diff --git a/hu_HU.ISO8859-2/books/handbook/l10n/chapter.sgml b/hu_HU.ISO8859-2/books/handbook/l10n/chapter.sgml index 4a21421564..de075e87ec 100644 --- a/hu_HU.ISO8859-2/books/handbook/l10n/chapter.sgml +++ b/hu_HU.ISO8859-2/books/handbook/l10n/chapter.sgml @@ -1,1348 +1,1348 @@ Andrey Chernov Írta: Michael C. Wu Átdolgozta: Honosítás: Az I18N/L10N használata és beállítása Áttekintés A &os; felhasználói földrajzi elhelyezkedésüket tekintve mindenhol megtalálhatóak a világon. Ebben a fejezetben ismertetjük a &os; honosításához és idegennyelvre fordításához alkalmazható eszközöket, amelyek segítségével az angolt nem, vagy csak kevésbé ismerõ felhasználók is képesek lesznek komolyabban használni. Az i18n megvalósítása rengeteg szemszögbõl megközelíthetõ rendszer és alkalmazás szintjén egyaránt, ezért ahol szükséges, hivatkozni fogunk az odaillõ forrásokra. A fejezet elolvasása során megismerjük: milyen nyelveket és nyelvi beállításokat találhatunk napjaink operációs rendszereiben; hogyan használjuk a nyelvi beállításokat a saját parancsértelmezõnkben; hogyan állítsuk be a konzolt az angolon kívül más nyelvekhez; hogyan használjuk ténylegesen az X Window Systemet a különbözõ nyelvekkel; hol olvashatunk többet az I18N-kompatibilis alkalmazások fejlesztésérõl. A fejezet elolvasásához ajánlott: külsõ alkalmazáok telepítésének ismerete (). Az alapok Mi az I18N/L10N? idegennyelvûség honosítás honosítás A fejlesztõk az I18N elnevezést az angol internationalization (idegennyelvûség) szóból származtatják, amiben a szám az elsõ és utolsó betû (az I és N) közt állók mennyiségére utal. Ehhez hasonlóan keletkezett az L10N a localization (honosítás) kifejezésbõl. Ezek házasságából jöttek létre az I18N/L10N módszerei, protokolljai és mindazon alkalmazásai, melyekkel a felhasználók a választott nyelvüket használni tudják. Az I18N alkalmazások céljak eléréséhez függvénykönyvtárakban implementált I18N készleteket használnak. Ezzel lehetõvé válik a fejlesztõik számára, hogy összegyûjtsék a programukban megjelenõ összes szöveget egyetlen állományba, majd azt külön lefordítsák a különbözõ nyelvekre. Mi is ezen konvenció követésére szeretnénk bíztatni minden programozót. Miért használjuk az I18N/L10N-t? Az I18N/L10N mindenhol jól jöhet, ahol idegennyelvû adatot akarunk megjeleníteni, bekérni vagy feldolgozni. Milyen nyelveket támogat az I18N? Az I18N és L10N nem korlátozódik a &os; tudására. Jelenleg a világban beszélt legelterjedtebb nyelvek mindegyikét használhatjuk bennük. Csak hogy néhányat említsünk közülük: kínai, német, japán, koreai, francia, orosz, vietnámi és még sok más. A honosítás használata Az I18N minden adottságával együtt független a &os;-tõl, egy egyezményes rendszer. Mindenkit bátorítunk arra, hogy segítse a &os;-t ennek az egyezménynek a betartásában. nyelvi beállítások A honosítás beállításai három fõbb részre tagolhatóak: a nyelv kódja, az ország kódja és a kódolás. A nyelvi beállítások nevei is ezekbõl állnak össze, az alábbi séma szerint: NyelviKód_OrszágKód.Kódolás A nyelv és az ország kódja nyelvi kódok országkódok Ha a &os; (vagy bármilyen más, az I18N-t ismerõ) rendszert honosítani akarunk az adott nyelvre, akkor a felhasználónak ismernie kell az adott országra és nyelvre vonatkozó kódokat (az országkód fogja elárulni az alkalmazásnak, hogy a nyelv melyik változatát használja). Ezenkívül a böngészõk, SMTP/POP szerverek és webszerverek stb. is ennek alapján fognak döntéseket hozni. Íme néhány nyelv/ország kódja: Nyelv/ország kódja Leírás en_US Angol - Egyesült Államok ru_RU Orosz - Oroszország zh_TW Hagyományos kínai - Tajvan Kódolások kódolások ASCII Bizonyos nyelvek 8 bites, széles vagy több byte-os, nem ASCII kódolású karaktereket használnak, melyekrõl a &man.multibyte.3; man oldalán olvashatunk részletesebben. Ezeket régebbi alkalmazások egyáltalán nem ismerik fel, és hibásan vezérlõkaraktereknek tulajdonítják. Az újabbak általában már felismerik a 8 bites karaktereket. A felhasználóknak az alkalmazásokat a széles vagy a több byte-os karakterek használatához vagy újra kell fordítaniuk, vagy pedig megfelelõen be kell állítaniuk, az implementációtól függõen. A széles vagy több byte-os karakterek beolvasásához és feldolgozásához a &os; Portgyûjtemény nyelvenként tartalmaz különféle programokat. A konkrét részletek megértéséhez olvassuk el az érintett &os; portok I18N dokumentációját. Vagyis a felhasználóknak át kell nézniük az alkalmazáshoz tartozó dokumentációt, mivel ebbõl tudhatják meg, hogyan állítsák be ezeket megfelelõen vagy milyen értékeket adjanak át a configure/Makefile/fordító hármasnak. Amiket esetleg érdemes lehet ezzel kapcsolatban észben tartanunk: A nyelvfüggõ egyszerû karakteres készletek (lásd &man.multibyte.3;), például ISO8859-1, ISO8859-15, KOI8-R, CP437. A széles vagy több byte-os kódolások, például az EUC, Big5. A karakterkészletek jelenleg elérhetõ listáját meg tudjuk tekinteni az IANA adatbázisában. A &os; helyettük X11-kompatibilis nyelvi kódolásokat használ. I18N alkalmazások A &os; port- és csomagrendszerében az I18N alkalmazások a könnyebb felismerhetõség érdekében a nevükben tartalmazzák az I18N megnevezést. Nem minden esetben támogatják a szükséges nyelvet. A nyelvi beállítások megadása Általában elegendõ annyi, hogy a kívánt nyelvi beállítás nevét exportáljuk az általunk használt parancsértelmezõ LANG környezeti változójába. Ez megtehetõ a felhasználói könyvtárunkban található ~/.login_conf, vagy a felhasználói parancsértelmezõ indító állományában (~/.profile, ~/.bashrc, ~/.cshrc). Nem szükséges a nyelvi beállítások részleteit, mint például az LC_CTYPE, LC_CTIME változókat, megadni. A pontosabb részleteket a &os; adott nyelvre vonatkozó dokumentációjában találjuk meg. A következõ két környezeti változót kell megadnunk az említett konfigurációs állományokban: POSIX A LANG változót a &posix; &man.setlocale.3; családjának MIME A MM_CHARSET változót az alkalmazás MIME karakterkészletéhez Ez magában foglalja a felhasználói parancsértelmezõ, az adott alkalmazás és az X11 beállítását. A nyelvi beállítások megadásának módszerei nyelvi beállítások bejelentkezési osztály Két módszer létezik a nyelvi beállítások megadására, ezen kettõrõl fogunk a továbbiakban beszélni. Az elsõ (és egyben ajánlott) ezek közül a bejelentkezési osztályban levõ környezeti változók beállítása, a második pedig környezeti változók hozzáadása a parancsértelmezõ rendszerszintû indító állományához. Beállítás a bejelentkezési osztályokkal Ezzel a módszerrel a nyelvi beállítás nevéhez és a MIME karakterkészlethez kötõdõ környezeti változókat az összes létezõ parancsértelmezõ számára csak egyszer kell megadnunk ahelyett, hogy külön mindegyikük indítóállományában szerepeltetnénk. A felhasználó a saját részét maga is elvégezheti, míg a rendszer szintjén adminisztrátori jogosultságokat igényel. Felhasználói szintû beállítás Íme példa gyanánt a felhasználó könyvtárában egy egyszerû .login_conf állomány, amiben mind a két változót Latin-1 kódolásra állítottuk: me:\ :charset=ISO-8859-1:\ :lang=de_DE.ISO8859-1: hagyományos kínaiBIG-5 kódolás Ebben a .login_conf példában a változókat BIG-5 kódolású hagyomános kínai nyelvre állítjuk. Észrevehetjük, hogy itt sokkal több változó beállítására van szükségünk, mivel egyes szoftverek nem kezelik megfelelõen a nyelvi beállításokat kínai, japán és koreai nyelvek esetén. # Azok a felhasználók, akik nem kívánnak tajvani pénz- vagy idõ formátumot # használni, egyenként írják át a változókat me:\ :lang=zh_TW.Big5:\ - :setenv=LC_ALL=zh_TW.Big:\ + :setenv=LC_ALL=zh_TW.Big5:\ :setenv=LC_COLLATE=zh_TW.Big5:\ :setenv=LC_CTYPE=zh_TW.Big5:\ :setenv=LC_MESSAGES=zh_TW.Big5:\ :setenv=LC_MONETARY=zh_TW.Big5:\ :setenv=LC_NUMERIC=zh_TW.Big5:\ :setenv=LC_TIME=zh_TW.Big5:\ :charset=big5:\ :xmodifiers="@im=gcin": # a gcin beállítása XIM szerverként A többit lásd a Rendszergazdai szintû beállítások résznél és a &man.login.conf.5; man oldalon. Rendszergazdai szintû beállítás Ellenõrizzük, hogy a felhasználó /etc/login.conf állományban szereplõ bejelentkezési osztálya a megfelelõ nyelvet állítja be. Gyõzõdjünk meg róla, hogy az alábbi beállítások helyet kapnak az /etc/login.conf állományban: nyelv_neve|A hozzáférés típusának leírása:\ :charset=MIME_karakterkészlet:\ :lang=nyelvi_beállítás_neve:\ :tc=default: Folytassuk tovább az elõbbi Latin-1-es példánk szerint: nemet|Nemet felhasznalok hozzaferesei:\ :charset=ISO-8859-1:\ :lang=de_DE.ISO8859-1:\ :tc=default: Mielõtt megváltoztatnánk a felhasználók bejelentkezési osztályait, adjuk ki a következõ parancsot: &prompt.root; cap_mkdb /etc/login.conf Ezzel a /etc/login.conf új tartalma láthatóvá válik a rendszer számára. A bejelentkezési osztály megváltoztatása a &man.vipw.8; programmal vipw A vipw segédprogramot új felhasználók hozzáadására használjuk, aminek eredményeképpen egy ehhez hasonló bejegyzést tudunk létrehozni: felhasznalo:jelszo:1111:11:nyelv:0:0:Felhasznalo neve:/home/felhasznalo:/bin/sh A bejelentkezési osztály megváltoztatása az &man.adduser.8;-rel adduser bejelentkezési osztály Az adduser-rel az alábbiak szerint tudunk új felhasználókat felvenni a rendszerbe: Adjuk hozzá a defaultclass = nyelv sort az /etc/adduser.conf-hoz. Ne felejtsük el, hogy ezután minden olyan felhasználónál a default bejelentkezési osztályt meg kell adni, akik nem ezt a nyelvet használják. Egy másik megoldás lehet, hogy a &man.adduser.8; használata során minden felhasználó esetén külön megadjuk a nyelvet az Enter login class: default []: rész megjelenésekor. Vagy használhatjuk az alábbit az egyes eltérõ nyelvû felhasználók hozzáadásánál: &prompt.root; adduser -class nyelv A bejelentkezési osztály megváltoztatása a &man.pw.8;-vel pw Amennyiben a &man.pw.8;-t használjuk új felhasználók hozzáadására, így érdemes meghívnunk: &prompt.root; pw useradd felhasználó_neve -L nyelv Beállítás a parancsértelmezõ indító állományával Ezt a módszert nem javasoljuk, mivel parancsértelmezõnként eltérõ beállítást kíván. Használjuk helyette a bejelentkezési osztályokkal megvalósított módszert. MIME nyelvi beállítás A nyelvi beállítás nevének és a MIME karakterkészlet beállításához egyszerûen csak adjuk meg a lenti /etc/profile és/vagy /etc/csh.login parancsértelmezõ indító állományokban bemutatott környezeti változót. Továbbra is a német nyelvet használjuk a példánkban: Az /etc/profile esetén: LANG=de_DE.ISO8859-1; export LANG MM_CHARSET=ISO-8859-1; export MM_CHARSET Vagy a /etc/csh.login esetén: setenv LANG de_DE.ISO8859-1 setenv MM_CHARSET ISO-8859-1 Úgy is megoldhatjuk ezt a feladatot, ha fenti utasításokat a /usr/share/skel/dot.profile (hasonló a fentebb említett /etc/profile állományhoz) vagy /usr/share/skel/dot.login (hasonló a fentebb említett /etc/csh.login állományhoz) esetén hajtjuk végre. X11 esetén: Adjuk meg a $HOME/.xinitrc állományban: LANG=de_DE.ISO8859-1; export LANG Vagy: setenv LANG de_DE.ISO8859-1 Attól függõen, milyen parancsértelmezõt használunk (lásd fentebb). A konzol beállítása Az összes egyszerû karakteres készlet esetén a kérdéses nyelvhez megfelelõ konzolos betûtípust az /etc/rc.conf állományban tudjuk beállítani: font8x16=betûtípus_neve font8x14=betûtípus_neve font8x8=betûtípus_neve Itt a betûtípus_neve az .fnt kiterjesztés elhagyásával a /usr/share/syscons/fonts könyvtárban található állományok nevébõl adható meg. sysinstall billentyûkiosztás betûkiosztás Ha szükséges állítsuk még be a megfelelõ billentyû- és betûkiosztást is a sysinstall segítségével. Ahogy sikerült elindítanunk a sysinstallt, válasszuk a Configure (Beállítások) pontot, majd a Console (Konzol)-t! Vagy ehelyett beírhatjuk az alábbi sorokat a /etc/rc.conf állományba: scrnmap=betûkiosztás_neve keymap=billentyûkiosztás_neve keychange="funkcióbillentyû_sorszáma szekvencia" Itt a betûkiosztás_neve a /usr/share/syscons/scrnmaps könyvtárban található állományok nevébõl származtatható az .scm kiterjesztés elhagyásával. A betûkiosztásokat általában a 9 bites karaktermátrixszal rendelkezõ VGA megjelenítõk problémáinak megoldására lehet használni, mivel így az eredetileg 8 bittel ábrázolt betûket ki lehet tolni az ilyen típusú kártyák pszeudografikus területérõl. Ha aktiváltuk a moused egérkezelõ démont az /etc/rc.conf állományban az alábbi sor megadásával: moused_enable="YES" akkor a következõ bekezdésben rá is térhetünk az egérmutató adatainak vizsgálatára. moused A &man.syscons.4; meghajtóban található egérmutató alapértelmezés szerint a 0xd0 - 0xd3 karaktereket foglalja el a karakterkészletben. Ha a nyelv ezeket használja, arrébb kell költöztetnünk ezt az egérmutató által elfoglalt sávot. A &os;-ben az /etc/rc.conf állományon keresztül érhetjük el: mousechar_start=3 A billentyûkiosztás_neve a /usr/share/syscons/keymaps könyvtárból, a .kbd kiterjesztés elhagyásával keletkezik. Ha nem vagyunk benne biztosak, melyik kiosztást is kellene használnunk, a &man.kbdmap.1; segítségével a rendszer újraindítása nélkül kipróbálhatjuk a rendelkezésre álló billentyûkiosztásokat. A keychange használatára többnyire a funkcióbillentyûk adott termináltípushoz egyeztetéséhez van szükség, mert a funkcióbillentyûk szekvenciái nem adhatóak meg a billentyûkiosztásban. Ezeken felül érdemes megbizonyosodnunk róla, hogy a /etc/ttys állományban jól állítjuk be a terminál típusát minden ttyv* bejegyzés esetén. Az aktuálisan elõre beállított kapcsolatok a következõk: Karakterkészlet Termináltípus ISO8859-1 vagy ISO8859-15 cons25l1 ISO8859-2 cons25l2 ISO8859-7 cons25l7 KOI8-R cons25r KOI8-U cons25u CP437 (alapértelmezett VGA) cons25 US-ASCII cons25w A széles és több byte-os karaktereket használó nyelvek esetén használjuk a /usr/ports/nyelv könyvtárban megfelelõ &os; portot. Egyes portok konzolosként jelennek meg, miközben a rendszer soros virtuális terminálként látja ezeket, ezért fenn kell tartanunk elegendõ virtuális terminált mind az X11, mind pedig pszeudo-soros konzol számára. Itt látható a konzolon más nyelvet használó alkalmazások részleges listája: Nyelv Hely Hagyományos kínai (BIG-5) chinese/big5con Japán japanese/kon2-16dot vagy japanese/mule-freewnn Koreai korean/han Az X11 beállítása Habár az X11 nem része a &os; projektnek, megemlítünk vele kapcsolatban néhány hasznos információt a &os; felhasználók számára is. Még több részletet a &xorg; honlapjáról vagy az általunk használt X11 szerver dokumentációjából tudhatunk meg. Az ~/.Xresources állományban további I18N beállításokat finomíthatunk alkalmazásonként (például betûtípusok, menük stb.). Betûtípusok megjelenítése X11 True Type betûtípus szerver Telepítsük fel az &xorg; (x11-servers/xorg-server) vagy az &xfree86; (x11-servers/XFree86-4-Server) szerverek valamelyikét, majd telepítsük a nyelvhez tartozó &truetype; betûtípusokat. Ezután a megfelelõ nyelvi beállítása megadása révén már látni fogjuk a kiválasztott nyelven megjelenõ menüket és egyéb szövegeket. Idegennyelvû karakterek bevitele X11 Input Method (XIM) Az X11 beviteli módszerének (X11 Input Method, XIM) protokollja egy új szabvány az összes X11 klienshez. Minden X11 alkalmazást olyan XIM-kliensként kell elkészíteni, amelyek a bemenõ adatokat az XIM beviteli szerverektõl kapják. Különbözõ XIM szerverek érhetõek el az eltérõ nyelvekhez. Nyomtatók beállítása Egyes egyszerû karakteres készletek általában hardveresen beépítve megtalálhatóak a nyomtatókban. A széles és több byte-os karakterkészletek azonban külön beállítást igényelnek, amire az apsfilter használatát javasoljuk. A megfelelõ nyelvhez szabott eszközökkel át is lehet konvertálni &postscript; vagy PDF formátumba a nyomtatni kívánt dokumentumot. A rendszermag és az állományrendszerek A &os; gyors állományrendszere (Fast File System, FFS) szabályosan kezeli a 8 bites karaktereket, tehát tetszõleges egyszerû karakteres készlet (lásd &man.multibyte.3;) használható vele, viszont a karakterkészlet nevét nem tárolja el az állományrendszerben. Emiatt a neveket nyersen kezeli, semmit sem tud a kódolásukról. Az FFS hivatalosan még nem támogat semmilyen fajta széles vagy több byte-os karakterkészletet. Léteznek azonban független javítások az FFS-hez, amelyek lehetõvé teszik ilyen széles vagy több byte-os karakterek használatát. Ezek csak átmeneti és nem hordozható megoldások, olyan módosítások, amelyekrõl úgy döntöttünk, nem vesszük fel ezeket a forrásfába. Az érintett nyelvek honlapjain elérhetjük ezeket a javításokat és többet megtudhatunk róluk. DOS Unicode A &os; &ms-dos; állományrendszere konfigurálható úgy, hogy képes legyen konvertálni az &ms-dos; Unicode és a kiválasztott &os; állományrendszerének karakterkészlete között. Errõl bõvebben a &man.mount.msdosfs.8; man oldalon olvashatunk. I18N programok fordítása Számos &os; port rendelkezik I18N támogatással. Ezek egy részének nevében szerepel az -I18N jelzés. Az ilyen és sok más hasonló program beépítetten ismeri az I18N-t, így nem igényelnek külön beállításokat. MySQL Néhány alkalmazás azonban, mint például a MySQL, esetén az adott karakterkészletnek megfelelõ módon kell beállítani a Makefile állományt. Ezt általában magában a Makefile állományban tudjuk megtenni, vagy pedig a configure megfelelõ paraméterezésével. A &os; honosítása adott nyelvekre Andrey Chernov Eredetileg írta: Az orosz nyelv (KOI8-R kódolás) honosítás orosz A KOI8-R kódolásról bõvebben a KOI8-R oldalán (orosz hálózati karakterkészlet) tájékozódhatunk. A nyelvi beállítások megadása Írjuk a következõ sorokat a ~/.login_conf állományunkba: me:Az en hozzaferesem:\ :charset=KOI8-R:\ :lang=ru_RU.KOI8-R: Valamint lásd a fejezet korábbi részeiben említett példákat a nyelvi beállítások megadására. A konzol beállítása Tegyük hozzá a következõ sort az /etc/rc.conf állományunkhoz: mousechar_start=3 Illetve használjuk az /etc/rc.conf állományban még a következõ beállításokat is: keymap="ru.koi8-r" scrnmap="koi8-r2cp866" font8x16="cp866b-8x16" font8x14="cp866-8x14" font8x8="cp866-8x8" A /etc/ttys állományban szereplõ mindegyik ttyv* bejegyzésnél adjuk meg termináltípusnak a cons25r-t. Valamint lásd a fejezet korábbi részében bemutatott példákat a konzol beállítására. A nyomtatás beállítása nyomtatók Mivel a legtöbb nyomtató hardveresen tartalmazza a CP866 kódlapot az orosz karakterek támogatásához, használnunk kell egy kimeneti szûrõt a KOI8-R kódolású karakterek CP866 kódolásúra konvertálásához. Egy ilyen szûrõ alapértelmezés szerint telepítésre kerül a /usr/libexec/lpr/ru/koi2alt állományba. Az orosz nyomtatóhoz tartozó bejegyzés valahogy így néz ki az /etc/printcap állományban: lp|Orosz helyi sornyomtato:\ :sh:of=/usr/libexec/lpr/ru/koi2alt:\ :lp=/dev/lpt0:sd=/var/spool/output/lpd:lf=/var/log/lpd-errs: A bõvebben magyarázathoz lásd a &man.printcap.5; man oldalt. Az &ms-dos; állományrendszere és az orosz állománynevek A most következõ példa &man.fstab.5; bejegyzés azt mutatja meg, hogy lehet bekapcsolni az orosz állománynevek támogatását a csatlakoztatandó &ms-dos; állományrendszereken: /dev/ad0s2 /dos/c msdos rw,-Wkoi2dos,-Lru_RU.KOI8-R 0 0 Az kapcsolóval kiválasztjuk a használni kívánt nyelvi beállítás nevét, és a kapcsolóval megadjuk a karakterek átváltásához szükséges táblázatot. A kapcsoló használata során mindenképpen csatlakoztassuk a /usr állományrendszert még az &ms-dos; partíció elõtt, mivel az átváltáshoz használt táblázatok a /usr/libdata/msdosfs könyvtárban találhatóak meg! A részleteket a &man.mount.msdosfs.8; man oldalon találhatjuk meg. Az X11 beállítása Adjuk meg elõször a leírtak szerint a nem X-es nyelvi beállításokat. Ha &xorg;-ot használunk, telepítsük a x11-fonts/xorg-fonts-cyrillic csomagot. Ellenõrizzük a /etc/X11/xorg.conf állományban a "Files" szakaszt. Az alábbi sort mindegyik más FontPath bejegyzés elõtt kell szerepeltetnünk: FontPath "/usr/X11R6/lib/X11/fonts/cyrillic" A portok között találhatunk még további cirill betûtípusokat. Az orosz billentyûzet életre keltéséhez írjuk be a következõket az xorg.conf állomány "Keyboard" szakaszába: Option "XkbLayout" "us,ru" Option "XkbOptions" "grp:toggle" Ellenõrizzük, hogy a XkbDisable ki van kapcsolva (ki van kommentezve) ebben a szakaszban. A grp:toggle beállítás esetén az orosz/latin (RUS/LAT) átkapcsolás gombja a jobb Alt lesz, míg a grp:ctrl_shift_toggle beállításnál a CtrlShift. A grp:caps_toggle esetén az orosz/latin váltás a CapsLock billentyûvel történik. Ilyenkor (de csak latin módban) a megszokott CapsLock funkció továbbra is elérhetõ a ShiftCapsLock kombinációval. A grp:caps_toggle valamiért nem mûködik az &xorg;ban. Ha van &windows; billentyûnk a billentyûzeten és azt tapasztaljuk, hogy egyes nem-alfabetikus billentyûk rosszul kerülnek kiosztásra orosz módban, adjuk hozzá a következõ sort az xorg.conf állományhoz: Option "XkbVariant" ",winkeys" Az orosz XKB billentyûzet egyes nem honosított alkalmazások esetén nem mûködik. A kis mértékben honosított alkalmazások esetén javasolt meghívni a XtSetLanuageProc(NULL, NULL, NULL); függvényt valahol a program elején. Az X11 alkalmazások honosításához további útmutatásokat a KOI8-R X Window-ra címû leírásban találhatunk. Hagyományos kínai honosítás tajvaniak számára honosítás hagyományos kínai A &os;-Taiwan projekt készített a &os;-hez egy kínainak szóló hogyant, amely elérhetõ a címen és számos kínai portot használ. A &os; kínai hogyan jelenlegi szerkesztõje Shen Chuan-Hsing (statue@freebsd.sinica.edu.tw). Chuan-Hsing Shen (statue@freebsd.sinica.edu.tw) létrehozta a Kínai &os; gyûjteményt (Chinese &os; Collection, CFC) a &os;-Taiwan zh-L10N-tut munkáját felhasználva. A hozzátartozó csomagok és szkriptek elérhetõek a címen. Honosítás német (és minden más ISO 8859-1 kódolású) nyelvre honosítás német Slaven Rezic (eserte@cs.tu-berlin.de) készített egy írást, amely elmagyarázza, hogyan használjunk német nemzeti karaktereket a &os; alatt. Ez a leírás németül készült és a címen érhetõ el. Honosítás görög nyelvre honosítás görög Nikos Kokkalis nickkokkalis@gmail.com egy teljes cikket írt a &os; görög nyelvi támogatásáról. Ez elérhetõ a &os; hivatalos görög nyelvû dokumentációjában, a címen. Felhívjuk a figyelmet, hogy az csak görög nyelven érhetõ el. Honosítás japán és koreai nyelvekre honosítás japán honosítás koreai A japán honosításhoz lásd , a koreaihoz pedig lásd . Idegennyelvû &os; dokumentáció Néhány &os; felhasználó lefordította a &os; dokumentációjának egyes részeit más nyelvekre is. Munkájuk elérhetõ a fõoldalon található linkeken keresztül vagy a /usr/share/doc könyvtárban. diff --git a/hu_HU.ISO8859-2/books/handbook/printing/chapter.sgml b/hu_HU.ISO8859-2/books/handbook/printing/chapter.sgml index ee3c377aa0..fda48768fb 100644 --- a/hu_HU.ISO8859-2/books/handbook/printing/chapter.sgml +++ b/hu_HU.ISO8859-2/books/handbook/printing/chapter.sgml @@ -1,6948 +1,6948 @@ Sean Kelly Írta: Jim Mock Átdolgozta és frissítette: Nyomtatás Áttekintés LPD nyomtatási rendszer nyomtatás A &os; képes rengeteg féle és fajta nyomtatóval együttmûködni, a legrégebbi vegyszeres nyomtatótól kezdve egészen napjaink lézernyomtatójáig, aminek köszönhetõen alkalmazásaikkal nagyon jó minõségû nyomtatásokat tudunk készíteni. A &os; a helyi hálózaton nyomtatószervernek is beállítható. Ekkor a vele közös hálózatra csatlakozó többi, &os;, &windows; vagy &macos; rendszerû számítógéptõl képes nyomtatási kéréseket elfogadni. A &os; gondoskodik róla, hogy egyszerre csak egy nyomtatás készüljön el, számon tartja, hogy mely felhasználók és számítógépek nyomtatnak a legtöbbet, és minden feladathoz munkalapot (banner page) készít, amiben többek közt megtalálhatjuk, hogy kihez tartozik. A fejezet elolvasása során megismerjük: hogyan állítsuk be a &os; nyomtatási sorát; hogyan telepítsünk nyomtatási szûrõket, hogyan kezeljünk különbözõ speciális nyomtatási feladatokat, tehát például miként alakítsuk át a beérkezõ dokumentumokat olyan nyomtatási formátumra, amelyet a nyomtatónk is megért; hogyan engedélyezzük a fejléc- vagy munkainformációk kinyomtatását; hogyan nyomtassunk más számítógépekhez csatlakoztatott nyomtatókkal; hogyan nyomtassunk a hálózatra közvetlenül kapcsolt nyomtatókkal; hogyan állítsuk be a nyomtató korlátait, például a nyomtatási munkák méretét, amivel egyes felhasználók nyomtatását visszafoghatjuk; hogyan készítsünk nyomtatási kimutatásokat és nyilvántartást a nyomtató használatáról; hogyan keressük meg a nyomtatás során felmerül problémák okait. A fejezet elolvasásához ajánlott: egy új rendszermag beállításának és telepítésének ismerete (). Bevezetés A &os;-ben a nyomtatók mûködéséhez be kell állítani az LPD nyomtatási rendszert. Ez a Berkeley sornyomtatási rendszere, amelyet ezentúl röviden csak LPD-nek fogunk hívni. Ez a &os; alapértelmezett szabványos nyomtatásvezérlõ rendszere. Ebben a fejezetben az LPD és annak konfigurációja kerül bemutatásra. Ha már találkoztunk az LPD-vel vagy hozzá hasonló rendszerekkel, akkor innen nyugodtan ugorhatunk az Kezdeti beállítások címû szakaszra. Az LPD vezérli a számítógéphez csatlakoztatott nyomtató összes funkcióját. Számos feladata van: Felügyeli a lokálisan és hálózaton keresztül csatlakoztatott nyomtatók hozzáféréseit. nyomtatási munkák Lehetõvé teszi az átküldött állományok kinyomtatását, amelyeket munkáknak nevezünk. Minden nyomtatóhoz fenntart egy nyomtatási sort, amivel meg tudja akadályozni, hogy egyszerre több felhasználó is hozzá tudjon férni az egyes nyomtatókhoz. A fejléceket (vagy más néven munka- vagy elválasztó lapokat) nyomtat, így a felhasználók könnyen megtalálják a saját nyomtatásaikat a többi közt. Felügyeli a soros portokon csatlakozó nyomtatók kommunikációs beállításait. A hálózaton keresztül átküli a munkákat egy másik számítógép LPD sorába. A nyomtatandó munkák formázásához lefuttatja az adott nyomtató nyelvéhez és képességeihez illeszkedõ speciális szûrõket. Nyilvántartja a nyomtató kihasználtságát. A beállításait tartalmazó állomány (/etc/printcap) és a speciális szûrõprogramok segítségével az LPD sokféle nyomtatón képes az összes említett feladatot vagy annak egy részét megvalósítani. Amiért nyomtatási sort érdemes használni Amikor csak egyedül vagyunk a rendszerben, felmerülhet bennünk a kérdés, hogy minek is kellene nekünk veszõdni a nyomtatási sor beállításával, hiszen nincs szükségünk sem a hozzáférések vezérlésére, sem fejlécekre, sem pedig nyilvántartásra. Noha akár közvetlenül is el tudjuk érni a nyomtatót, néhány okból azért mégis érdemes nyomtatási sort használni: Az LPD a háttérben nyomtat, ezért ilyenkor nem kell megvárni, amikor az adat átmásolódik a nyomtatóra. &tex; Az LPD tetszõlegesen tudja alakítani a nyomtatási munkákat: hozzájuk tud tenni különbözõ adatokat (dátum és idõ), vagy a speciális állományokat (például a &tex; DVI formátumát) képes megértetni a nyomtatóval, és nem nekünk kell mindezeket a lépéseket elvégeznünk. Számos nyomtatási lehetõséggel rendelkezõ szabad és kereskedelmi program arra számít, hogy a rendszerünkben nyomtatási sor található, ezért egy ilyen beállításával sokkal könnyebb használni ezeket a szoftvereket. Kezdeti beállítások Úgy tudjuk használni a nyomtatókat az LPD nyomtatási rendszerével, ha egyaránt beállítjuk a nyomtatót és magát az LPD-t is. Itt a beállítás két szintjét tárgyaljuk: Az Alacsonyszintû nyomtatóbeállítás címû szakaszból megtudhatjuk, hogyan tudunk csatlakoztatni egy nyomtatót, hogyan adjuk meg az LPD-nek, miként kommunikáljon vele, hogyan nyomtassunk ki egyszerû szöveges állományokat a nyomtatón. A Magasszintû nyomtatóbeállítás szakaszban bemutatjuk, hogyan nyomtassunk ki különféle speciális állományokat, hogyan készítessünk fejléceket, hogyan nyomtassuk hálózaton keresztül, hogyan vezéreljük a nyomtatók hozzáférését és hogyan tartsuk nyilván a nyomtató használatát. Alacsonyszintû nyomtatóbeállítás Ebben a szakaszban láthatjuk, miképpen kell beállítani a nyomtatónkat és az LPD hogyan lesz képes azt használatba venni. Az alapoktól kezdünk: A Hardveres beállítás címû szakaszban abban kapunk segítséget, hogyan kell a nyomtatót a számítógéphez csatlakoztatni. A Szoftveres beállítás címû szakaszban az LPD nyomtatási rendszer beállítását tartalmazó állományt (/etc/printcap) vesszük sorra. Amennyiben olyan nyomtatót akarunk beállítani, amely nem helyileg, hanem valamilyen hálózati protokollon keresztül csatlakozik, nézzük meg a Nyomtatók hálózati adatcsatlakozással címû szakaszt. Habár ez a szakasz nevében csupán Alacsonyszintû nyomtatóbeállításról szól, meglehetõsen szerteágazó tud lenni. A nyomtató hardveres és szoftveres életre keltése az egyik legnehezesebb feladat. Ha van egy mûködõ nyomtatónk, a fejlécek és a nyilvántartás beállítása tulajdonképpen már gyerekjáték. Hardveres beállítás Ebben a szakaszban a nyomtatók csatlakoztatásának lehetséges módozatairól esik szó. Beszélni fogunk mindenféle portokról és kábelekrõl, és a &os; rendszermagjának az egyes nyomtatók használatához szükséges beállításairól is. Ha korábban tudtuk csatlakoztatni a nyomtatónkat, és más operációs rendszerekkel már sikeresen is nyomtattunk vele, akkor rögtön ugorhatunk is a Szoftveres beállításokat tartalmazó szakaszra. Portok és kábelek A személyi számítógépekhez kapható nyomtatók általában a következõ három csatolófelület egyikével rendelkeznek: nyomtató soros A soros, más néven RS-232-es vagy COM porton keresztül kommunikáló felületek a számítógép soros portján küldenek adatot a nyomtatónak. A soros csatolófelületek igen elterjedtek a számítógépiparban, könnyen tudunk ilyen kábelt szerezni, gyorsan is gyártható. Elõfordulhat, hogy a soros csatolófelületek használatához valamilyen különleges kábelre, valamint bonyolult kommunikációs beállítások megadására van szükség. A legtöbb soros port által elérhetõ legnagyobb adatátviteli sebesség másodpercenként 115 200 bit, ami miatt azonban a komolyabb grafikai tartalmak nyomtatása szinte lehetetlen. nyomtató párhuzamos A párhuzamos csatolófelületek a számítógépünk párhuzamos portjával küldenek adatokat a nyomtatónak. A párhuzamos felületek gyorsabbak az RS-232 soros felületnél, és a számítógéppiacon is gyakran megtalálhatóak. Könnyen tudunk ilyen kábelt szerezni, azonban kézileg nehezebb elkészíteni. A párhuzamos csatolófelületekhez általában nem tartoznak kommunikációs beállítások, ezért rendkívül egyszerûen el lehet boldogulni velük. centronics párhuzamos nyomtató A párhuzamos felületekre olykor Centronics csatolófelületként is hivatkoznak, amelyet egy nyomtatótípus után neveztek el. nyomtató USB A Universal Serial Bus (Univerzális soros busz) rövidítéseként használt USB elnevezésû csatolófelület a párhuzamos és a soros felületeknél jóval nagyobb sebességre képes. A hozzátartozó kábelek felépítése egyszerû és az áruk olcsó. Habár a nyomtatás terén az USB hivatott leváltani az RS-232-es soros és a párhuzamos felületeket, nem mindegyik &unix; rendszer támogatja kellõképpen. Ezt a problémát például úgy kerülhetjük el, ha olyan nyomtatót vásárolunk, amelyen a legtöbbhöz hasonlóan a párhuzamos és az USB csatlakozás is megtalálható. A párhuzamos felületeken általában csak egy irányban tudunk üzeneteket küldeni (a számítógéptõl a nyomtatóhoz), miközben az USB és a soros felület használatával mind a két irányban is. &os; alatt viszont már az újabb (EPP és ECP) párhuzamos portok egy IEEE 1284 szabványú kábellel képesek oda-vissza kommunikálni. PostScript A párhuzamos nyomtatók kétirányú kommunikációját általában két mód közül az egyiken szokták megvalósítani. Az elsõ esetben a &os; a nyomtatóhoz egy speciális meghajtót használ, amely ismeri az általa beszélt nyelvet. Ilyenek a tintasugaras nyomtatók, amelyek más egyéb állapotinformációk mellett ezen keresztül képesek jelezni a tinapatronokban levõ tinta mennyiségét. A második esetben a nyomtató ismeri a &postscript; nyelvet. A &postscript; nyelvû munkák valójában a nyomtatónak küldött programok. Használatukhoz még papírra sincs feltétlenül szükség, és adódhat, hogy közvetlenül a számítógépnek válaszolnak. A &postscript; is kétirányú kommunikáción keresztül értesíti a számítógépet az olyan gondokról, mint például a &postscript; programokban levõ hibák vagy a papír beakadása, amely információnak a felhasználók szoktak örülni. Hovatovább ez a kétirányú kommunikáció a kulcsa a &postscript; nyomtatók hatékony nyilvántartásának is: egyszerûen lekérdezzük a nyomtatótól a lapszámlálót (ami megadja, hogy a nyomtató eddig mennyi lapot nyomtatott ki), kiküldjük a felhasználóhoz tartozó feladatot és ismét lekérdezzük a lapszámlálót. A két érték kivonásából tájékozódhatunk a felhasználó által igényelt lapok mennyiségérõl. Párhuzamos portok A párhuzamos csatolófelületen érintkezõ nyomtató használatához kapcsoljunk össze számítógépünket és nyomtatónkat egy párhuzamos kábellel. Az erre vonatkozó konkrét utasítások a nyomtató és/vagy a számítógép kézikönyvében olvashatóak. Jegyezzük meg, hogy a számítógép melyik párhuzamos portjára csatlakoztattuk a kábelt. &os; alatt az elsõ ilyen port a ppc0 eszköz, a második pedig a ppc1 eszköz lesz és így tovább. A nyomtatóeszköz elnevezése ugyanezt a sémát követi: a /dev/lpt0 lesz az elsõ párhuzamos porton levõ nyomtató stb. Soros portok A soros csatolófelületet használó nyomtatók beüzemeléséhez elõször egy soros kábel segítségével kapcsoljuk össze a számítógépünkkel. Ennek pontos részleteit a nyomtató és/vagy a számítógépünk kézikönyvében találhatjuk meg. Ha nem vagyunk benne biztosak, hogy milyen a megfelelõ soros kábel, próbáljunk az alábbiak alapján dönteni: A modem kábele a két oldalán levõ az egymásnak megfelelõ tüskéket közvetlenül összeköti. Ezt a típust nevezik DTE-DCE kábelnek. null-modem kábel A null-modem kábel bizonyos érintkezõket rendesen, másokat pedig fordítva köt össze (például a küldõt a fogadóval), illetve némelyeket rövidre zár közvetlenül a csatlakozón belül. Ez a típus a DTE-DTE kábel. Néhány speciális nyomtató esetén elõfordul még a soros nyomtatókábel, amelyek leginkább a null-modem kábelekez hasonlítanak, azonban az ott rövidre zárt csatornák itt a nekik megfelelõ érintkezõknek továbbítanak jeleket. jelváltási sebesség paritás forgalomirányítási protokoll Emellett még a nyomtató elõlapján vagy az alján található kapcsolók segítségével be kell állítanunk a nyomtatóhoz tartozó kommunikációs paramétereket is. Itt válasszuk azt a bps (a bitek száma másodpercenként) értéket, amelyet még a számítógépünk és a nyomtatónk is egyaránt képes támogatni. Válasszunk 7 vagy 8 adatbitet, páros, páratlan vagy kikapcsolt paritásbitet és 1 vagy 2 stopbitet. Ekkor tudjuk megadni a forgalomirányítási protokollt is: lehet kikapcsolt, XON/XOFF (ez az ún. sávon belüli vagy szoftveres) forgalomirányítás. Ne felejtsük el ezeket a beállításokat a most következõ szoftveres beállítások elvégzése során sem. Szoftveres beállítás Ebben a fejezetben tárgyaljuk a &os;-ben található LPD nyomtatási rendszer mûködéséhez és a nyomtatáshoz szükséges szoftveres beállításokat. Íme az elvégzendõ lépések rövid vázlata: Amennyiben szükséges, állítsuk be a rendszermagunkat nyomtató által használt portra. Ehhez A rendszermag beállítása szakaszban olvashatjuk mit is kell pontosan tenni. Ha párhuzamos portot használunk, akkor állítsuk be, hogy a párhuzamos port miként fog kommunikálni. A párhuzamos port kommunikációs módjának beállítása címû szakasz tárja fel ennek részleteit. Próbáljuk ki, hogy ezek után az operációs rendszer képes-e adatot küldeni a nyomtatónak. A nyomtató kommunikációjának ellenõrzése szakaszban kapunk erre pár javaslatot. Az /etc/printcap állomány felhasználásával állítsuk be a nyomtatónkhoz a LPD-t. Errõl a fejezet további részei adnak majd felvilágosítást. A rendszermag beállítása Az operációs rendszer magja eszközök egy adott csoportjával képes együttmûködni, amiben a soros és párhuzamos felületen csatlakozó nyomtatók is megtalálhatóak. Azonban ha a rendszermag nem ismeri fel még valamelyiket, akkor a soros vagy párhuzamos portok használatához külön támogatásra van szükség. Így tudjuk megnézni, hogy a jelenleg használt rendszermag támogatja-e a soros csatolófelületet: &prompt.root; grep sioN /var/run/dmesg.boot Itt az N nullától kezdõdõen adja meg a soros port sorszámát. Amennyiben látunk valami ilyesmit: sio2 at port 0x3e8-0x3ef irq 5 on isa sio2: type 16550A Ez azt jelenti, hogy a rendszermag sikeresen észlelte a portot. A párhuzamos csatolófelület támogatásáról így gyõzõdhetünk meg: &prompt.root; grep ppcN /var/run/dmesg.boot Itt az N nullától kezdõdõen sorszámozza a párhuzamos portot. Ha eredményül valami hasonlót kapunk: ppc0: <Parallel port> at port 0x378-0x37f irq 7 on isa0 ppc0: SMC-like chipset (ECP/EPP/PS2/NIBBLE) in COMPATIBLE mode ppc0: FIFO with 16/16/8 bytes threshold Ez arra utal, hogy a rendszermagunk tud a portról. Elõfordulhat azonban, hogy az operációs rendszer csak akkor fogja észrevenni a nyomtatásra használt soros vagy párhuzamos portot, ha átállítjuk a rendszermagunkat. A soros port támogatásának beállításához olvassuk el a rendszermag beállításáról szóló szakaszt. A párhuzamos port támogatásához szintén olvassuk el ugyanazt a szakaszt és a most a következõt. A párhuzamos port kommunikációs módjának beállítása A párhuzamos csatolófelület használata esetén választhatunk, hogy a &os; milyen módon tartsa a kapcsolatot a nyomtatóval: megszakításokkal vezérelje (interrupt-driven) vagy esetleg folyamatosan kérdezgesse (polled). A &os; általános meghajtója (&man.lpt.4;) a &man.ppbus.4; alrendszert használja, ami a portot a &man.ppc.4; meghajtón keresztül vezérli. A megszakítás alapú módszer a GENERIC rendszermagban alapértelmezés. Ilyenkor az operációs rendszer egy megszakításkérés felhasználásával értesül arról, hogy a nyomtató mikor áll készen adatok fogadására. A lekérdezéses módszer használata során az operációs rendszer folyamatosan érdeklõdik a nyomtató rendelkezésre állásáról. Amikor erre pozitív megerõsítést kap, akkor a rendszermag újabb adatokat küld. A megszakításos módszer valamivel gyorsabb, azonban cserébe lefoglal egy értékes IRQ vonalat. A HP újabb nyomtatói állítólag nem mûködnek megfelelõen ilyen módban, valamilyen (pillanatnyilag még nem teljesen tisztázott) idõzítési probléma miatt. Ezért az ilyen nyomtatóknak is valószínûleg a lekérdezéses módszer kell használniuk. Más nyomtatók pedig habár mûködnek mind a két módszerrel, hihetetlenül lassúak a megszakításokkal. Kétféleképpen állíthatjuk be a kommunikációs módot: a rendszermagon keresztül, vagy az &man.lptcontrol.8; segédprogrammal. A rendszermagban így állíthatjuk be a kommunikációt: Írjuk át a rendszermag beállításait tartalmazó állományt. Keressük meg benne a használt párhuzamos portnak megfelelõen a ppc0, ppc1 (második párhuzamos port) vagy ppc2 (harmadik párhuzamos port) bejegyzést, és engedélyezzük. A megszakításos mód használatához nyissuk meg a /boot/device.hints állományt, és az N helyére írjuk be a hint.ppc.0.irq="N" sorba a megfelelõ IRQ számát. A rendszermag beállításait tartalmazó állománynak tartalmaznia kell a &man.ppc.4; meghajtót is: device ppc A lekérdezéses mód használatához a /boot/device.hints állományból távolítsuk el a következõ sort: hint.ppc.0.irq="N" Némely esetben azonban ennyi még nem lesz elég a port lekérdezéses beállításához. Ugyanis ha a hozzátartozó meghajtó az &man.acpi.4;, akkor ez fogja felismerni, kezelni és a nyomtatóhoz tartozó portok hozzáférési módját vezérelni. A problémát ezért gyakran érdemes a &man.acpi.4; beállításai között is keresni. Mentsük el az állományt. Konfiguráljuk be, fordítsuk le és telepítsük az új rendszermagot. Ennek pontos részleteit a rendszermag beállításáról szóló fejezetben olvashatjuk. A kommunikáció módjának beállítása az &man.lptcontrol.8; programmal: A megszakításos mód beállításához írjuk be: &prompt.root; lptcontrol /dev/lptN ahol az lptN a nyomtatóhoz tartozó eszköz neve. A lekérdezéses mód beállításához írjuk be: &prompt.root; lptcontrol /dev/lptN ahol az lptN a nyomtatóhoz tartozó eszköz neve. Ha ezeket a parancsokat berakjuk az /etc/rc.local állományunkba, akkor azzal a rendszer minden egyes indítása során beállítjuk a számunkra megfelelõ módot. Errõl többet az &man.lptcontrol.8; man oldaláról tudhatunk meg. A kommunikáció ellenõrzése Még mielõtt nekilátnánk a nyomtatási rendszer beállításának, bizonyosodjuk meg róla, hogy az operációs rendszer képes adatokat továbbítani a nyomtatónak. Sokkal könnyebb egymástól függetlenül megvizsgálni a kommunikáció és nyomtatási rendszer mûködését. A nyomtatót úgy tudjuk kipróbálni, ha küldünk neki valamilyen szöveget. Az &man.lptest.1; tökéletesen megfelelõ akkor, ha olyan nyomtatónk van, amely azonnal kinyomtatja a kapott szöveget. Ez a program 96 sorban létrehozza mind az összes 96 kinyomtatható ASCII karaktert. PostScript A &postscript; (vagy más egyéb nyelvet ismerõ) nyomtatóknak azonban ennél kifinomultabb próbára van szüksége. Erre a célra tökéletesen megfelel egy olyan kisebb &postscript; programocska, mint például ez: %!PS 100 100 moveto 300 300 lineto stroke 310 310 moveto /Helvetica findfont 12 scalefont setfont (Remek! Ez mukodik!) show showpage Ezt a &postscript; kódot nyugodtan elmenthetjük egy állományba, amelyet aztán a késõbbi szakaszokban megjelenõ példák szerint használni is tudunk majd. PCL A kézikönyvben a nyomtató nyelve alatt leginkább egy &postscript;-szerû nyelvet értünk, nem pedig a Hewlett Packard PCL típusú nyelvét. Habár a PCL nagyon sokra képes, hiszen keverhetjük még benne akár a programokat és a nyers szövegeket is. Ezzel szemben a &postscript; nem képes nyers szöveget kinyomtatni, ezért az ilyen típusú nyomtatók mûködtetéséhez külön támogatásra van szükségünk. A párhuzamos nyomtató ellenõrzése nyomtató párhuzamos Ebben a szakaszban megtudhatjuk, hogy &os; alatt miként ellenõrizzük a párhuzamos portra csatlakozó nyomtatók mûködését. A párhuzamos porton levõ nyomtató kipróbálásához: A &man.su.1; segítségével váljunk root felhasználóvá. Küldjünk a nyomtatónak valamilyen adatot. Ha a nyomtató képes nyers szöveget fogadni, akkor használjuk az &man.lptest.1; programot. Ehhez gépeljük be: &prompt.root; lptest > /dev/lptN ahol az N nullától kezdõdõen a párhuzamos port sorszáma. Ha a nyomtató &postscript; vagy más nyomtatási nyelvet ismer, akkor egy apró programot kell küldenünk neki. Ehhez írjuk be: &prompt.root; cat > /dev/lptN Ezután soronként írjuk be a programot, de vigyázzunk, mert az Enter vagy a Return lenyomása után már nem tudjuk kijavítani! A program begépelése után nyomjuk meg a CtrlD vagy bármely más olyan billentyûkombinációt, amivel ki tudunk lépni. Ezt a programot belerakhatjuk egy állományba is, amire aztán adjuk ki az alábbi parancsot: &prompt.root; cat állomány > /dev/lptN ahol az állomány a nyomtatóra küldendõ program neve lesz. Ezután a nyomtató megkezdi a nyomtatást. Ne aggódjunk, ha netalán valami furcsán nézne ki, mert a késõbbiekben ezt még úgyis rendbetesszük. A soros nyomtató ellenõrzése nyomtató soros Ebben a szakaszban megtudhatjuk, hogyan ellenõrizzük a &os; és soros portra kötött nyomtató kapcsolódását. Így tudjuk kipróbálni a soros porton csatlakozó nyomtatónkat: A &man.su.1; paranccsal váljunk root felhasználóvá. Nyissuk meg az /etc/remote állományt. Tegyük hozzá a következõ sort: printer:dv=/dev/port:br#bps:pa=paritás bit-per-másodperc soros port paritás ahol a port a soros porthoz tartozó eszközleíró neve (ttyd0, ttyd1, stb.), a bps a nyomtató által használt adatátviteli sebesség, végül a paritás a nyomtatóhoz használt paritás (ami lehet even (páros), odd (páratlan), none (nincs), vagy zero (nulla)). Íme egy olyan soros nyomtató beállítása (printer néven), amely sebessége 19 200 bps, a harmadik portra csatlakozik és nem használ paritást: printer:dv=/dev/ttyd2:br#19200:pa=none Kapcsolódjunk a nyomtatóhoz a &man.tip.1; segítségével. Ennek parancsa: &prompt.root; tip printer Ha az iménti lépés nem mûködne, próbálkozzunk az /etc/remote állomány újbóli módosításával, és a /dev/cuaaN eszköz helyett használjuk a /dev/ttydN eszközt! Küldjünk adatot a nyomtatónak. Ha a nyomtató képes nyers szöveget nyomtatni, akkor használjuk az &man.lptest.1; segédprogramot. Gépeljük be: &prompt.user; $lptest Ha a nyomtató a &postscript; vagy egy hozzá hasonló nyomtatási nyelven kommunikál, akkor a nyomtatónak egy rövid programot kell küldenünk. Soronként gépeljük be a programot, azonban vigyázzunk arra, hogy a törlés és minden más szerkesztésre használt billentyû a nyomtató számára is értelmes lehet. Az is elõfordulhat, hogy a program küldését egy speciális jelsorozattal tudjuk csak lezárni. A &postscript; nyomtatók esetén ilyenkor elegendõ a Ctrl D billentyûk együttes lenyomása. Vagy tehetjük az egész programot egy állományba, amihez aztán írjuk be ezt: &prompt.user; >állomány ahol az állomány a programot tartalmazó állomány neve. Miután a &man.tip.1; elküldte az állományt, nyomjuk le a lezáráshoz szükséges billentyûkombinációt. Most már meg kellene jelennie valaminek a nyomtatón. Az még nem számít, pontosan mi is lesz az — késõbb még majd úgyis beállítjuk. A nyomtatási rendszer aktiválása: a <filename>/etc/printcap</filename> állomány Csatlakoztattuk a nyomtatónkat, a mûködtetéséhez beállítottuk a rendszermagot (amennyiben erre szükségünk volt), és tudtunk neki adatokat küldeni. Most már készen állunk arra, hogy LDP alkalmazáson keresztül beállítsuk a nyomtató hozzáférésének vezérlését. Az LPD beállításait az /etc/printcap állományban találjuk. Az LPD nyomtatási rendszer minden egyes mûvelet elõtt beolvassa ezt az állományt, ezért a benne végzett módosítások szinte azonnal életbe is lépnek. nyomtató tulajdonságai A &man.printcap.5; tartalma könnyen érthetõ, a /etc/printcap állományt egyszerûen módosíthatjuk a kedvenc szövegszerkesztõnkkel. A felépítése teljesen megegyezik a többi hozzá hasonló állományéval: ilyenek például a /usr/share/misc/termcap és a /etc/remote. Az itt alkalmazott formátum teljes leírását a &man.cgetent.3; man oldalon találjuk. A nyomtatási rendszer egyszerû beállítása az alábbi lépésekbõl áll: Adjunk nevet (és még néhány álnevet) a nyomtatónak, írjuk ezeket az /etc/printcap állományba. A nevekrõl A nyomtató elnevezése címû szakaszban kapunk felvilágosítást. fejléclapok A(z alapból bekapcsolt) fejléclapokat az sh tulajdonság megadásával kapcsolhatjuk ki. A részleteket A fejléclapok letiltása címû szakaszban találjuk. Hozzunk létre egy nyomtatási könyvtárat, és adjuk meg a helyét az sd tulajdonság beállításával. A nyomtatási könyvtár létrehozása címû szakaszban fogunk errõl többet mondani. Állítsunk be egy nyomtató által használt /dev könyvtárbeli leírót, és az lp tulajdonsággal adjuk meg az /etc/printcap állományban. Errõl részletesebben A nyomtatóeszköz azonosítása címû szakaszban olvashatunk. Ha a nyomtató soros porton keresztül csatlakozik, az ms# tulajdonsággal még meg kell adnunk A nyomtatási rendszer kommunikációs paraméterei szakaszban tárgyaltakat is. Helyezzünk el egy szûrõt a beérkezõ nyers szövegek számára. Errõl A szövegszûrõ telepítése címû szakasz értekezik. Az &man.lpr.1; parancs segítségével próbáljuk ki a nyomtatást. Ennek pontos részleteit a Próbáljuk ki! és a Hibakeresés címû fejezetekben találhatjuk meg. A magasabb szintû nyomtatók, mint például a &postscript; nyomtatók nem képesek közvetlenül nyers szöveget nyomtatni. Az imént felvázolt egyszerû beállítási séma feltételezi, hogy csak olyan állományokat fogunk nyomtatni a nyomtatón, amelyeket meg is ért. A felhasználók gyakran arra számítanak, hogy bármelyik általuk elérhetõ nyomtatón képesek nyers szöveget kinyomtatni. Az LPD alkalmazással kapcsolatban álló programok is általában ugyanezt az elgondolást követik. Ha egy saját nyelvvel rendelkezõ nyomtatót akarunk telepíteni, de a nyomtató saját nyelvén és a nyers szöveg formájában érkezõ munkákat is rendesen ki akarjuk nyomtatni, akkor mindenképpen javasoljuk, hogy illeszünk még egy további lépést is ebbe a sorba: illesszünk a rendszerbe egy nyers szövegrõl automatikusan &postscript; (vagy más egyéb) nyelvre tolmácsoló programot. Errõ a Szöveges nyomtatási feladatok &postscript; nyomtatókon címû fejezetben olvashatunk. A nyomtató elnevezése Az elsõ (egyszerû) lépés a nyomtatónk nevének kiválasztása. Igazából nem számít, mennyire kifejezõ vagy éppen hóbortos nevet adunk neki, hiszen emellett még számos álnévvel is illethetjük. Az /etc/printcap állományban megtalálható nyomtatók egyikének legalább az lp álnévvel rendelkeznie kell, mivel ez lesz az alapértelmezett nyomtató neve. Tehát ha a felhasználó nem adja meg sem a PRINTER környezeti változót, sem pedig az LPD-vel kapcsolatban álló aktuális parancsban a használni kívánt nyomtató nevét, akkor a rendszer az lp nevût fogja keresni. Ezenkívül általában még gyakran adnak egy olyan álnevet is a nyomtatónak, ahol annak teljes leírása, többek közt a gyártmánya és a típusa szerepel. Ahogy sikerült nevet és álneveket adni a nyomtatónak, írjuk is be ezeket az /etc/printcap állományba. Itt a nyomtató neveit balról el kezdjük felsorolni, mindegyik álnevet egy függõleges vonallal válasszunk el, és az utolsó után pedig tegyünk pontosvesszõt. A most következõ példában egy olyan vázt mutatunk be az /etc/printcap állományhoz, amiben két nyomtatót (egy Diablo 630 márkájú sornyomtatót és egy Panasonic KX-P4455 típusú &postscript; lézernyomtatót) adunk meg: # # /etc/printcap (rose) # rattan|line|diablo|lp|Diablo 630 Line Printer: bamboo|ps|PS|S|panasonic|Panasonic KX-P4455 PostScript v51.4: Ebben a példában az elsõ nyomtató neve rattan, és ehhez tartozik még a line, diablo, lp, és Diablo 630 Line Printer álnév. Mivel itt soroltuk fel az lp álnevet is, ezért a rendszerben ez lesz az alapértelmezett nyomtató. A második nyomtató neve bamboo, és álnevei többek közt a ps, PS, S, panasonic, valamint a Panasonic KX-P4455 PostScript v51.4. A fejléclapok letiltása nyomtatás fejléclapok Az LPD nyomtatási rendszer alapértelmezés szerint minden egyes feladathoz fejléclapot készít. Ez a lap szép nagy betûkkel tartalmazza a munkát kiadó felhasználó nevét, a gépet, amirõl küldték, és a feladat nevét. Sajnálatos módon ez azonban inkább akadályozza a hibakeresést a nyomtató beállításában, ezért most inkább kapcsoljuk ki ezeket. Ha le akarjuk tiltani a fejléclapokat, az /etc/printcap állományban adjuk meg az sh (úgy mint suppress header pages) tulajdonságot. Íme egy példa az sh tulajdonsággal bõvített /etc/printcap állományra: # # /etc/printcap (rose) - sehol sem lesznek fejléclapok # rattan|line|diablo|lp|Diablo 630 Line Printer:\ :sh: bamboo|ps|PS|S|panasonic|Panasonic KX-P4455 PostScript v51.4:\ :sh: Ebben a példában megfigyelhetjük a helyes felírási módot: az elsõ sor a legbaloldalibb oszlopban kezdõdik, és az azt követõ sorok pedig bentebb. Minden bejegyzésben az utolsó kivételével mindegyik sor egy visszaper (backslash) karakterrel zárul. A nyomtatási könyvtár létrehozása nyomtatási rendszer nyomtatási munkák A nyomtatási rendszerünk beállításának következõ lépése a nyomtatási könyvtár létrehozása. Ez egy olyan könyvtár, ahová a különbözõ nyomtatási feladatok kerülnek a feldolgozásuk elõtt, valamint ahol a nyomtatási rendszer többi állománya lakozik. A nyomtatási rendszer adatait tároló könyvtárakat tartalmuk gyakori változása miatt általában a /var/spool könyvtárba szokás tenni. Ezen könyvtárak tartalmát nem szükséges menteni sem. Az &man.mkdir.1; parancs futtatásával egyszerûen újra létre tudjuk hozni. Általában minden nyomtatóhoz külön létre szoktak hozni egy könyvtárat az adott nyomtató nevén. Erre példa: &prompt.root; mkdir /var/spool/nyomtatónév Azonban ha a hálózatunkon rengeteg nyomtató található, akkor érdemes inkább egyetlen könyvtárat használni, amelyet az LPD számára tartunk fenn. &prompt.root; mkdir /var/spool/lpd &prompt.root; mkdir /var/spool/lpd/rattan &prompt.root; mkdir /var/spool/lpd/bamboo Amennyiben fontos nekünk a felhasználói nyomtatások titkosságának megóvása, érdemes levédenünk a nyomtatási könyvtárat, így az nem lesz mindenki által elérhetõ. A nyomtatási könyvtárak tulajdonosa egyedül és kizárólag a daemon felhasználó és a daemon csoport legyen, és hozzá olvasási, írási és keresési engedélyekkel rendelkezzen. Ezt fogjuk most beállítani a példáinkban szereplõ nyomtatóinkhoz is: &prompt.root; chown daemon:daemon /var/spool/lpd/rattan &prompt.root; chown daemon:daemon /var/spool/lpd/bamboo &prompt.root; chmod 770 /var/spool/lpd/rattan &prompt.root; chmod 770 /var/spool/lpd/bamboo Végezetül az /etc/printcap állományban ezeket a könyvtárakat se felejtsük el megadni az LPD-nek. Itt a nyomtatási könyvtár nevét az sd tulajdonsággal írjuk le: # # /etc/printcap (rose) - a nyomtatási könyvtárak hozzáadása # rattan|line|diablo|lp|Diablo 630 Line Printer:\ :sh:sd=/var/spool/lpd/rattan: bamboo|ps|PS|S|panasonic|Panasonic KX-P4455 PostScript v51.4:\ :sh:sd=/var/spool/lpd/bamboo: Vegyük észre, hogy a nyomtató neve ugyan a sor elején kezdõdik, azonban a hozzátartozó összes többi sor mind bentebb kezdõdik és egy visszaper (backslash) karakterrel választjuk le. Ha az sd tulajdonsággal nem adunk meg semmilyen nyomtatási könyvtárat, akkor ennek az értéke alapértelmezés szerint a /var/spool/lpd lesz. A nyomtatóeszköz azonosítása A Hardveres beállítás címû szakaszban már beazonosítottuk, hogy a &os; a /dev könyvtárban melyik eszközleírón keresztül fogja megszólítani a nyomtatót. Most ideje ugyanezt tudatni az LPD démonnal is. Így amikor a nyomtatási rendszer ki szeretne nyomtatni egy munkát, a szûrõprogram nevében ezt az eszközt nyitja meg (ahol a szûrõn keresztül továbbítjuk az adatokat a nyomtató felé). Az lp tulajdonság segítségével a /etc/printcap állományban soroljuk fel a nyomtatók /dev könyvtárban található leíróit. Az eddig használt példánkban most tételezzük fel, hogy a rattan nevû nyomtató az elsõ párhuzamos porton található, míg a bamboo nevû a hatodik soros porton. Ebben a helyzetben így kellene kiegészítenünk az /etc/printcap állományunkat: # # /etc/printcap (rose) - a használni kívánt eszközök # beazonosítása # rattan|line|diablo|lp|Diablo 630 Line Printer:\ :sh:sd=/var/spool/lpd/rattan:\ :lp=/dev/lpt0: bamboo|ps|PS|S|panasonic|Panasonic KX-P4455 PostScript v51.4:\ :sh:sd=/var/spool/lpd/bamboo:\ :lp=/dev/ttyd5: Az LPD alapértelmezés szerint a /dev/lp eszköz fogja használni, ha nem adjuk meg az lp tulajdonságot az /etc/printcap állományban. Az /dev/lp azonban a &os;-ben jelenleg nem létezik. Ha a telepítendõ nyomtatónk valamelyik párhuzamos portra csatlakozik, akkor innen akár tovább is léphetünk A szövegszûrõ telepítése címû szakaszra. Ha viszont nem, kövessük a most következõ szakaszban szereplõ utasításokat. A nyomtatási rendszer kommunikációs paraméterei nyomtató soros A soros portra csatlakozó nyomtatóknál az LPD képes beállítani az adatátviteli sebességet, a paritást, valamint más egyéb olyan kommunikációs paramétereket, amelyekkel a szûrõprogram adatokat tud továbbítani a nyomtató felé. Ez több szempontból is elõnyös, mivel: Egyszerûen az /etc/printcap állomány átírásával ki tudunk próbálni több kommunikációs beállítást, nem kell magát a szûrõprogramot újrafordítanunk. A nyomtatási rendszer képes ugyanazt a szûrõt több, különbözõ kommunikációs beállítást alkalmazó nyomtatóhoz is használni. Az /etc/printcap állományban az lp tulajdonsággal megadott eszközök soros kommunikációjának beállításait az alábbi tulajdonságok határozzák meg: br#sebesség Beállítja az eszköz adatátviteli sebességét a sebesség értékre, ahol a sebesség lehet 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 9600, 19 200, 38 400, 57 600 vagy 115 200 bit másodpercenként (bps). ms#stty-mód Beállítja az eszköz megnyitása után használt termináleszköz mûködésének paramétereit. Az &man.stty.1; man oldalon többet is megtudhatunk róluk. Miután az LPD megnyitja az lp tulajdonsággal megadott eszközt, beállítja az ms# tulajdonság értéke szerint annak jellemzõit. Itt a parenb, parodd, cs5, cs6, cs7, cs8, cstopb, crtscts, és ixon módok lehetnek lényegesek, melyekrõl az &man.stty.1; man oldalon többet is megtudhatunk. Állítsunk most akkor be az egyik képzeletbeli nyomtatónkat a hatodik soros portra. Az adatátviteli sebessége 38 400 bps lesz. A kommunikáció módjánál kapcsoljuk ki a paritást (-parenb), 8 bites karakterek legyenek (cs8), ne legyen modemes vezérlés (clocal) és a hardveres forgalomirányítás legyen crtscts: bamboo|ps|PS|S|panasonic|Panasonic KX-P4455 PostScript v51.4:\ :sh:sd=/var/spool/lpd/bamboo:\ :lp=/dev/ttyd5:ms#-parenb cs8 clocal crtscts: A szövegszûrõ telepítése nyomtatás szûrõk Most már utasíthatjuk az LPD-t, hogy milyen szövegszûrõt használjon a munkák nyomtatóra küldéséhez. A szövegszûrõ (text filter), vagy más néven bemeneti szûrõ (input filter) egy olyan program, amelyet az LPD egy nyomtatási feladat elvégzésekor lefuttat. Amikor az LPD lefuttatja a nyomtatóhoz tartozó szövegszûrõt, a szûrõ szabványos bemenetére elküldi a kinyomtatandó munkát, és a szabványos kimenetét pedig átirányítja az lp tulajdonság által megadott nyomtatóeszközre. Ennek megfelelõen a szûrõnek a szabványos bemenetrõl kell olvasnia az elvégzendõ feladatot, a szabványos kimenetre pedig a ténylegesen nyomtatandót kell kiírnia. A szövegszûrõk részleteirõl a Hogyan mûködnek a szûrõk? szakasz szól. A mi esetünkben most szövegszûrõnek tökéletesen megfelel egy olyan rövid szkript, ami a nyomtatóra a munkát a /bin/cat paranccsal küldi ki. A &os;-ben még találhatunk egy másik szûrõt is, amelynek a neve lpf. Ez képes a törlést és aláhúzást jelzõ karaktereket érthetõvé tenni bizonyos nyomtatók számára. Természetesen itt használhatunk kedvünk szerinti szûrõt is. Az lpf szûrõ mûködésének részleteit Az lpf szövegszûrõ címû szakaszban fejtjük ki bõvebben. Elõször is készítsünk egy /usr/local/libexec/if-simple nevû egyszerû szövegszûrõ szkriptet. A kedvenc szövegszerkesztõnkkel írjuk bele a következõ sorokat: #!/bin/sh # # if-simple - egyszerû szövegszûrõ szkript az lpd-hez # Helye: /usr/local/libexec/if-simple # # Egyszerûen átmásolja a kimenetére a bemenetérõl érkezõ adatokat; nem # fogad el semmilyen paramétert. /bin/cat && exit 0 exit 2 Tegyük indíthatóvá: &prompt.root; chmod 555 /usr/local/libexec/if-simple Ezután tájékoztassuk róla az LPD-t az /etc/printcap állományban található if tulajdonság megadásával. Itt most a példánkban szereplõ mind a két nyomtatóhoz beillesztjük: # # /etc/printcap (rose) - a szövegszûrõ hozzáadása # rattan|line|diablo|lp|Diablo 630 Line Printer:\ :sh:sd=/var/spool/lpd/rattan:\ :lp=/dev/lpt0:\ :if=/usr/local/libexec/if-simple: bamboo|ps|PS|S|panasonic|Panasonic KX-P4455 PostScript v51.4:\ :sh:sd=/var/spool/lpd/bamboo:\ :lp=/dev/ttyd5:ms#-parenb cs8 clocal crtscts:\ :if=/usr/local/libexec/if-simple: Az if-simple szkript megtalálható a /usr/share/examples/printing könyvtárban. Az <application>LPD</application> elindítása Az &man.lpd.8; az /etc/rc szkriptbõl, az lpd_enable változó értékének megfelelõen indul el. Ennek értéke alapból NO, vagyis nem. Ha eddig még nem tettük volna meg, akkor az /etc/rc.conf állományba most vegyük fel a következõ sort: lpd_enable="YES" Ezután vagy indítsuk újra a számítógépünket, vagy pedig adjuk ki az &man.lpd.8; parancsot: &prompt.root; lpd Próbáljuk ki! Elérkeztünk az LPD egyszerû beállításának utolsó lépéséhez. Sajnos azonban még nem gratulálhatunk, hiszen hátra van még a nyomtató kipróbálása és az esetlegesen elõforduló hibák kijavítása. A beállítást úgy tudjuk a legegyszerûbben letesztelni, ha megpróbálunk valamit kinyomtatni. Az LPD rendszerben az &man.lpr.1; parancs használatával tudunk nyomtatási feladatokat kiadni. A kommunikáció ellenõrzése címû szakaszban megtalálhatjuk, hogy hozzunk létre tesztelésre alkalmas szövegeket az &man.lpr.1; és az &man.lptest.1; programok segítségével. Az LPD beállításainak egyszerû tesztelése: Írjuk be: &prompt.root; lptest 20 5 | lpr nyomtatónév ahol a nyomtatónév az /etc/printcap állományban megadott egyik nyomtató neve (vagy álneve) lehet. Az alapértelmezett nyomtató kipróbálásához ne adjunk meg az &man.lpr.1; parancsnak semmilyen paramétert. Még egyszer megemlítenénk, hogy amennyiben &postscript; nyomtatót tesztelünk, az elõbbi helyett az &man.lptest.1; paranccsal küldjünk ki egy &postscript; programot. Ehhez tegyük a tesztelõ programunkat egy állományba, majd írjuk be az lpr állománynév parancsot. A &postscript; nyomtató esetén a kiküldött program eredményét kell látnunk. Amennyiben az &man.lptest.1; parancsot használjuk, valami ilyesmire kell számítanunk: !"#$%&'()*+,-./01234 "#$%&'()*+,-./012345 #$%&'()*+,-./0123456 $%&'()*+,-./01234567 %&'()*+,-./012345678 A nyomtató kimerítõbb teszteléséhez próbáljunk meg nagyobb programokat keríteni valahonnan (ha a nyomtatónk valamilyen nyelven kommunikál) vagy adjunk meg az &man.lptest.1; parancsnak más paramétereket. Például az lptest 80 60 soronként 80 karaktert írat ki 60 sorban. Amennyiben a nyomtató nem mûködne, nézzük meg a Hibakereséshez tartozó szakaszt. Magasszintû nyomtatóbeállítás Ebben a szakaszban olyan szûrõket mutatunk be, amelyek speciálisan formázott állományok, fejléclapok, hálózati nyomtatás, nyomtatási nyilvántartás vagy szabályozás esetén használhatóak. Szûrõk nyomtatás szûrõk Noha az LPD képes hálózati protokollokat, nyomtatási sorokat, hozzáférést és sok minden más nyomtatási feladatot kezelni, a tényleges munka legnagyobb része a szûrõkben (filter) történik. A szûrõk olyan programok, amelyek tartják a kapcsolatot a nyomtatóval és megbírkóznak annak eszközfüggõségeivel és különleges igényeivel. Az egyszerû beállítás során egy primitív szövegszûrõt állítottunk be (lásd A szövegszûrõ telepítése) — ami annyira egyszerû, hogy szinte minden nyomtatón mûködnie kell. Azonban mindahhoz, hogy ki tudjuk használni a különbözõ átalakítási, nyilvántartási lehetõségeket, valamint a nyomtatók különlegességeit és egyebeit, meg kell értenünk a szûrõk pontos mûködését. Az elõbb említett feladatok ugyanis teljesen a szûrõ kezében vannak. Ezzel kapcsolatban azonban rossz hír, hogy ezeket a szûrõket nekünk kell megírnunk. A jó hír ellenben az, hogy könnyen találunk ilyen szûrõket, vagy ha éppen nem lelnénk valamelyiket, akkor is gyorsan meg tudjuk ezeket írni. Sõt, a &os; alapból tartalmaz is egyet, amit a /usr/libexec/lpr/lpf helyen találunk meg, és sok olyan nyomtatóval képes együttmûködni, amelyek nyers szöveget tudnak nyomtatni. (Kezeli az állományokban felbukkanó törléseket és tabulalásokat, valamint képes nyilvántartást vezetni, de semmi többet.) Rajta kívül még számos szûrõt és szûrõelemet is találhatunk a &os; Portgyûjteményében. Lássuk, mit tartogat számunkra ez a rész: A Hogyan mûködnek a szûrõk? címû szakaszban megpróbálunk egyfajta áttekintést adni a szûrõk nyomtatási folyamatban betöltött szerepérõl. Mindenképpen érdemes elolvasnunk ezt a szakaszt, mivel ebben derül ki, hogy valójában mi is történik a függöny mögött, vagyis amikor az LPD használja ezeket a szûrõket. Ezzel a tudással el tudjuk kerülni vagy éppen nyakon tudjuk csípni azokat a problémákat, amelyek a nyomtatóinkhoz telepített szûrõk hozzáadása során adódhatnak. Az LPD alapból arra számít, hogy minden nyomtató képes nyers szöveget nyomtatni. Ez gondot okoz a &postscript; (és minden más nyelv alapú) nyomtatók esetén, mivel azok nem képesek nyers szöveget nyomtatni. Szöveges nyomtatási feladatok &postscript; nyomtatókon címû szakaszban viszont fény derül rá, hogyan kerekedjünk felül ezen. Feltétlenül olvassuk el, ha &postscript; nyomtatónk van. A &postscript; számos program közkedvelt kimeneti formátuma, sõt gyakran maguk a felhasználók is szeretnek ilyen programokat írni. Sajnos azonban a &postscript; nyomtatók egyáltalán nem olcsók. A &postscript; szimulációja nem &postscript; nyomtatókon címû szakaszban megtudhatjuk, miképp tudjuk úgy módosítani a szûrõt, hogy nem &postscript; nyomtatókon is tudjunk &postscript; programokkal nyomtatni. Ezt a szakaszt akkor érdemes elolvasni, ha nincs &postscript; nyomtatónk. A Konverziós szûrõk címû szakaszban eláruljuk, miként lehetséges automatizálni a különbözõ állományformátumok és a nyomtatók által érthetõ formátumok közti konverziókat, legyen az grafikus vagy betûszedésre vonatkozó adat. A szakasz elolvasása során megismerjük, hogyan tudjuk a nyomtatónkat képessé tenni az lpr paranccsal troff adatok, vagy a lpr paranccsal a &tex; DVI állományainak, esetleg az lpr paranccsal raszteres képek nyomtatására és így tovább. Csak ajánlani tudjuk ennek elolvasását. A Kimeneti szûrõk címû szakaszban kivesézzük az LPD egyik kevésbé használt lehetõségét is, a kimeneti szûrõket. Hacsak nem fejléclapokat akarunk készíteni (lásd Fejléclapok), akkor ezt a szakaszt nyugodtan kihagyhatjuk. Az lpf szövegszûrõ szakaszban bemutatásra kerül a &os;-ben alapból megtalálható lpf szûrõ, amely egy sornyomtatónknál (vagy az így viselkedõ lézernyomtatóknál) használható egyszerû szövegszûrõ. Ha nyers szövegek nyomtatásánál meg akarjuk oldani a nyomtatási munkák nyilvántartását, vagy a törlés karakter láttán a nyomtatónk füstölni kezdene, akkor mindenképpen érdemes belemerülnünk az lpf titkaiba. A most következõ szkriptek mindegyike megtalálható a /usr/share/examples/printing könyvtárban. Hogyan mûködnek a szûrõk? Ahogy már korábban is jeleztük, a szûrõ egy olyan végrehajtható program, amelyet az LPD indít el, amikor a nyomtatóval eszközfüggetlen módon kommunikál. Amikor az LPD egy feladat elvégzése során ki akar nyomtatni egy állományt, akkor elindít egy ilyen szûrõprogramot. A szûrõ szabványos bemenetére elküldi a kinyomtatandó állományt, a szabványos kimenetét a nyomtatóra, a szabványos hibajelzéseit pedig egy naplóállományba irányítja (ez utóbbit az /etc/printcap) állományban az lf tulajdonsággal adhatjuk meg, vagy alapértelmezés szerinti a /dev/console állományba kerül). troff Az LPD a használni kívánt szûrõt és annak paramétereit az /etc/printcap állományban felsoroltak vagy az &man.lpr.1; parancssorában megadottak szerint választja ki. Például, ha a felhasználó a lpr parancsot adja ki, akkor az LPD a célként megadott nyomtatónál szereplõ tf tulajdonság által megadott troff szûrõt kezdi el használni. Amennyiben a felhasználó egyszerûen csak nyers szöveget akar nyomtatni, akkor az if szûrõnek kellene elindulnia (ez viszont csak részben igaz: lásd Kimeneti szûrõk). Háromfajta szûrõ jelenhet meg az /etc/printcap állományban: A szövegszûrõ (text filter), ami a hagyományos szöveges nyomtatásért felelõs, és amit az LPD dokumentációjában érdekes módon bemeneti szûrõnek (input filter) hívnak. Mivel az LPD arra számít, hogy minden nyomtató alapból képes kinyomtatni bármilyen nyers szöveget, ezért a szövegszûrõ feladata, hogy a nyomtató számára gondoskodjon a tabulátorok, törlések és más egyéb speciális karakterek megfelelõ kezelésérõl. Emellett ha olyan helyen vagyunk, ahol szükség van a nyomtatási munkák nyilvántartására is, a szövegszûrõ ennek megoldására is képes, méghozzá úgy, hogy összeszámolja a kinyomtatott sorokat és elosztja ezeket a nyomtató által oldalanként nyomtatott sorok számával. Egy szövegszûrõ a következõ paraméterekkel indulhat: szûrõnév -c -w szélesség -l hossz -i behúzás -n hozzáférés -h gépnév nyilvántartás ahol a akkor jelenik meg, ha egy munkát az lpr paranccsal adunk át szélesség az /etc/printcap állományban definiált pw (page width, avagy oldalszélesség) tulajdonság értéke, ami alapbeállítás szerint 132 hossz a pl (page length, avagy oldalhossz) tulajdonság értéke, amely az alapbeállítás szerint 66 behúzás az lpr parancs megadása során használt behúzás mértéke, ami alapból 0 hozzáférés a nyomtatást végzõ felhasználó hozzáférésének megnevezése gépnév a gép neve, amirõl a nyomtatási munka érkezett nyilvántartás ez a nyilvántartást tároló állomány af tulajdonsággal definiált neve nyomtatás szûrõk A konverziós szûrõk (conversion filter) egy adott állományformátumot hoznak a nyomtató számára értelmes formára. Például ditroff adatok közvetlenül ugyan nem nyomtathatóak, azonban a ditroff állományokhoz tudunk telepíteni egy olyan szûrõt, amely a ditroff adatokat a nyomtató számára is emészthetõ és nyomtatható formájúvá teszi. A Konverziós szûrõk címû szakasz tud ezekrõl többet mondani. Ilyen esetekben kérhetünk nyilvántartást. A konverziós szûrõk az alábbi paraméterekkel indulhatnak: szûrõnév -x pixelszélesség -y pixelmagasság -n hozzáférés -h gépnév nyilvántartás ahol a pixelszélesség a px tulajdonság értékébõl (ami alapból 0), a pixelmagasság a py tulajdonság értékébõl (ami alapból szintén 0) származik. A kimeneti szûrõ (output filter), ami csak akkor aktív, ha a szövegszûrõ nem, vagy ha engedélyeztük fejléclapok nyomtatását. Tapasztalatom szerint az ilyen szûrõket ritkán használják. A Kimeneti szûrõk címû szakasz mutatja be a mûködésüket. Ekkor csupán két paraméterünk van: szûrõnév -w szélesség -l hosszúság amik rendre megegyeznek a szövegszûrõk és paramétereivel. A szûrõk ki is tudnak lépni a következõ kódokkal (exit status): 0 A szûrõ sikeresen kinyomtatta az állományt. 1 A szûrõnek nem sikerült kinyomtatnia az állományt, azonban szeretné, ha az LPD újból megpróbálkozna vele. Az LPD tehát ebben az esetben újraindítja a szûrõt. 2 A szûrõnek nem sikerült kinyomtatnia az állományt, és nem is kívánja újra megpróbálni. Ekkor az LPD eldobja az állományt. A &os; kiadásokban megtalálható /usr/libexec/lpr/lpf szövegszûrõ képes a kapott szélesség és hossz paraméterekkel megállapítani az oldaltöréseket és a nyomtató használatát nyilvántartani, amihez a hozzáférés, gépnév és nyilvántartás adatait használja fel. Amikor majd igyekszünk mellé újabb szûrõket beszerezni, ne felejtsük el ellenõrizni, hogy együtt tudnak-e mûködni az LPD-vel. Ha a válasz igen, akkor a fentebb említett paraméterek mindegyikét ismerniük kell. Az általános használatra készült szûrõk készítése során mi magunknak is be kell tartanunk ezeket az elvárásokat. Szöveges nyomtatási feladatok &postscript; nyomtatókon nyomtatsái munkák Ha csak egyedül dolgozunk a számítógépen és &postscript; (vagy bármilyen más nyelvet ismerõ) nyomtatónk van, valamint megígérjük, hogy soha nem küldünk sem mi, sem pedig nem küldetünk semmilyen más programmal nyers szöveget a nyomtatóra, akkor átléphetjük ezt a szakaszt. Ha viszont egyaránt akarunk küldeni &postscript; programot és nyers szöveget tartalmazó munkákat a nyomtatónak, akkor ehhez kénytelenek vagyunk a rendszerünket beállítani. Elõször is szükségünk van szövegszûrõre, ami megállapítja, hogy a frissen érkezett munka nyers szöveget vagy &postscript; programot tartalmaz-e. Minden &postscript;-alapú feladat a %! karaktersorozattal kezdõdik (a többi esetben olvassuk a nyomtató leírását). Szóval, ha a nyomtatandó állomány elsõ két karaktere ilyen, akkor egy &postscript; programmal van dolgunk és közvetlenül továbbküldhetjük a munkát a nyomtatónak. Minden más esetben a szûrõnek elõbb át kell alakítania a szöveget &postscript; nyelvre. Hogyan érhetjük el mindezt? nyomtató soros Ha soros nyomtatónk van, akkor erre a feladatra az lprps parancs tökéletes. Az lprps egy olyan &postscript; szûrõ, amely mind a két irányban képes közvetíteni. Folyamatosan rögzíti egy állományba a nyomtató állapotát, így a felhasználók és rendszergazdák pontosan látják a nyomtató jelenlegi állapotát (például toner low (a toner hamarosan kifogy) vagy paper jam (a papír beragadt)). Ami viszont sokkal lényegesebb, hogy a psif nevû program képes megmondani az érkezõ munka valódi típusát, és ennek megfelelõen meg tudja hívni nyers szöveg átalakítására a textps (egy másik program, amit a lprps mellé kapunk) parancsot. Ezután az lprps elküldi a feladatot a nyomtatónak. Az lprps a &os; Portgyûjteményének része (lásd A Portgyûjtemény), ezért a használni kívánt papír méretétõl függõen pillanatok alatt magunk is letölhetjük, fordíthatjuk és telepíthetjük a print/lprps-a4 és print/lprps-letter csomagok valamelyikét. Az lprps telepítése után egyszerûen csak adjuk meg a psif elérési útvonalát. Ha tehát telepítettük a Portgyûjteménybõl az lprps csomagot, akkor egy soros portra csatlakozó &postscript; nyomtató esetén ezt kell beírnunk az /etc/printcap állományba: :if=/usr/local/libexec/psif: Ezenkívül még az rw tulajdonsággal meg kell mondanunk az LPD-nek, hogy a nyomtatót írásra és olvasásra nyissa meg. Amennyiben a &postscript; nyomtatónk a párhuzamos porton csatlakozik (és amiért a nyomtatónk nem képes az lprps által igényelt kétirányú kommunikációra), szövegszûrõként a következõ szkriptet fogjuk használni: #!/bin/sh # # psif - PostScript vagy nyers szöveg nyomtatása PostScript nyomtatón # Ez a szkriptes változat, NEM pedig az lprps-hez mellékelt szûrõ # (a /usr/local/libexec/psif állomány)! # IFS="" read -r first_line first_two_chars=`expr "$first_line" : '\(..\)'` if [ "$first_two_chars" = "%!" ]; then # # PostScript: nyomtassuk ki. # echo "$first_line" && cat && printf "\004" && exit 0 exit 2 else # # Nyers szöveg: alakítsuk át, majd nyomtassuk ki. # ( echo "$first_line"; cat ) | /usr/local/bin/textps && printf "\004" && exit 0 exit 2 fi A fentebb szereplõ szkriptben a textps programot használjuk a nyers szövegek &postscript; programokra alakításához, de helyette bármilyen más konvertáló programot is igénybe vehetünk. A &os; Portgyûjteményében (lásd A Portgyûjtemény) találhatunk erre a célra egy a2ps nevû programot is, amit esetleg érdemes lehet közelebbrõl megnéznünk. &postscript; szimulációja nem &postscript; nyomtatókon PostScript emuláció Ghostscript A &postscript; a magas színvonalú betûszedés és nyomtatás de facto szabványa. Emellett azonban a &postscript; egy költséges szabvány is. Az Aladdin Enterprises-nak hála azonban létezik egy hozzá hasonló szabad szoftver, a Ghostscript, amely képes &os;-n is futni. A Ghostscript képes a legtöbb &postscript; állomány olvasására, megjelenítésére mindenféle eszközökön, beleértve a &postscript;et nem ismerõ nyomtatókat is. A Ghostscript és egy speciális szövegszûrõ telepítésével el tudjuk érni, hogy egy nem &postscript; nyomtató valódi &postscript; nyomtatóként viselkedjen. Ha telepíteni szeretnénk, a Ghostscript megtalálható a &os; Portgyûjteményében. Innen tehát magunk is könnyedén le tudjuk tölteni, fordítani és telepíteni. A &postscript; nyomtatás szimulációjához elõször egy szûrõ segítségével észre kell vennünk, hogy egy &postscript; formátumú állományt készülünk kinyomtatni. Ha nem ilyen a nyomtatandó munka, akkor egyenesen a nyomtatóra küldjük, azonban minden más esetben elõször a Ghostscript segítségével átalakítjuk egy olyan formátumba, amit a nyomtató is képes feldolgozni. Nézzünk erre egy példát: a most következõ szövegszûrõ a Hewlett Packard DeskJet 500-as nyomtatóihoz használható. Más nyomtató esetén cseréljük ki a gs (Ghostscript) parancs paraméterét a neki megfelelõre. (A telepített Ghostscript által ismert nyomtatók listáját a gs paranccsal kérdezhetjük le.) #!/bin/sh # # ifhp - Ghostscripttel szimulált Postscript nyomtatás DeskJet 500-on # Helye: /usr/local/libexec/ifhp # # LF karaktereket CR+LF-ként kezeljük (elkerülve ezzel a HP/PCL # nyomtatókon a "lépcsõzést"): # printf "\033&k2G" || exit 2 # # Az állomány elsõ két karakterének beolvasása # IFS="" read -r first_line first_two_chars=`expr "$first_line" : '\(..\)'` if [ "$first_two_chars" = "%!" ]; then # # Ez PostScript: küldjük át a Ghostscripten és nyomtassuk ki. # /usr/local/bin/gs -dSAFER -dNOPAUSE -q -sDEVICE=djet500 \ -sOutputFile=- - && exit 0 else # # Nyers szöveg vagy HP/PCL, ezért küldjük át közvetlenül. Az utolsó # lap kidobásához küldünk még egy lapdobást is. # echo "$first_line" && cat && printf "\033&l0H" && exit 0 fi exit 2 Befejezésül az if tulajdonságon keresztül értesítenünk kell errõl a szûrõrõl az LPD-t is: :if=/usr/local/libexec/ifhp: Készen is vagyunk! Most már nyugodtan beírhatjuk, hogy lpr sima.szöveg vagy lpr akármi.ps, mind a kettõnek ki kell tudnia nyomtatódnia. Konverziós szûrõk Miután elvégeztük az Alacsonyszintû nyomtatóbeállítás címû szakaszban leírt beállításokat, a (nyers ASCII szöveg mellett) kedvenc állományformátumainkhoz is minden bizonnyal szeretnénk telepíteni néhány konverziós szûrõt. Miért használjunk konverziós szûrõket? &tex; DVI állományok nyomtatása A konverziós szûrõk segítségével állományok mindenféle formátumait könnyen ki tudjuk nyomtatni. Például tegyük fel, hogy a sokat dolgozunk a &tex; betûszedõ rendszerrel és egy &postscript; nyomtatónk van. Minden alkalommal, amikor egy DVI állományt hozunk létre a &tex; forrásból, azt közvetlenül még nem tudjuk a nyomtatóra küldeni. Ehhez a következõ parancsokat kell kiadnunk: &prompt.user; dvips hínár-elemzés.dvi &prompt.user; lpr hínár-elemzés.ps Ha telepítünk egy konverziós szûrõt a DVI állományokhoz, meg tudjuk spórolni ezt a manuális átalakítási lépést azzal, hogy átadjuk ezt a feladatot az LPD-nek. Így ezután mindig, amikor egy DVI állományt akarunk kinyomtatni, csupán egyetlen lépésre lesz szükségünk: &prompt.user; lpr hínár-elemzés.dvi Az LPD-nek a paraméterrel adjuk meg, hogy a nyomtatás elõtt hajtsa végre a DVI átalakítását. A Formázási és konverziós beállítások címû szakaszban találjuk meg a többi konverziós opciót. Minden olyan konverziós beállításhoz, amit használni szeretnénk a nyomtatóval, telepítenünk kell egy konverziós szûrõt (conversion filter) és meg kell adnunk a nevét az /etc/printcap állományban. A konverziós szûrõk az egyszerû nyomtatóbeállításnál szereplõ szövegszûrõkhöz hasonlítanak (lásd A szövegszûrõ telepítése szakasz) azzal a kivétellel, hogy a nyers szövegek kinyomtatása helyett ezek a szûrõk a nyomtató számára értelmes formátumra alakítják az állományokat. Milyen konverziós szûrõket érdemes telepíteni? Olyan konverziós szûrõket telepítsünk, amelyekre gyakran szükségünk lehet. Ha például sok DVI adatot szeretnénk nyomtatni a jövõben, akkor használjunk DVI konverziós szûrõt, vagy ha sok troff formátumú adatot nyomtatunk, akkor minden bizonnyal jól fog jönni egy troff szûrõ. A következõ táblázat foglalja össze azokat a szûrõket, amelyekkel az LPD képes együttmûködni. Megtudhatjuk, hogy az /etc/printcap állományban melyik tulajdonság tartozik hozzájuk és hogyan hívjuk meg ezeket az lpr paranccsal: Állománytípus Tulajdonság az /etc/printcap állományban Az lpr kapcsolója cifplot cf DVI df plot gf ditroff nf FORTRAN forrás rf troff tf raster vf nyers szöveg if nincs, , vagy A példánkban tehát a lpr parancs használata arra utal, hogy a nyomtatónak az /etc/printcap állományból a df tulajdonságára van szüksége. FORTRAN Minden hadakozás ellenére állíthatjuk, hogy a FORTRAN források és a plot által használt szövegek formátuma napjainkra már elavultnak tekinthetõ. Ezért ezekhez az opciókhoz a saját szûrõinkkel tetszõleges formázási lehetõségeket rendelhetünk. Például, ha Printerleaf (az Interleaf asztali kiadványszerkesztõ formátuma) állományokat szeretnénk közvetlenül nyomtatni, akkor valószínûleg nem lesz szükségünk plot állományokra. Ezért a gf tulajdonságnak megadhatunk egy Printerleaf konverziós szûrõt, amelyen keresztül aztán a felhasználók az lpr paranccsal Printerleaf állományokat tudnak nyomtatni. Konverziós szûrõk telepítése Mivel a konverziós szûrõk az alap &os; rendszeren kívülre kerülnek, ezért ezeket minden valószínûség szerint valahol a /usr/local könyvtárban találjuk meg. Ezen belül is általában a /usr/local/libexec könyvtárban fordulnak elõ, mivel ezeket csak az LPD futtatja, senki másnak nincs rájuk szüksége. A konverziós szûrõk aktiválásához az /etc/printcap állományban egyszerûen adjuk meg az alkalmas tulajdonságoknak megfelelõ szûrõk elérési útvonalait. A példánkban most felveszünk egy DVI konverziós szûrõt a bamboo nevû nyomtatóhoz. Itt ismét láthatjuk a korábban használt /etc/printcap állományt, ahol most azonban a bamboo nevû nyomtatónál hozzáadtunk egy df tulajdonságot: # # /etc/printcap (rose) - egy df szûrõ hozzáadása a bamboo # nevû nyomtatóhoz # rattan|line|diablo|lp|Diablo 630 Line Printer:\ :sh:sd=/var/spool/lpd/rattan:\ :lp=/dev/lpt0:\ :if=/usr/local/libexec/if-simple: bamboo|ps|PS|S|panasonic|Panasonic KX-P4455 PostScript v51.4:\ :sh:sd=/var/spool/lpd/bamboo:\ :lp=/dev/ttyd5:ms#-parenb cs8 clocal crtscts:rw:\ :if=/usr/local/libexec/psif:\ :df=/usr/local/libexec/psdf: A DVI szûrõ ebben az esetben a /usr/local/libexec/psdf néven elérhetõ aprócska szkript. Ezt találhatjuk benne: #!/bin/sh # # psdf - DVI szûrõ PostScript nyomtatóhoz # Helye: /usr/local/libexec/psdf # # Az lpr -d parancs hatására hívódik meg # exec /usr/local/bin/dvips -f | /usr/local/libexec/lprps "$@" A szkript a dvips parancsot szûrõként futtatja (az paraméterrel) a szabványos bemenetrõl, ahova a nyomtatási munkát is kapja. Ezután elindítja az lprps &postscript; szûrõt (lásd a Szöveges nyomtatási feladatok &postscript; nyomtatókon címû szakaszt) az LPD által átadott paraméterekkel. Az lprps parancs ezekkel a paraméterekkel tartja nyilván az így kinyomtatott lapokat. További példák konverziós szûrõkre A konverziós szûrõk telepítésének nincs bevált receptje, ezért ebben a szakaszban bemutatunk rájuk néhány mûködõ illusztrációt. Ezeket tudjuk felhasználni saját szûrõk elkészítésére. Vagy ha megtehetjük, használjuk közvetlenül ezeket. Ebben a példa szkriptben Hewlett Packard LaserJet III-Si nyomtatókhoz hozunk létre raszteres (pontosabban GIF formátumú) konverziós szûrõt: #!/bin/sh # # hpvf - GIF állományokat konvertál át HP/PCL-be, majd kinyomtatja # Helye: /usr/local/libexec/hpvf PATH=/usr/X11R6/bin:$PATH; export PATH giftopnm | ppmtopgm | pgmtopbm | pbmtolj -resolution 300 \ && exit 0 \ || exit 2 Úgy mûködik, hogy a GIF állományt elõször PNM (portable anymap), utána PGM (portable graymap), majd PBM (portable bitmap) formátumúra alakítja, amibõl végül LaserJet/PCL-kompatibilis adat lesz. Ez lesz a hozzátartozó /etc/printcap állomány: # # /etc/printcap (orchid) # teak|hp|laserjet|Hewlett Packard LaserJet 3Si:\ :lp=/dev/lpt0:sh:sd=/var/spool/lpd/teak:mx#0:\ :if=/usr/local/libexec/hpif:\ :vf=/usr/local/libexec/hpvf: A most következõ szkript a groff betûszedû rendszerbõl érkezõ troff adatokat alakítja át a bamboo nevû &postscript; nyomtató számára: #!/bin/sh # # pstf - a groff troff adait alakítja PS-re, majd kinyomtatja # Helye: /usr/local/libexec/pstf # exec grops | /usr/local/libexec/lprps "$@" A szkript az lprps parancs segítségével kommunikál a nyomtatóval. Ha a nyomtatónk párhuzamos porton csatlakozik, akkor helyette ezt a szkriptet használjuk: #!/bin/sh # # pstf - a groff troff adatait alakítja PS-re, majd kinyomtatja # Helye: /usr/local/libexec/pstf # exec grops Kész is! A szûrõ éltrekeltéséhez mindössze ennyit kell beillesztenünk az /etc/printcap állományba: :tf=/usr/local/libexec/pstf: Most pedig jöjjön a FORTRAN szerelmeseinek szívét megmelengetõ szkript. Ez egy olyan szövegszûrõ, amely bármelyik nyers szöveget közvetlenül kezelni tudó nyomtató esetén mûködik. A teak nevû nyomtatóhoz helyezzük be: #!/bin/sh # # hprf - FORTRAN szövegszûrõ LaserJet 3si-hez # Helye: /usr/local/libexec/hprf # printf "\033&k2G" && fpr && printf "\033&l0H" && exit 0 exit 2 Az /etc/printcap állományban a teak nyomtatóhoz a következõ sor beírásával tudjuk engedélyezni ezt a szûrõt: :rf=/usr/local/libexec/hprf: Most pedig következzen egy utolsó, de az eddigieknél valamivel összetettebb példa. Ebben a korábban bemutatott teak nevû LaserJet nyomtatóhoz fogunk hozzáadni egy DVI szûrõt. Elõször is következzen a mûvelet egyszerûbb része: bõvítsük ki az /etc/printcap állományt a DVI szûrõ helyének megadásával: :df=/usr/local/libexec/hpdf: Ezután következzék a nehezebb rész: a szûrõ elkészítése. Ehhez szükségünk lesz egy DVI-rõl LaserJet/PCL-re alakító programra. A &os; Portgyûjteményében (lásd A Portgyûjtemény) találunk is egyet: a csomag neve print/dvi2xx. A csomag telepítésével megkapjunk a nekünk kellõ dvilj2p programot, ami képes DVI-t LaserJet IIp, LaserJet III és a LaserJet 2000 típusok által ismert kódokra fordítani. A dvilj2p felhasználásától függetlenül a hpdf néven létrehozni kívánt szûrõnk még így is bonyolult lesz, hiszen a dvilj2p nem tud olvasni a szabványos bemenetrõl, hanem minden áron egy állománnyal akar dolgozni. Sõt, olyan állománnyal, amelynek .dvi kiterjesztése van, ezért még a /dev/fd/0 (vagyis a szabványos bemenethez tartozó eszközleíró) használata is akadályokba ütközik. Üröm még az örömünkben, hogy a /tmp könyvtárat sem tudjuk felhasználni ideiglenes link létrehozására: a szimbolikus linkeket a bin felhasználó és csoport birtokolja, a szûrõt pedig a daemon felhasználó futtatja. A /tmp könyvtárban rááadásul csak a tulajdonosaik képesek állományokat átnevezni vagy törölni (sticky bit). Ezért a szûrõ ugyan létre tudna hozni egy linket, azonban ezt a munkája végeztével nem lesz majd képes törölni, mivel a link egy másik felhasználóhoz tartozik. Ezért a szûrõ az aktuális könyvtárban fogja létrehozni ezt a szimbolikus linket, ami jelen esetünkben a nyomtatási rendszer által használt könyvtár lesz (ezt az /etc/printcap állomány sd tulajdonságával adjuk meg). Itt remekül el tudják végezni a feladataikat a szûrõk, különösen mivel (néha) több hely van itt, mint a /tmp könyvtárban. Végül lássuk magát a szûrõt: #!/bin/sh # # hpdf - DVI adat nyomtatása HP/PCL nyomtatón # Helye: /usr/local/libexec/hpdf PATH=/usr/local/bin:$PATH; export PATH # # Létrehozunk egy függvényt az átmeneti állományok törlésére. Ezek # az aktuális könyvtárban jönnek létre, ami pedig a nyomtatási # rendszer adott nyomtatóhoz tartozó könyvtára lesz. # cleanup() { rm -f hpdf$$.dvi } # # Létrehozunk egy függvényt a súlyos hibák kezelésére: írassunk ki # egy adott üzenetet és lépjünk ki a 2-es hibakóddal. Ezzel üzenünk # az LPD-nek, hogy ne nyomtatassa újra a munkát. # fatal() { echo "$@" 1>&2 cleanup exit 2 } # # Ha a felhasználó eltávolítja a munkát a sorból, akkor az LPD egy SIGINT # jelzést fog küldeni, ezért próbáljuk meg azt elkapni (néhány más egyéb # jelzéssel együtt), így még tudjuk törölni az ideiglenesen # létrehozott állományokat. # trap cleanup 1 2 15 # # Gondoskodjunk róla, hogy a feladat megkezdésekor még egyetlen # használt állomány sem létezik. # cleanup # # Kössük össze a szabványos bemenetet egy DVI állománnyal (amit # majd nyomtatni akarunk). # ln -s /dev/fd/0 hpdf$$.dvi || fatal "Cannot symlink /dev/fd/0" # # LF = CR+LF # printf "\033&k2G" || fatal "Cannot initialize printer" # # Alakítsuk át az adatot és nyomtassunk. A dvilj2p által visszaadott érték # nem túlságosan megbízható, ezért ne is foglalkozzunk vele. # dvilj2p -M1 -q -e- dfhp$$.dvi # # Takarítsunk el magunk után és lépjünk ki szabályosan # cleanup exit 0 Automatikus konverziók: a konverziós szûrõk helyett A konverziós szûrõk sokat segítenek egy kényelmes nyomtatási környezet kialakításában, azonban a használatukhoz a felhasználóknak (az &man.lpr.1; parancson keresztül) egyenként hivatkozniuk kell rájuk. Ha a rendszerünk felhasználói nem eléggé mûveltek számítástechnikai téren, akkor még egy szûrõ megadása is zavaró lehet számukra. Ami még ennél is rosszabb, hogy egy rosszul megadott szûrõ hatására a nyomtató sem fogja jól kezelni az adott állomány formátumát és erre válaszul akár többszáz lapot is pillanatok alatt kiköphet magából. A konverziós szûrõk telepítése helyett gyakran csak egy (alapértelmezett) szövegszûrõre van szükségünk, amely kideríti a nyomtatandó állomány pontos formátumát és magától elindítja a neki megfelelõ konverziós szûrõt. Ilyen esetekben például a file parancs pont a hasznunkra válhat. Persze bizonyos állománytípusok közt nagyon nehéz különbséget tenni — de ezekre továbbra is adhatunk még külön konverziós szûrõket. apsfilter nyomtatás szûrõk apsfilter A &os; Portgyûjteményében találhatunk egy apsfilter elnevezésû szövegszûrõt (print/apsfilter), ami képes ilyen automatikus konverzióra. Képes felismerni a nyers szöveget, &postscript; programokat, DVI és szinte bármilyen formátumú állományokat, lefuttatni rájuk a megfelelõ átalakítástokat, majd kinyomtatni ezeket. Kimeneti szûrõk Az LPD nyomtatási rendszer kezel egy eddig még nem tárgyalt szûrõtípust is: ez a kimeneti szûrõ. A kimeneti szûrõ a szövegszûrõhöz hasonlóan csak nyers szöveg nyomtatására használatos, de tartalmaz néhány egyszerûsítést. Ha kizárólag csak kimeneti szûrõket alkalmazunk, akkor: Az LPD az egész nyomtatási feladathoz egyetlen kimeneti szûrõt fog használni, nem pedig minden állományhoz külön. Az LPD a kimeneti szûrõ számára nem nyújt semmilyen segítséget a munkán belül szereplõ állományok kezdetének vagy végének megállapításában. Az LPD a szûrõnek nem adja át sem a felhasználó hozzáférését, sem pedig gépnevét, ezért nyilvántartásra nem alkalmas. Mindent összegezve lényegében csak két paramétert kap meg: szûrõnév -wszélesség -lhossz ahol a szélesség a kérdéses nyomtató pw tulajdonságából, a hossz pedig a pl tulajdonságából származik. Ne bûvöljön el minket a szûrõ egyszerûsége! Ha például a munkában minden állományt újabb lapon szeretnénk kezdeni, akkor azt kimeneti szûrõvel nem tudjuk megoldani. Erre a célra használjunk szövegszûrõt (másik nevén bemeneti szûrõt), lásd A szövegszûrõ telepítése szakaszt. Hovatovább, a kimeneti szûrõ valójában sokkal bonyolultabb abban a tekintetben, hogy a beérkezõ adatok közül neki kell kikeresnie a speciális jelentéssel bíró karaktereket ugyanúgy, ahogy az LPD helyett saját magának kell küldenie a jelzéseket. Azonban a kimeneti szûrõk használata elkerülhetetlen, ha például fejléclapokat akarunk nyomtatni, és esetleg még különbözõ inicializálásra használatos speciális kódokat vagy karakterláncokat akarunk ez elõtt kiküldeni. (Ellenben badarság a fejléclapoktól követelni a felhasználó adatait, hiszen az LPD a kimeneti szûrõnek nem ad semmilyen erre vonatkozó információt.) Egyetlen nyomtató esetén az LPD egyaránt lehetõvé teszi kimeneti, szöveg- és más egyéb szûrõk használatát. Ilyenkor az LPD a kimeneti szûrõn keresztül csak a fejlécet tartalmazó oldal (lásd a Fejléclapok szakaszt) nyomtatását indítja el. Ezt követõen az LPD arra számít, hogy a kimeneti szûrõ két karakter, az ASCII 031 és az ezt követõ ASCII 001, hatására leállítja magát. Amikor tehát a kimeneti szûrõ érzékeli ezt a két karaktert (031, 001), akkor a SIGSTOP jelzéssel le kell állnia. Miután az LPD lefuttatta a többi szûrõt, a SIGCONT jelzéssel újraindítja a kimeneti szûrõt. Ha van kimeneti szûrõnk, de nincs szövegszûrõnk, akkor az LPD minden további feldolgozás nélkül továbbadja a munkát a kimeneti szûrõnek. Ahogy már korábban is említettük, a kimeneti szûrõ a munkában levõ összes állományt egymás után nyomtatja ki, lapdobások vagy bármilyen más papírmozgatás nélkül, ezért valószínûleg nem ez kell nekünk. Az esetek túlnyomó részében ehhez elég egy szövegszûrõ. A korábban szövegszûrõként beharangozott lpf program kimeneti szûrõként is képes funkcionálni. Ha szükségünk lenne egy gyorsan összecsapható kimeneti szûrõre, és nem akarunk a speciális karakterek valamint a jelzések küldésével elidõzni, akkor próbálkozzunk az lpf használatával. Az lpf parancsot mellesleg becsomagolhatjuk egy olyan szkriptbe is, amely elvégzi a nyomtató számára szükséges inicializálást. Az <command>lpf</command> szövegszûrõ A &os; bináris terjesztéséhez mellékelt /usr/libexec/lpr/lpf program egy szövegszûrõ (bemeneti szûrõ), amely képes (az lpr paranccsal hozzáadott munkákat) tabulálni, (az lpr paranccsal felvett munkákban) a vezérlõkaraktereket figyelemen kívül hagyni, a munkában elõforduló törlések és behúzások nyomtatási pozícióját igazítani és nyilvántartani a kinyomtatott lapokat. Kimeneti szûrõként is tud viselkedni. Az lpf szûrõ rengeteg nyomtatási környezetben felhasználható. Habár nem képes a nyomtatónak inicializáló jelsorozatokat küldeni, mégis könnyû olyan szkriptet írni, amely elvégzi ezeket a hiányzó kezdeti beállításokat, majd lefuttatja az lpf szûrõt. oldalak nyilvántartása nyilvántartás nyomtató Az lpf akkor lesz képes helyesen számolni a kinyomtatott lapokat, ha ehhez az /etc/printcap állományban jól töltjük ki a pw és pl tulajdonságokat. Ezen értékek segítségével határozható meg ugyanis, hogy mennyi szöveg fért rá egy lapra és így mennyi lapot emésztett fel az adott felhasználó által küldött munka. A nyomtatás nyilvántartásával kapcsolatban A nyomtató használatának nyilvántartása címû szakaszt érdemes elolvasni. Fejléclapok Ha nagyon sok felhasználónk van, és sok különbözõ nyomtatót is használnak, akkor elõbb vagy utóbb minden bizonnyal elkerülhetetlenné fog válni a fejléclapok használata. munkalapok fejléclapok fejléclapok A fejléc-, vagy más néven munka vagy elválasztó lapok segítik elõ a kinyomtatott munkák azonosítását. A többi dokumentumtól kirívó módon, általában dekoratív keretben, nagy, vastag betûkkel nyomtatódnak ki, hogy a halomnyi papír között a felhasználók könnyedén megtalálhassák az elküldött munkáik eredményét. Természetesen a fejléclapok nyilvánvaló hátulütõje, hogy így minden munkához még egy lappal többet kell elhasználni és mivel gyakorlatilag néhány percnél tovább nincs is rájuk szükség, meglehetõsen hamar a kukába kerülnek. (A fejléclapok munkánként jönnek létre, nem pedig az munkákban levõ állományokhoz egyenként, ezért nem is akkora pazarlás ez.) Az LPD rendszer képes magától fejléclapokat készíteni a nyomtatásokhoz, amennyiben a nyomtatónk képes közvetlenül nyers szöveget nyomtatni. Ha &postscript; nyomtatónk van, akkor ennek legyártásához egy külsõ programra van szükségünk, lásd a Fejléclapok &postscript; nyomtatókon szakaszt. A fejléclapok engedélyezése Az Alacsonyszintû nyomtatóbeállítás címû szakaszban az /etc/printcap állományban a sh (úgy mint suppress header) tulajdonsággal kikapcsoltuk a fejléclapokat. A fejléclapok engedélyezéséhez mindösszesen el kell távolítanunk ezt az sh tulajdonságot. Ez túl egyszerû, nemde? Igen, ez így van. Elõfordulhat, hogy szükségünk van még egy olyan kimeneti szûrõre is, amely inicializáló karaktereket küld a nyomtatónak. Íme egy példa ehhez a Hewlett Packard PCL-kompatibilis nyomtatói esetére: #!/bin/sh # # hpof - Kimeneti szûrõ Hewlett Packard PCL-kompatibilis nyomtatókhoz # Helye: /usr/local/libexec/hpof printf "\033&k2G" || exit 2 exec /usr/libexec/lpr/lpf Az of tulajdonsággal adjuk meg a kimeneti szûrõt. A Kimeneti szûrõk szakaszban errõl részletesebben is olvashatunk. A korábban ismertetett teak nevû nyomtatóhoz most az alábbi minta /etc/printcap állományt mellékeljük. Itt engedélyeztük a fejléclapokat és hozzátettük az iménti kimeneti szûrõt: # # /etc/printcap (orchid) # teak|hp|laserjet|Hewlett Packard LaserJet 3Si:\ :lp=/dev/lpt0:sd=/var/spool/lpd/teak:mx#0:\ :if=/usr/local/libexec/hpif:\ :vf=/usr/local/libexec/hpvf:\ :of=/usr/local/libexec/hpof: Mostantól kezdve, amikor a felhasználók a teak nyomtatón akarnak nyomtatni, minden munkához kapni fognak egy fejléclapot. Amennyiben a kedves felhasználók mégis keresgetni akarják a nyomtatásaikat, az lpr paranccsal tetszõleges módon letilthatják azokat. Az &man.lpr.1; többi hasonló opcióját A fejléclapokhoz tartozó beállítások szakaszban találjuk. Az LPD minden fejléclap után egy lapdobást küld. Ha erre a célra a nyomtatónk egy eltérõ karaktert vagy karaktersorozatot használ, akkor azt az /etc/printcap állomány ff tulajdonságával határozhatjuk meg. A fejléclapok vezérlése A fejléclapok engedélyezésével az LPD egy ún. hosszú fejlécet fog készíteni, vagyis a felhasználót, gépet és a munkát jól azonosító, egész lapot kitöltõ óriási betûket. Erre egy példa (amiben a rose nevû géprõl kelly nyomtatta ki az outline elnevezésû munkát): k ll ll k l l k l l k k eeee l l y y k k e e l l y y k k eeeeee l l y y kk k e l l y y k k e e l l y yy k k eeee lll lll yyy y y y y yyyy ll t l i t l oooo u u ttttt l ii n nnn eeee o o u u t l i nn n e e o o u u t l i n n eeeeee o o u u t l i n n e o o u uu t t l i n n e e oooo uuu u tt lll iii n n eeee r rrr oooo ssss eeee rr r o o s s e e r o o ss eeeeee r o o ss e r o o s s e e r oooo ssss eeee Job: outline Date: Sun Sep 17 11:04:58 1995 Ezt követõen az LPD elküld még egy lapdobást is, ezért maga a munka egy új oldalon fog kezdõdni (kivéve, ha az /etc/printcap állományban az adott nyomtatóhoz tartozó bejegyzésben megadtuk az sf (úgy mint suppress form feeds, vagyis a lapdobások letiltása) tulajdonságot. Ha úgy jobban tetszik, akkor az /etc/printcap állományban a sb tulajdonsággal az LPD utasítható rövid fejlécek készítésére is. Ilyenkor a fejléclap tartalma mindössze ennyi lesz: rose:kelly Job: outline Date: Sun Sep 17 11:07:51 1995 Alapértelmezés szerint az LPD elõször a fejléclapot majd a munkát nyomtatja ki. Ezt a sorrendet az /etc/printcap állományban a hl (header last) tulajdonsággal meg tudjuk fordítani. A nyomtató használatának nyilvántartása Az LPD által felkínált fejléclapok használata során egyetlen irányelv érvényesül a nyilvántartásukban: a fejléclapok költségmentesek. De miért? Azért, mert kizárólag csak a kimeneti szûrõ képes a fejléclapok viselkedését irányítani, ami viszont nem képes semmiféle nyilvántartásra, hiszen nem kapja meg az ehhez szükséges felhasználói- vagy gépnév információkat, illetve nyilvántartásokat. Emiatt fogalma sincs róla, hogy kit terhel az adott nyomtató használata. Úgy sem tudjuk megoldani a problémát, ha a szöveg- vagy konverziós szûrõkben (ahol már rendelkezésünkre állnak a felhasználó és a gépének adatai) növeljük a lapok számát eggyel a munkában, mivel a felhasználók az lpr parancs használatával kedvük szerint letilthatják a fejléclapokat. Ezt ugyan alapvetõen a természetet óvni kívánó felhasználók részesítik elõnyben, de ettõl függetlenül sem erõszakolhatjuk rá mindenkire. Az sem elég, ha minden szûrõ létrehozza a saját fejlécét (amiért aztán pénzt kérhetnénk). Mivel ha a felhasználók az lpr paranccsal le akarják tiltani a fejlécek használatát, attól a szûrõkhöz még mindig létrejönnek, hiszen az LPD a opcióról semmilyen értesítést nem küld át a szûrõknek. Nos, ilyenkor mitévõk legyünk? A lehetõségeink: Elfogadjuk az LPD elvét, és nem számítunk fel költséget a fejléclapokra. Az LPD helyett egy másik nyomtatási rendszert használunk, például az LPRng rendszert. A Más nyomtatási rendszerek címû szakaszban kiderül, milyen alternatívák érhetõek el az LPD kiváltására. Írjunk mi magunk egy intelligens kimeneti szûrõt. Normális esetben a kimeneti szûrõk nem valók másra, csupán a nyomtató alaphelyzetbe hozására vagy egyszerûbb karakterkonverziók elvégzésére. Fejléclapokhoz és nyers szöveget tartalmazó munkákhoz remekül használható (ahol nincs szöveg- (avagy bemeneti) szûrõ). Azonban ha a nyers szövegekhez van szövegszûrõnk, akkor az LPD a kimeneti szûrõt csak a fejléclapokhoz indítja el. Emellett a kimeneti szûrõ az LPD által generált fejléc szövegébõl képes megmondani, melyik felhasználóhoz és géphez tartozik a szóbanforgó fejléc. A módszer egyetlen bökkenõje, hogy a nyilvántartásokat tároló állományról viszont még így se tudunk semmilyen információt szerezni (mivel nem kapjuk meg az af tulajdonsággal beállított állomány nevét). Ha azonban egy rendszerszinten elérhetõ állományba mentjük ezeket az adatokat, akkor akár bele is drótozhatjuk ezt a kimeneti szûrõbe. A kimeneti szûrõ az adatot megtalálásában ilyenkor úgy tudunk segíteni, ha az /etc/printcap állományban az sh (rövid fejléc) tulajdonságot állítjuk be. De ez igazából sok hûhó semmiért, és a felhasználók is jobban megbecsülik az olyan nagylelkû rendszergazdát, aki nem számítja fel nekik a fejléclapokat. Fejléclapok &postscript; nyomtatókon Ahogy arról már korábban is szó esett, az LPD képes többféle nyomtató számára is megfelelõ, nyers szövegû fejléclapokat készíteni. Persze a &postscript; közvetlenül nem képes nyers szövegek nyomtatására, ezért az LPD ezen lehetõsége lényegében használhatatlan — többnyire. Ilyen helyzetben a fejléclapok használatának nyilvánvaló módja, hogy minden szövegszûrõt fejlécek gyártására utasítunk. Ezek a szûrõk a felhasználóról és a gépérõl kapott információkból össze tudják állítani a megfelelõ fejléclapot. A megoldás hátránya, hogy ez még olyankor is megtörténik, amikor a felhasználók az lpr paranccsal küldik a munkájukat. Kísérletezzünk egy kicsit ezzel a módszerrel! A most következõ szkript három paramétert fogad el (a felhasználó hozzáférést, a gép és a munka nevét), majd ezekbõl létrehoz egy egyszerû &postscript; formátumú fejlécet: #!/bin/sh # # make-ps-header - PostScript fejléc létrehozása a szabvány kimenetre # Helye: /usr/local/libexec/make-ps-header # # # Ezek itt a PostScript által használt egységekben vannak megadva # (72/col vagy 28/cm). Írjuk át az általunk használt papírméretre, # A4-re vagy amit éppen használunk: # page_width=612 page_height=792 border=72 # # A paraméterek ellenõrzése. # if [ $# -ne 3 ]; then echo "Usage: `basename $0` <user> <host> <job>" 1>&2 exit 1 fi # # Mentsük el ezeket, leginkább az olvashatóság miatt. # user=$1 host=$2 job=$3 date=`date` # # Küldjük el a PostScript-kódot a szabványos kimenetre. # exec cat <<EOF %!PS % % Gondoskodjunk róla, hogy ne zavarjuk az utánunk következõ % felhasználó munkáját. % save % % Csináljunk egy csúf vastag szegélyt, körbe a papíron. % $border $border moveto $page_width $border 2 mul sub 0 rlineto 0 $page_height $border 2 mul sub rlineto currentscreen 3 -1 roll pop 100 3 1 roll setscreen $border 2 mul $page_width sub 0 rlineto closepath 0.8 setgray 10 setlinewidth stroke 0 setgray % % Jelenítsük meg a felhasználó azonosítóját szép, feltûnõ % betûkkel. % /Helvetica-Bold findfont 64 scalefont setfont $page_width ($user) stringwidth pop sub 2 div $page_height 200 sub moveto ($user) show % % Most pedig mutassuk az unalmas részleteket. % /Helvetica findfont 14 scalefont setfont /y 200 def [ (Job:) (Host:) (Date:) ] { 200 y moveto show /y y 18 sub def } forall /Helvetica-Bold findfont 14 scalefont setfont /y 200 def [ ($job) ($host) ($date) ] { 270 y moveto show /y y 18 sub def } forall % % Ennyi lett volna. % restore showpage EOF Ezzel a szkripttel pedig mindegyik konverziós- és szövegszûrõ elõször létrehoz egy fejléclapot, majd kinyomtatja a felhasználó munkáját. Íme egy korábban már bemutatott DVI szûrõ, amit most kiegészítünk a fejléclapok használatával: #!/bin/sh # # psdf - DVI szûrõ PostScript nyomtatóhoz # Helye: /usr/local/libexec/psdf # # Az lpr -d parancs hatására hívódik meg. # orig_args="$@" fail() { echo "$@" 1>&2 exit 2 } while getopts "x:y:n:h:" option; do case $option in x|y) ;; # Ignore n) login=$OPTARG ;; h) host=$OPTARG ;; *) echo "LPD started `basename $0` wrong." 1>&2 exit 2 ;; esac done [ "$login" ] || fail "No login name" [ "$host" ] || fail "No host name" ( /usr/local/libexec/make-ps-header $login $host "DVI File" /usr/local/bin/dvips -f ) | eval /usr/local/libexec/lprps $orig_args Láthatjuk, hogy a szûrõnek a felhasználói- és a gépnév megállapításához végig kell néznie a paraméterek listáját. Ez lényegében minden más konverziós szûrõnél ugyanígy néz ki. Ez a lista azonban a szövegszûrõk esetén némileg eltér (lásd a Hogyan mûködnek a szûrõk? szakaszt). Már az elõbbiekben is tárgyaltuk, hogy ez a megoldás, habár eléggé egyszerû, az lpr számára nem teszi lehetõvé a fejléclapok letiltását (a opció). Ha a felhasználóink kímélni akarják a fákat (vagy meg akarják úszni a fejléclapok égbeszökõ költségeit), akkor ezt nem tudják megtenni, hiszen a szûrõk minden munkához készíteni fognak fejléceket. Ezt a korlátozást csak úgy tudjuk elsöpörni, ha bevetjük a A nyomtató használatának nyilvántartása szakaszban leírt cselt, tehát készítünk egy olyan kimeneti szûrõt, amely megkeresi az LPD-vel generált fejléceket és létrehozza azok &postscript; változatát. Ha valaki az lpr paranccsal küld nyomtatnivalót, akkor LPD nem készít hozzá fejléclapot, ahogy a kimeneti szûrõnk sem. A kimeneti szûrõ minden más esetben beolvassa az LPD által küldött szöveget és átküldi a neki megfelelõ &postscript; kódot a nyomtatóra. Ha soros &postscript; nyomtatónk van, akkor használhatjuk a psof kimeneti szûrõhöz tartozó lprps parancsot is, ami pontosan az elõbbit végzi el. Hozzátennénk azonban, hogy a psof nem számolja a fejléclapokat. Hálózati nyomtatás nyomtató hálózati hálózati nyomtatás A &os; tud hálozaton is nyomtatni, vagyis tud távoli számítógépeknek is nyomtatási munkát küldeni. A hálózati nyomtatás kifejezés általánosságban véve két különbözõ dolgra utalhat: Egy távoli számítógéphez kapcsolt nyomtató hozzáférését. A géphez a nyomtató a hagyományos soros vagy párhuzamos csatolófelületen keresztül kapcsolódik, amit aztán az LPD alkalmas beállításával a hálózaton mindenki számára elérhetõvé teszünk. A Távoli számítógépekre csatlakoztatott nyomtatók címû szakasz errõl szól. Egy közvetlenül a hálózatra kapcsolt nyomtató hozzáférését. A nyomtató tehát rendelkezik még egy hálózati csatlakozással is a hagyományos soros vagy párhuzamos felület mellett (vagy éppen helyett). Egy ilyen nyomtató a következõképpen mûködhet: Elfogadja az LPD kéréseit, és még képes munkákat is tárolni. Ebben az esetben teljesen egyenértékû egy LPD alkalmazást futtató számítógéppel. Ekkor nincs más teendõnk, csak követnünk kell a Távoli számítógépeken telepített nyomtatók címû szakasz utasításait. Hálózati adatfolyamokkal dolgozik. Ebben az esetben a nyomtatót hozzá kell kapcsolnunk a hálózaton található egyik számítógéphez, ami majd a munkák tárolásáért és folyamatos küldéséért lesz felelõs. A Nyomtatók hálózati adatcsatlakozással szakasz az ilyen fajtájú nyomtatók telepítésére tesz néhány javaslatot. Távoli számítógépekre csatlakoztatott nyomtatók Az LPD nyomtatási rendszer alapból képes más, szintén LPD-t (vagy vele kompatibilis rendszert) futtató számítógépekre munkákat küldeni. Ezzel lényegében az egyik géphez hozzá tudunk kapcsolni egy nyomtatót, amit aztán a többiek számára elérhetõvé teszünk. Ez olyan nyomtatók esetében is mûködik, amelyek ismerik az LPD által alkalmazott protokollt. A távoli nyomtatáshoz elõször telepítsük a nyomtatót valamelyik számítógépre az Alacsonyszintû nyomtatóbeállítás szakaszban leírtak szerint, és ezzel az lesz a nyomtatószerverünk. Ezután, amennyiben szükségesnek találjuk, végezzünk magasabb szintû nyomtatóbeállításokat is. Ne felejtsük el kipróbálni a nyomtatón, hogy rendesen mûködik az LPD mindegyik olyan beállításával, amit engedélyeztünk. Emellett gondoskodjunk minden olyan jogosultságról is, amivel a helyi számítógéprõl el tudjuk érni a távoli számítógép által felkínált LPD szolgáltatást (lásd Távoli számítógépekrõl érkezõ kérések szabályozása). nyomtató hálózati hálózati nyomtatás Ha olyan nyomtatót használunk, aminek a hálózati felülete kompatibilis az LPD rendszerrel, akkor az elõbb említett nyomtatószerver lényegében maga lesz a nyomtató, valamint a nyomtató neve a rajta beállított név. Ezzel kapcsolatban olvassuk el a nyomtatóhoz és/vagy a hálózati csatolójához mellékelt dokumentációt. Amikor a Hewlett Packard Laserjet típusú nyomtatóit használjuk, a text nevû nyomtatónév magától elvégzi a LF és CRLF formátumú sortörések közti átalakítást, ezért ilyenkor nincs szükségünk a hpif szkriptre. Ezután ha szeretnénk más gépek részére is elérhetõvé tenni a frissen telepített nyomtatónkat, adjuk meg mindegyikük /etc/printcap állományában a következõket: Tetszõlegesen választott nevet, álneveket. Az egyszerûség kedvéért azonban itt érdemes ugyanazokat a neveket választani, mint amit a nyomtatószerveren is használunk. Szándékosan hagyjuk az lp tulajdonságot üresen (:lp=:). Hozzunk létre egy nyomtatási könyvtárat, és jelöljük meg a helyét az sd tulajdonsággal. Az LPD itt fogja összegyûjteni a munkákat, mielõtt elküldené azokat a nyomtatószervernek. Adjuk meg a nyomtatószerver nevét az rm tulajdonság segítségével. Az rp tulajdonsággal adjuk meg a nyomtatószerverre csatlakoztatott nyomtató nevét. Kész! Az /etc/printcap állományban már nem kell megadni konverziós szûrõket, oldalbeállításokat és semmi más egyebet. Lássunk mindezekre egy példát. A rose nevû számítógéphez két nyomtató csatlakozik, a bamboo és a rattan. Most pedig beállítjuk, hogy az orchid nevû gép felhasználói képesek legyenek ezekkel a nyomtatókkal dolgozni. Ekkor a most következõk szerint fog kinézni az orchid (a Fejléclapok engedélyezése szakaszban bemutatott) /etc/printcap állománya. Tartalmazza a teak nevû nyomtató beállításait is, és ehhez fogjuk hozzáadni a rose másik két nyomtatóját: # # /etc/printcap (orchid) - a rose két (távoli) nyomtatójának # hozzáadása # # # A "teak" egy helyi nyomtató, közvetlenül az orchidhoz # csatlakozik: # teak|hp|laserjet|Hewlett Packard LaserJet 3Si:\ :lp=/dev/lpt0:sd=/var/spool/lpd/teak:mx#0:\ :if=/usr/local/libexec/ifhp:\ :vf=/usr/local/libexec/vfhp:\ :of=/usr/local/libexec/ofhp: # # A "rattan" rose-hoz csatlakozik, így küldhetünk neki munkát: # rattan|line|diablo|lp|Diablo 630 Line Printer:\ :lp=:rm=rose:rp=rattan:sd=/var/spool/lpd/rattan: # # A "bamboo" is a rose-hoz tartozik: # bamboo|ps|PS|S|panasonic|Panasonic KX-P4455 PostScript v51.4:\ :lp=:rm=rose:rp=bamboo:sd=/var/spool/lpd/bamboo: Ezután más csak létre kell hoznunk a megfelelõ nyomtatási könyvtárakat az orchid nevû gépen: &prompt.root; mkdir /var/spool/lpd/rattan /var/spool/lpd/bamboo &prompt.root; chmod 770 /var/spool/lpd/rattan /var/spool/lpd/bamboo &prompt.root; chown daemon:daemon /var/spool/lpd/rattan /var/spool/lpd/bamboo Mostantól kezdve az orchid felhasználói képesek lesznek nyomtatni a rattan és bamboo nevû nyomtatókon is. Ezért, ha az orchid egyik felhasználója beírja, hogy: &prompt.user; lpr bamboo sushi-leírás.dvi Az orchid gépen mûködõ LPD rendszer ezt a munkát a bemásolja a /var/spool/lpd/bamboo nevû nyomtatási könyvtárba és feljegyzi róla, hogy a nyomtatásához DVI szûrõre lesz szükség. Ahogy rose gépen található bamboo nyomtatási könyvtárában elegendõ hely keletkezik, a két LPD átküldi egymás közt a rose nevû gépre az állományt. Ezután az állomány egészen addig várakozik a rose nyomtatási sorában, amíg végezetül kinyomtatásra nem kerül. A rose fogja átalakítani DVI-rõl &postscript; formátumra átalakítani (mivel a bamboo egy &postscript; nyomtató). Nyomtatók hálózati adatcsatlakozással Amikor hálózati kártyát vásárolunk a nyomtatónkhoz, általában két változatukkal találkozhatunk: az egyikük nyomtatási rendszerként mûködik (ez a drágább), a másikuk pedig egyszerûen csak soros vagy párhuzamos csatlakozón továbbítandó adatként közvetíti az adatokat a nyomtató felé (az olcsóbb). A drágábbik változatot az elõzõ, Távoli számítógépekre csatlakoztatott nyomtatók címû szakaszban leírtak szerint tudjuk használni. Az /etc/printcap állományban ugyan meg tudjuk adni, hogy a nyomtató soros vagy párhuzamos portra csatlakozik, és azon keresztül milyen adatátviteli sebességgel (amennyiben soros), forgalomirányítással, tabulálással, sortörési konvenció szerint stb. kommunikáljunk vele. Azonban TCP/IP vagy más hálózati porton ülõ nyomtatók adatait itt nem tudjuk kifejteni. A hálózatra kötött nyomtatók használatához lényegében egy olyan külön kifejlesztett kommunikációs programra van szükségünk, amely a szöveg- vagy konverziós szûrõkhöz hasonló módon hívható meg. Erre rögtön adunk is egy példát: a netprint szkript a szabványos bemenetrõl beolvassa az összes kinyomtatandó adatot és átküldi azokat a hálózatra csatlakoztatott nyomtatónak. A szkript elsõ paramétereként a nyomtató hálózati nevét adjuk meg, másodiknak pedig portot. Azonban megjegyezzünk, hogy ez csak egyirányú kommunikációt tesz lehetõvé (a &os;-tõl a nyomtatóig). Sok hálózati nyomtató viszont két irányban is képes kommunikálni, ezért érdemes lehet ezt kihasználni (a nyomtató állapotának lekérdezésére, nyilvántartások készítésére stb). #!/usr/bin/perl # # netprint - A hálózatra csatlakoztatott nyomtató szövegszûrõje # Helye: /usr/local/libexec/netprint # $#ARGV eq 1 || die "Usage: $0 <printer-hostname> <port-number>"; $printer_host = $ARGV[0]; $printer_port = $ARGV[1]; require 'sys/socket.ph'; ($ignore, $ignore, $protocol) = getprotobyname('tcp'); ($ignore, $ignore, $ignore, $ignore, $address) = gethostbyname($printer_host); $sockaddr = pack('S n a4 x8', &AF_INET, $printer_port, $address); socket(PRINTER, &PF_INET, &SOCK_STREAM, $protocol) || die "Can't create TCP/IP stream socket: $!"; connect(PRINTER, $sockaddr) || die "Can't contact $printer_host: $!"; while (<STDIN>) { print PRINTER; } exit 0; Rengeteg szûrõben fel tudjuk használni ezt a szkriptet. Például tegyük fel, hogy egy Diablo 750-N típusú sornyomtatót csatlakoztattunk a hálózatra, amely az 5100-as porton várja a nyomtatandó adatokat. A hálózati neve most scrivener lesz. Íme a hozzátartozó szövegszûrõ: #!/bin/sh # # diablo-if-net - Az 5100-as porton figyelõ `scrivener' nevû Diablo # nyomtató szövegszûrõje. Helye: /usr/local/libexec/diablo-if-net # exec /usr/libexec/lpr/lpf "$@" | /usr/local/libexec/netprint scrivener 5100 A nyomtató használatának szabályozása nyomtató a hozzáférés korlátozása Ebben a szakaszban a nyomtató használatának korlázásáról írunk. Az LPD rendszeren keresztül meghatározhatjuk, hogy ki képes helyben vagy távolról hozzáférni a nyomtatóhoz, mennyi másolatot nyomtathat, mennyi és egyenként mekkora munkákat küldhet. A másolatok számának szabályozása Az LPD segítségével a felhasználók egy állományt könnyen ki tudnak nyomtatni akár többször is. Ha (például) a felhasználó egy munka nyomtatásához az lpr parancsot használja, akkor a munkában levõ összes állományból öt példányt kap. Ennek létjogosultságát azonban nekünk kell megítélni. Amennyiben úgy érezzük, hogy a további példányok készítése csupán felesleges papír- és tintapazarlás, akkor az sc tulajdonság megadásával az /etc/printcap állományban kikapcsolhatjuk az &man.lpr.1; lehetõség használatát. Így amikor a felhasználók a kapcsolóval küldenek el munkákat a nyomtatóra, a következõt fogják tapasztalni: lpr: multiple copies are not allowed Fordítása: lpr: másolatok nyomtatása nem engedélyezett Vigyázzunk arra, hogy ha távoli számítógépen zajlik a nyomtatás (lásd Távoli számítógépekre csatlakoztatott nyomtatók), akkor az sc tulajdonságot a távoli számítógép /etc/printcap állományában is be kell állítani, máskülönben a felhasználók egy másik számítógéprõl mindig képesek lesznek több példány nyomtatására. Nézzünk erre egy példát. Itt most a rose nevû számítógép /etc/printcap állományát vesszük szemügyre. Ebben a rattan egy nagyon szívélyes nyomtató lesz, ezért engedélyezi a másolatok nyomtatását, azonban a bamboo nevû lézernyomtató nála már sokkal válogatósabb lesz, ezért a beállításai közt az sc tulajdonsággal kikapcsoljuk a másodpéldányok nyomtatását: # # /etc/printcap (rose) - A másolatok korlátozása a "bamboo" # nevû nyomtatón # rattan|line|diablo|lp|Diablo 630 Line Printer:\ :sh:sd=/var/spool/lpd/rattan:\ :lp=/dev/lpt0:\ :if=/usr/local/libexec/if-simple: bamboo|ps|PS|S|panasonic|Panasonic KX-P4455 PostScript v51.4:\ :sh:sd=/var/spool/lpd/bamboo:sc:\ :lp=/dev/ttyd5:ms#-parenb cs8 clocal crtscts:rw:\ :if=/usr/local/libexec/psif:\ :df=/usr/local/libexec/psdf: Az sc tulajdonságot az orchid /etc/printcap állományában is meg kell adni (és ha már itt vagyunk, akkor tegyük meg ugyanezt a teak esetében is): # # /etc/printcap (orchid) - Nincsenek másodpéldányok sem a helyi # "teak" nyomtatón, sem pedig a távoli "bamboo" nyomtatón teak|hp|laserjet|Hewlett Packard LaserJet 3Si:\ :lp=/dev/lpt0:sd=/var/spool/lpd/teak:mx#0:sc:\ :if=/usr/local/libexec/ifhp:\ :vf=/usr/local/libexec/vfhp:\ :of=/usr/local/libexec/ofhp: rattan|line|diablo|lp|Diablo 630 Line Printer:\ :lp=:rm=rose:rp=rattan:sd=/var/spool/lpd/rattan: bamboo|ps|PS|S|panasonic|Panasonic KX-P4455 PostScript v51.4:\ :lp=:rm=rose:rp=bamboo:sd=/var/spool/lpd/bamboo:sc: Az sc tulajdonság használatával ugyan megakadályozzuk az lpr parancs teljesítését, azonban ez még mindig nem óv minket attól, hogy a felhasználók képesek legyenek többször egymás után lefuttatni az &man.lpr.1; parancsot, vagy éppen egyetlen munkában több állományt is elküldeni: &prompt.user; lpr forsale.sign forsale.sign forsale.sign forsale.sign forsale.sign Számos módszer kínálkozik az effajta visszaélések kivédésére (beleértve a figyelmen kívül hagyást is), lehet velük kísérletezgetni! A nyomtatók hozzáférésének szabályozása A &unix; csoportkezelésével és az /etc/printcap állományban található rg tulajdonság felhasználásával korlátozni tudjuk, ki milyen nyomtatón dolgozhat. Ehhez mindösszesen annyit kell tennünk, hogy besoroljuk egy csoportba azokat a felhasználókat, amelyek hozzáférhetnek a nyomtatóhoz, és az rg tulajdonsággal megnevezzük azt. A csoporton kívüli felhasználókat (köztük magát a root felhasználót is) pedig ezután így üdvözli a rendszer, ha megpróbálnak valamit kinyomtatni egy korlátozott felhasználású nyomtatón: lpr: Not a member of the restricted group Az üzenet fordítása: lpr: Nem jogosult felhasználó Ha erre a távoli számítógépek esetén szükségünk lenne (lásd Távoli számítógépekre csatlakoztatott nyomtatók), akkor tegyük ugyanazt, mint amit az sc (a másodpéldányok letiltása, suppress multiple copies) tulajdonság esetén is, vagyis az rg tulajdonságot adjuk meg azokon a távoli számítógépeken is, amelyek hozzá tudnak férni a megosztott nyomtatóhoz. Például megengedjük, hogy a rattan nevû nyomtatót bárki használhassa, azonban a bamboo nyomtatón csak az artists nevû csoport használhatja. Következzen hát akkor a rose korábbról már ismert /etc/printcap állománya: # # /etc/printcap (rose) - A bamboo hozzáférésének korlátozása # rattan|line|diablo|lp|Diablo 630 Line Printer:\ :sh:sd=/var/spool/lpd/rattan:\ :lp=/dev/lpt0:\ :if=/usr/local/libexec/if-simple: bamboo|ps|PS|S|panasonic|Panasonic KX-P4455 PostScript v51.4:\ :sh:sd=/var/spool/lpd/bamboo:sc:rg=artists:\ :lp=/dev/ttyd5:ms#-parenb cs8 clocal crtscts:rw:\ :if=/usr/local/libexec/psif:\ :df=/usr/local/libexec/psdf: Most ne bántsuk a másik (az orchid nevû gépen levõ) /etc/printcap állományt. Így persze az orchid bármelyik felhasználója nyomtathat a bamboo nyomtatón. De ez most egy olyan eset, ahol egyébként lekorlátozzuk a orchid elérését is, ezért az ott beengedett felhasználók már akár használhatják is a nyomtatót. Vagy sem. Minden nyomtatóhoz csak egy ilyen csoportot adhatunk meg. A beküldött munkák méretének szabályozása nyomtatási munkák Ha sok felhasználó szeretne a nyomtatóinkhoz hozzáférni, akkor minden bizonnyal meg akarunk adni egy felsõ határt a felhasználók által beküldhetõ nyomtatások méretére vonatkozóan. Mivel a nyomtatási könyvtáraknak otthont adó állományrendszer is egyszer betelhet, ezért mindenképpen érdemes gondoskodni arról, hogy mindenki munkáját el tudjuk rendesen tárolni. nyomtatási munkák szabályozása Az LPD az mx tulajdonsággal lehetõséget ad arra, hogy lekorlátozzuk a munkákban található egyes állományok méretét. Ennek mértékegysége egy BUFSIZ blokk, ami pedig 1024 byte. Ha értékül nullát adunk meg, akkor nincs korlátozás, viszont ha semmit sem rögzítünk, akkor az mx tulajdonság alapértéke, vagyis 1000 blokk lesz a határ. Ez az érték a munkákban levõ egyes állományok méretére vonatkozik, nem pedig a munkák teljes méretére. Fontos tudni, hogy az LPD nem dobja vissza a méreten felüli állományokat. Ehelyett a méret alatti részt szépen berakja a sorba és kinyomtatja, a többi pedig elhagyja. Lehetne rajta vitázni, hogy ez mennyire helyes cselekedet. Példaképpen definiáljunk a korábban használt rattan és bamboo nyomtatóinkhoz ilyen korlátokat. Mivel az artists csoport tagjai hajlamosak nagy &postscript; állományokat küldeni, ezért most lekorlátozzuk ezt öt megabyte-ra. A szöveges nyomtatónk esetén azonban nem lesz semmilyen határ: # # /etc/printcap (rose) # # # Itt nincs korlát a munkákra: # rattan|line|diablo|lp|Diablo 630 Line Printer:\ :sh:mx#0:sd=/var/spool/lpd/rattan:\ :lp=/dev/lpt0:\ :if=/usr/local/libexec/if-simple: # # Öt megabyte a PostScript: # bamboo|ps|PS|S|panasonic|Panasonic KX-P4455 PostScript v51.4:\ :sh:sd=/var/spool/lpd/bamboo:sc:rg=artists:mx#5000:\ :lp=/dev/ttyd5:ms#-parenb cs8 clocal crtscts:rw:\ :if=/usr/local/libexec/psif:\ :df=/usr/local/libexec/psdf: Ismét hozzátesszük, hogy ezek a korlátok csak a helyi felhasználókra vonatkoznak. Amennyiben távolról is el lehet érni ezt a nyomtatót, a távoli felhasználókat nem fog semmilyen korlátozás érinteni. Azokon a számítógépeken is meg kell adnunk az /etc/printcap állományban az mx tulajdonságot. Ehhez a Távoli számítógépekre csatlakoztatott nyomtatók címû szakaszban találunk segítséget. Van még egy speciális módszer, amivel képesek vagyunk szabályozni a távolról érkezõ kérések méretét. Errõl a Távoli számítógépekrõl érkezõ kérések szabályozása szakaszban olvashatunk. Távoli számítógépekrõl érkezõ kérések szabályozása Az LPD nyomtatási rendszer több módot is szolgáltat a távolról érkezõ nyomtatási munkák szabályozására: Az elérés szabályozása Az /etc/hosts.equiv és /etc/hosts.lpd állományok segítségével beállíthatjuk, hogy mely távoli számítógépektõl fogadjon el kéréseket az LPD. Az LPD minden kérés elfogadásakor ellenõrzi, hogy a küldõ számítógép címe szerepel-e az említett állományok valamelyikében. Ha nem, akkor az LPD visszautasítja a kérést. A két állomány felépítése egyszerû, mert bennük minden sorban egy-egy hálózati nevet adunk meg. Hozzátennénk azonban, hogy legyünk óvatosak, mivel az /etc/hosts.equiv állományt az &man.ruserok.3; protokoll is használja, ezért ennek módosítása hatással van az &man.rsh.1; és &man.rcp.1; programok mûködésére. Például most nézzük meg a rose /etc/hosts.lpd állományát: orchid violet madrigal.fishbaum.de Ennek megfelelõen tehát a rose elfogadja az orchid, violet és madrigal.fishbaum.de nevû távoli számítógépek kéréseit. Ha bármilyen más gép próbál hozzáférni a rose által felkínált LPD szolgáltatáshoz, visszautasítja. A méret szabályozása Szabályozhatjuk többek közt azt is, hogy mennyi szabad területnek kell fennmaradnia a nyomtatási könyvtárnak otthont adó állományrendszeren. A helyi nyomtató könyvtárában ehhez hozzunk létre egy minfree nevû állományt. Ide írjuk be, mennyi szabad lemezblokk (512 byte-os egység a lemezen) szükségeltetik egy távolról beérkezõ munka fogásához. Így gondoskodhatunk róla, hogy a távoli felhasználók nem fogják eltömíteni az állományrendszerünket, illetve ezzel egyúttal adhatunk némi elõnyt a helyi felhasználóknak is: õk ugyanis még azután is képesek lesznek munkákat küldeni a nyomtatónak, miután az állományrendszeren található szabad terület mennyisége már rég a minfree állományban szereplõ érték alá csökkent. Példaként most a bamboo nevû nyomtatónkhoz adjunk meg egy ilyen minfree állományt. Ehhez az /etc/printcap állományból tudjuk kideríteni a hozzátartozó nyomtatási könyvtárat. Lássuk tehát belõle a bamboo bejegyzését: bamboo|ps|PS|S|panasonic|Panasonic KX-P4455 PostScript v51.4:\ :sh:sd=/var/spool/lpd/bamboo:sc:rg=artists:mx#5000:\ :lp=/dev/ttyd5:ms#-parenb cs8 clocal crtscts:rw:mx#5000:\ :if=/usr/local/libexec/psif:\ :df=/usr/local/libexec/psdf: A nyomtatási könyvtárat az sd tulajdonság határozza meg. Úgy állítjuk most be, hogy az LPD számára a távoli munkák fogadásához ebben a könyvtárban legalább három megabyte (6144 blokk) szabad területnek mindig lennie kell: &prompt.root; echo 6144 > /var/spool/lpd/bamboo/minfree A felhasználók szabályozása Az /etc/printcap állományban megadható rs tulajdonság segítségével korlátozhatjuk a helyi nyomtatókhoz hozzáférni képes távoli felhasználókat. Amikor az rs tulajdonság szerepel egy helyben csatlakozó nyomtató leírásánál, akkor az LPD csak abban az esetben fogad el távoli felhasználóktól munkát, ha a munkát küldõ felhasználónak ugyanazon a néven van a helyi gépen is hozzáférése. Máskülönben az LPD vissza fogja utasítani a kérést. Ez a tulajdonság különösen fontos olyan környezetben, ahol (például) több szervezeti egység használ egyetlen közös hálózatot és bizonyos felhasználók képesek átlépni szervezeti egységük határait, mivel ha a hozzáférést adunk neki a rendszereinkhez, akkor képesek a saját helyükrõl használni ezeket. Ha ehelyett csupán a nyomtatóinkat és a számítógépünk összes erõforrását akarjuk megosztani, akkor létrehozhatunk a számukra olyan token hozzáféréseket is, amikhez nem tartozik sem felhasználói könyvtár, sem pedig parancsértelmezõ (pontosabban a /usr/bin/false). A nyomtató használatának nyilvántartása nyilvántartás nyomtató Tehát szükségünk lenne a nyomtatások költségének elszámolására. Miért is ne tennénk ilyet? A papír és a tinta bizony pénzbe kerül, amihez még hozzájárulnak más egyéb karbantartási költségek is — a nyomtatók dugig vannak mindenféle mozgó alkatrésszel, amelyek elõbb-utóbbi el is romlanak. Tegyük fel, hogy a nyomtatóink kapacitása, kihasználtsága és karbantartási költsége alapján már megállapítottunk egy elszámolási egységet (oldalanként, méterenként, akárminként). De hogyan lássunk hozzá a nyomtatások költségének tényleges nyilvántartásához? Van egy rossz hírünk: az LPD nyomtatási rendszer önmaga nem tud segíteni ebben a feladatban. A nyilvántartás nagyban függ a használt nyomtatóktól, a nyomtatott formátumoktól és nyomtató általunk kiszabott költségeitõl. A nyilvántartás létrehozásához át kell írnunk a nyomtatóhoz tartozó szûrõt (a nyers szövegek költségének felszámításához) és konverziós szûrõket (a különféle formátumok költségei miatt), amikkel aztán számolhatjuk vagy lekérdezhetjük a kinyomtatott lapokat. Egyetlen kimeneti szûrõ használatával szinte semmire se megyünk, mivel az nem képes nyilvántartás vezetésére. Errõl bõvebb útmutatást a Szûrõk szakaszban találhatunk. Általánosságban véve két módon vezethetünk nyilvántartást: Az idõszakos elszámolás a gyakoribb, mivel ez az egyszerûbb. Amikor valaki kinyomtat egy munkát, a szûrõ a nyilvántartást tároló állományba feljegyzi a felhasználó azonosítóját, a gépének nevét és a kinyomtatott oldalakat. Ezután minden hónapban, félévben, évben vagy akár tetszõleges idõközönként összegyûjtjük a nyomtatók nyilvántartásait és külön feljegyezzük az egyes felhasználók nyomtatásait, majd benyújtjuk róla a számlát. Töröljük az összes naplóállományt, és tiszta lappal kezdjük a következõ idõszakot. Az azonnali elszámolás már nem annyira népszerû, mivel nehezebb megvalósítani. Ekkor a felhasználók már közvetlenül a nyomtatás után megkapják a számlát, hasonlóan a lemezkvótákhoz. Meg tudjuk akadályozni ezzel azt is, hogy a felhasználók túlléphessék az elõre kiszabott nyomtatási kvótájukat, amit persze menet közben lehet ellenõrizni és állítgatni. A felhasználók és kvótájuk nyomonkövetéséhez viszont szükségünk lesz egy kis adatbáziskezelésre is. Az LPD nyomtatási rendszer mind a két módszer kivitelezéséhez tud segítséget nyújtani, hiszen amikor szûrõket állítunk be (vagyis szinte mindig), lehetõségünk van a nyilvántartást végzõ programrészleteket is beilleszteni. És ami feltétlenül elõnyös: óriási mértékû rugalmasságot ajánl fel a nyilvántartás megvalósításához. Például magunk választhatjuk ki, hogy idõszakos vagy azonnali elszámolást alkalmazunk. Meg tudjuk adni, milyen információkat rögzítsünk: felhasználói neveket, számítógépek neveit, a munkák típusát, vagy a kinyomtatott oldalakat, a felhasznált lapok területét, a nyomtatások idõbeli igényeit és így tovább. Ehhez mindössze csak a szûrõket kell módosítani. Nyilvántartás gyorsan és egyszerûen A &os;-ben egybõl találunk is két programot, amivel pillanatok alatt ki tudunk alakítani egy egyszerû idõszakos elszámolási rendszert. Ezek Az lpf szövegszûrõ címû szakaszban ismertetett lpf és a nyomtatók nyilvántartásait tartalmazó állományok adatainak összegyûjtését és kiértékelését végzõ &man.pac.8;. Ahogy korábban már leírtuk a szûrõkrõl szóló szakaszban (Szûrõk), az LPD a szöveg- és konverziós szûrõket parancssorból a nyilvántartást tároló állomány nevével indítja el. Ezt a paramétert a szûrõk aztán fel tudják használni a nyilvántartások feljegyzéséhez. Az állomány nevét az /etc/printcap állományban szereplõ af tulajdonsággal tudjuk megadni, vagy teljes elérési úttal, vagy pedig a nyomtatási könyvtárhoz viszonyítva. Az LPD az lpf szûrõt a lap szélességének és hosszának megadásával indítja el (ezeket az értékeket a pw és pl tulajdonságokból származtatja). Az lpf ezek felhasználásával meg tudja mondani, mennyi papírt használtunk el. Miután kiküldte az állományt a nyomtatóra, nyilvántartásba is veszi. Ezek a típusú bejegyzések valahogy így néznek ki: 2.00 rose:andy 3.00 rose:kelly 3.00 orchid:mary 5.00 orchid:mary 2.00 orchid:zhang Minden nyomtatóhoz érdemes külön nyilvántartást vezetni, mivel az lpf nem tartalmaz semmilyen beépített zárolási megoldást, ezért két lpf párhuzamos futtatása könnyen összezagyválhatja a közösen használt nyilvántartások tartalmát. Az /etc/printcap állományban az af=acct tulajdonság megadásával könnyen létre tudunk hozni minden nyomtatóhoz külön nyilvántartást. Ilyenkor minden nyomtató könyvtárában megjelenik egy acct nevû állomány. Amikor elérkezünk a nyomtatások kiszámlázásához, futtassuk le a &man.pac.8; programot. Ehhez mindössze annyit kell tennünk, hogy átlépünk az elszámolni kívánt nyomtató könyvtárába és begépeljük a pac parancsot. Ekkor kapunk egy ehhez hasonló, dollár alapú kimutatást: Login pages/feet runs price orchid:kelly 5.00 1 $ 0.10 orchid:mary 31.00 3 $ 0.62 orchid:zhang 9.00 1 $ 0.18 rose:andy 2.00 1 $ 0.04 rose:kelly 177.00 104 $ 3.54 rose:mary 87.00 32 $ 1.74 rose:root 26.00 12 $ 0.52 total 337.00 154 $ 6.74 A &man.pac.8; a következõ paramétereket várja: Az kiértékelendõ nyomtató neve. Ez a paraméter csak akkor használható, ha az /etc/printcap állományban az af tulajdonságnak teljes elérési utat adtunk meg. A felhasználók nevei helyett a fizetendõ összeg szerint rendezze a listát. Hagyja figyelmen kívül a nyilvántartásban szereplõ gépek hálózati neveit. Ennek hatására az alpha géprõl nyomtató smith meg fog egyezni a gamma géprõl nyomtatóval. A beállítás nélkül ez a két felhasználó el fog térni. A paraméterként megadott ár dollár értékkel számol oldalanként vagy lábanként az /etc/printcap állományban megadott pc tulajdonság értéke helyett (ami alapból két cent). Az ár lebegõpontos (valós) számként is megadható. A rendezési sorrend megfordítása. Hozzon létre egy elszámolást, majd törölje a hozzá kapcsolódó nyilvántartási adatokat. név … Csak az adott nevû felhasználók adatait értékelje ki. A &man.pac.8; által alapértelmezés szerint generált kimutatásban láthatjuk az egyes gépekrõl származó egyes felhasználók kinyomtatott oldalait. Ha nekünk viszont nem számít, hogy honnan küldték a kéréseket (mivel bárhonnan lehet küldeni), akkor a pac paranccsal az alábbi táblázatot készítetthetjük el: Login pages/feet runs price andy 2.00 1 $ 0.04 kelly 182.00 105 $ 3.64 mary 118.00 35 $ 2.36 root 26.00 12 $ 0.52 zhang 9.00 1 $ 0.18 total 337.00 154 $ 6.74 Itt megtaláljuk a ténylegesen kifizetendõ összegeket is, amik kiszámításához a &man.pac.8; az /etc/printcap állomány pc tulajdonságát használja (ez alapból 200, avagy 2 cent oldalanként). Ezzel a tulajdonsággal tehát egy cent századrészében mérve tudjuk megadni az oldalakénti vagy lábankénti árakat. Ezt a beállítást természetesen a &man.pac.8; opciójával felül tudjuk bírálni. Arra azonban vigyázzunk, hogy a után dollárban kell megadnunk az árat. Emiatt tehát a &prompt.root; pac parancs szerint minden egyes oldal másfél dollárba fog kerülni. Ezzel az opcióval aztán alaposan megdönthetjük az árakat. Végezetül megemlítjük, hogy a pac parancs az általa létrehozott elszámolást egy külön állományba menti, amelynek a neve nagyjából megegyezik a nyilvántartást végzõével, de _sum-ra (mint summary, azaz elszámolás) végzõdik. Ezután nullázza a nyilvántartást. Amikor a &man.pac.8; programot újra lefuttatjuk, újból beolvassa a korábban elmentett elszámolásokat, majd hozzászámolja a többit a hagyományos nyilvántartási adatokból. Hogyan tudjuk számolni a kinyomtatott lapokat? A nyilvántartás pontos vezetéséhez még távolról is valamilyen módon meg kell tudnunk mondani, hogy mennyi lapot használt egy nyomtatási munka végrehajtása. Ez a nyomtatás nyilvántartásának egyik alapvetõ problémája. A nyers szövegek esetében ez nem is annyira bonyolult: egyszerûen számoljuk össze, hogy a munkában mennyi sor kinyomtatására lesz szükség és vessük össze ezt a nyomtató által lapoként kinyomtatott sorok számálva. Ne felejtsük el számításba venni a szövegben felbukkanó törlések hatását, vagy az olyan hosszú sorokat, amelyek a valóságban több sorban fognak megjelenni. Viszont (Az lpf szövegszûrõ címû szakaszban bemutatott) lpf program ezeket mind lekezeli a nyilvántartások készítése során. Ezért ha szintén egy nyilvántartást vezetni képes szövegszûrõt akarunk írni, akkor mindenképpen érdemes megnéznünk az lpf forráskódját. De hogyan bánjunk el a többi formátummal? Nos, a DVI-Laserjet és DVI-&postscript; közti átalakítások esetén a kinyomtatott lapok számának megállapításához meg kell tanítanunk a szûrõnket értelmezni a dvilj vagy dvips parancsok kimenetét. Ugyanezt meg tudjuk tenni más formátumok és más konverziós programok használata során is. Azonban ezek a módszerek nem veszik számításba, hogy a nyomtató egyáltalán ki is nyomtatta-e az összes elküldött oldalt. Sok minden történhet még addig, például beragadhat a papír, kifogyhat a tinta vagy akár felrobbanhat a nyomtató — a felhasználónak ettõl függetlenül még fizetnie kell. Mit lehet ilyenkor tenni? A precíz nyilvántartásnak csak egyetlen biztos módja létezik. Olyan nyomtatót szerezzünk be, amely képes megmondani, mennyi lapot használt el a nyomtatás során, majd egy ilyet csatlakoztassunk soros porton vagy hálózaton keresztül. Szinte majdnem az összes &postscript; nyomtató támogatja ezt a lehetõséget, ahogy sok más gyártmány és típus is (például a hálózati Imagen lézernyomtatók). A nyomtatóhoz tartozó szûrõt ehhez úgy kell módosítani, hogy lekérdezzük a kinyomtatott lapok számát a nyomtatás után és kizárólag erre az értékre alapozva készítünk nyilvántartást. Itt nincs szükség sem a sorok számolására, sem pedig az állományok (könnyen elhibázható) átvizsgálására. Természetesen lehetünk nagylelkûek és ne számítsunk fel semmit a nyomtatásért. A nyomtatók használata nyomtató használat Ebbõl a szakaszból megtudhatjuk, hogyan használjuk a &os;-n beállított nyomtatónkat. Röviden most itt foglaljuk össze az ide tartozó felhasználói parancsokat: &man.lpr.1; Munkákat nyomtat ki. &man.lpq.1; Ellenõrzi a nyomtatási sorokat. &man.lprm.1; Munkákat vesz ki a nyomtatási sorokból. Ezek mellett létezik még a nyomtatók és a hozzájuk tartozó sorok irányítására alkalmas parancs is, az &man.lpc.8;, amelyre a A nyomtatók vezérlése címû szakaszban fogunk részleteiben kitérni. A nyomtatók/sorok /etc/printcap állományban szereplõ nevük szerinti megadásához az &man.lpr.1;, &man.lprm.1; és &man.lpq.1; parancsok közül mindegyik elfogadja a paramétert. Ennek köszönhetõen képesek vagyunk munkákat küldeni, eltávolítani vagy felügyelni az egyes nyomtatók soraiban. Ha nem használjuk a kapcsolót, akkor az érintett nyomtató a PRINTER környezeti változó által meghatározott lesz. Végül, ha a PRINTER nevû környezeti változót sem állítottuk be, akkor a parancsok alapértelmezett módon az lp nevû nyomtatót fogják használni. A továbbiakban az alapértelmezett nyomtató kifejezés a PRINTER környezeti változó által megnevezett nyomtatóra fog utalni, illetve ha ezt nem definiáltuk, akkor az lp nevû nyomtatóra. Munkák nyomtatása Az állományok kinyomtatásához írjuk be: &prompt.user; lpr állománynév ... nyomtatás Ezzel kinyomtatjuk az összes felsorolt állományt az alapértelmezett nyomtatón. Ha nem adunk meg állományokat, akkor az &man.lpr.1; parancs a szabványos bemenetrõl várja a nyomtatandó adatokat. Például ezzel a paranccsal néhány igen fontos rendszerállományt tudunk kinyomtatni: &prompt.user; lpr /etc/host.conf /etc/hosts.equiv A nyomtató megválasztásához így adjuk ki a parancsot: &prompt.user; lpr nyomtatónév állománynév ... Ez a példa kinyomtatja az aktuális könyvtár részletes listáját a rattan nevû nyomtatón: &prompt.user; ls | lpr rattan Mivel egyetlen állományt sem adtunk meg az &man.lpr.1; programnak, az lpr parancs a nyomtatandó adatokat a szabványos bemenetrõl várja, ami jelen esetünkben a ls parancs kimenete. Az &man.lpr.1; ezeken felül még képes értelmezni rengeteg formázásra, konverzióra, másolatok készítésére stb. utasító kapcsolót is. Errõl bõvebben a Nyomtatási beállítások címû szakaszban lesz szó. Munkák felügyelete nyomtatási munkák Amikor az &man.lpr.1; programmal nyomtatunk, az összes nyomtatandónk egy nyomtatási munkának nevezett csomagba kerül, ami pedig az LPD nyomtatási rendszerébe. Minden nyomtatóhoz tartozik egy nyomtatási sor, ahol részünkrõl és mások által eddig kiadott munkákat találhatjuk. A nyomtató ezután ezeket a munkákat érkezési sorrend szerint dolgozza fel. Az alapértelmezett nyomtatóhoz tartozó sor állapotát az &man.lpq.1; programmal tudjuk megnézni. Ha egy adott nyomtatóra vagyunk kíváncsiak, akkor használjuk a kapcsolót. Például a &prompt.user; lpq bamboo parancs a bamboo nevû nyomtató sorát fogja megmutatni. Példaképpen lássuk is ilyen esetben az lpq parancs eredményét: bamboo is ready and printing Rank Owner Job Files Total Size active kelly 9 /etc/host.conf, /etc/hosts.equiv 88 bytes 2nd kelly 10 (standard input) 1635 bytes 3rd mary 11 ... 78519 bytes Itt három munkát láthatunk a bamboo nyomtatási sorában. Az elsõ munka, amit a kelly nevû felhasználó küldött, a 9-es munkaszámot kapta. A nyomtatóhoz tartozó összes munka kap egy ilyen egyedi számot. Többnyire nyugodtan figyelmen kívül hagyhatjuk, azonban szükségünk lehet rá, ha éppen törölni kívánjuk a hozzátartozó munkát. Ezzel majd a Munkák eltávolítása címû szakaszban foglalkozunk. A kilences számú munka két állományt tartalmaz: ha a parancssorban több állományt adunk meg az &man.lpr.1; programnak, akkor az egy munkának számít. Ez egyben a pillanatnyilag aktív munka (ezt a Rank oszlopban szereplõ active érték jelzi), tehát a nyomtató éppen ezzel foglalatoskodik. A második munka közvetlenül az &man.lpr.1; szabványos bemenetére érkezett. A harmadik a mary nevû felhasználótól jött, és ez egy nagyobbacska munka. A nyomtatandó állomány elérési útvonala túlságosan hosszú ahhoz, hogy ki lehessen írni, ezért az &man.lpr.1; csak három pontot jelez ki helyette. Az &man.lpq.1; kimenetének elsõ sorai is nagyon hasznos információt tartalmaz: megtudhatjuk, mit csinál éppen (legalább is az LPD szerint) a nyomtató. A kapcsolóval az &man.lpq.1; parancstól kérhetünk sokkal részletesebb listázást is. Például így nézhet ki a lpq parancs eredménye: waiting for bamboo to become ready (offline ?) kelly: 1st [job 009rose] /etc/host.conf 73 bytes /etc/hosts.equiv 15 bytes kelly: 2nd [job 010rose] (standard input) 1635 bytes mary: 3rd [job 011rose] /home/orchid/mary/research/venus/alpha-regio/mapping 78519 bytes Munkák eltávolítása Ha meggondoltuk volna magunkat egy munka kinyomtatásáról, az &man.lprm.1; paranccsal még törölni tudjuk a sorból. Az &man.lprm.1; gyakran még a nyomtatás alatt álló munkát is képes eltávolítani, azonban elõfordulhat, hogy a munka egy része már nyomtatásra került. Az alapértelmezett nyomtató sorából csak úgy tudunk munkákat törölni, ha elõször az &man.lpq.1; segítségével megkeressük a számukat. Ha ez megvan, írjuk be: &prompt.user; lprm munkaszám Adott nyomtatóról a kapcsoló segítségével tudunk munkákat törölni. A most következõ parancs a bamboo nevû nyomtatóról törli a 10-es számú munkát: &prompt.user; lprm bamboo 10 Az &man.lprm.1; parancs esetén még használhatóak az alábbi rövidítések is: lprm - Eltávolítja a hozzánk tartozó az összes munkát (az alapértelmezett nyomtatón). lprm felhasználó Eltávolítja az adott felhasználóhoz tartozó összes munkát (az alapértelmezett nyomtatón). Kizárólag a rendszergazdák képesek erre, a rendes felhasználók csak a saját munkáikat törölhetik. lprm A munka száma, a felhasználói név vagy a megadása nélkül az &man.lprm.1; törli az alapértelmezett nyomtatón éppen aktív munkát, amennyiben az a miénk. Csak a rendszergazdák képesek bármilyen aktív munkát törölni. Ha kiegészítjük az imént említett rövidítéséket a paraméter megadásával, akkor az alapértelmezett nyomtató helyett bármelyik másikat is használhatjuk. Például ez a parancs eltávolítja az aktuális felhasználó összes munkáját a rattan nevû nyomtatón: &prompt.user; lprm rattan - Hálózati környezetben az &man.lprm.1; csak arról a géprõl engedi törölni a munkákat, amelyrõl küldték ezeket, még abban az esetben is, amikor ugyanaz a nyomtató más számítógépekrõl is elérhetõ. A következõ parancssorozat ezt igyekszik szemléltetni: &prompt.user; lpr rattan myfile &prompt.user; rlogin orchid &prompt.user; lpq rattan Rank Owner Job Files Total Size active seeyan 12 ... 49123 bytes 2nd kelly 13 myfile 12 bytes &prompt.user; lprm rattan 13 rose: Permission denied &prompt.user; logout &prompt.user; lprm rattan 13 dfA013rose dequeued cfA013rose dequeued Túl a nyers szövegen: nyomtatási beállítások Az &man.lpr.1; parancs számos olyan beállítást enged, amelyekkel a szövegek formázását, grafikák átalakítását illetve más állományformátumok használatát, másolatok készítését, munkák irányítását és még sok minden mást el tudunk végezni. Ebben a szakaszban pontosan ezekrõl a kapcsolókról lesz szó. Formázási és konverziós beállítások Az &man.lpr.1; most következõ opciói a munkákban található állományok formázását vezérlik. Akkor használjuk ezeket a beállításokat, ha a munka nem tartalmaz nyers szöveget, vagy ha nyers szöveget akarunk formázni az &man.pr.1; segédprogrammal. &tex; Például az alábbi parancs kinyomtat egy halászati-jelentés.dvi nevû (a &tex; betûszedû rendszerbõl már jól ismert) DVI állományt a bamboo nevû nyomtatón: &prompt.user; lpr bamboo -d halászati-jelentés.dvi Ezek a beállítások a munkában szereplõ minden egyes állományra vonatkoznak, ezért nem keverhetjük (például) a DVI és ditroff formátumú állományokat egy munkán belül. Ehelyett külön munkákban kell elküldenünk az eltérõ formátumú állományokat, és mindegyik munkához külön konverziós beállításokat kell megadnunk. A és kapcsolók kivételével az itt felsorolt összes beállításnak a kiválasztott nyomtatóhoz szüksége van a megfelelõ konverziós szûrõre. Például a opció használatához kell egy konverziós szûrõ a DVI formátumhoz. A Konverziós szûrõk címû szakasz errõl ad bõvebb tájékoztatást. Cifplot állományok nyomtatása. DVI állományok nyomtatása. FORTRAN forrás nyomtatása. Plot formátumú adatok nyomtatása. A kinyomtatott szöveg behúzásának növelése a szám értékével. Ha nem adjuk meg a számot, akkor ennek értéke 8 lesz. Ez a beállítás csak bizonyos konverziós szûrõkkel mûködik. Ne hagyjunk helyet az és a szám között. A szöveg formázás nélküli nyomtatása, vezérlõkarakterekkel együtt. Ditroff (eszközfüggetlen troff) adat nyomtatása. -p Nyomtatás elõtt a szöveg formázása a &man.pr.1; programmal. Lásd &man.pr.1;. Az állomány neve helyett a fejlécben a címet jeleníti meg a &man.pr.1;. Ennek a beállításnak csak a opcióval együtt van hatása. Troff adat nyomtatása. Raszteres adatok nyomtatása. Vegyünk az iméntiekre egy példát. A következõ parancs az &man.ls.1; szépen megformázott man oldalát nyomtatja ki az alapértelmezett nyomtatón: &prompt.user; zcat /usr/share/man/man1/ls.1.gz | troff -man | lpr A &man.zcat.1; kitömöríti az &man.ls.1; man oldalának forrását és átadja a &man.troff.1; parancsnak, ami ebbõl létrehoz a GNU troff formátumának megfelelõ kimenetet és továbbadja az &man.lpr.1; parancsnak, ami végül elküldi a munkát az LPD nyomtatási rendszernek. Mivel az &man.lpr.1; parancsnak megadtuk az kapcsolót, a nyomtatási rendszer a GNU troff formátumban érkezõ adatokat magától át fogja alakítani olyan formátumra, amit a nyomtató is képes lesz megérteni. Munkák kezelése Az &man.lpr.1; most felsorolandó beállításaival az LPD rendszert arra tudjuk utasítani, hogy a munkát különleges módon kezelje: -# példányszám Egyetlen példány helyett hozzon létre példányszám számú példányt a munkában található összes állományból. A rendszergazda a nyomtató kímélése érdekében ezt a lehetõséget letilthatja, amivel inkább a fénymásoló használatára ösztönzi a felhasználókat. Lásd A másolatok számának szabályozása szakasz. A beállítás illusztrálásaként most az alapértelmezett nyomtatón elõször nyomtassuk ki három példányt a parser.c, majd ezután a parser.h állományokból: &prompt.user; lpr parser.c parser.h -m A rendszer küldjön levelet a munka teljesítése után. Ekkor az LPD a munka elvégzése után levelet küld a helyi postafiókunkba. A levélben kifejti, hogy sikeres volt-e a nyomtatás, vagy esetleg valamilyen hiba keletkezett, és ha hiba történt, akkor pontosan mi is volt az. -s Ne másolja közvetlenül az állományokat a nyomtatási könyvtárba, hanem készítsen hozzájuk szimbolikus linkeket. Egy nagyobb munka nyomtatása esetén javasolt használni ezt a kapcsolót. Ezzel a megoldással helyet tudunk spórolni a nyomtatási könyvtárban (amikor a munkánk könnyen megtelítheti a nyomtatási könyvtárat tároló állományrendszert). Emellett idõt is takarítunk meg, mivel az LPD-nek nem kell a munka minden egyes bitjét átmásolni a nyomtatási könyvtárba. Van azonban egy hátránya: mivel az LPD ekkor közvetlenül az eredeti állományra fog hivatkozni, ezért a nyomtatás befejezéséig azt nem módosíthatjuk vagy törölhetjük. Ha egy távoli nyomtatónak küldjük a munkát, akkor az LPD a helyi és a távoli számítógép között mégis kénytelen lesz átmásolni a munkát, így a kapcsoló egyedül csak a helyi nyomtatási könyvtárban fog helyet spórolni. Ettõl eltekintve még ilyenkor is hasznunkra válhat. -r Törölje a munkában szereplõ állományokat, miután átmásolta ezeket a nyomtatási könyvtárba, vagy miután a kapcsoló használatával kinyomtatta ezeket. Nagy körültekintéssel használjuk! A fejléclapok beállításai Az &man.lpr.1; most következõ beállításai a munkák fejlécében megjelenõ szövegekre vannak hatással. Így ha letiltottuk a fejléclapok használatát, akkor ezek a kapcsolók lényegében semmit sem állítanak. A Fejléclapok címû szakaszból tudhatunk meg többet ezek beállításáról. -C szöveg A fejléclapon megjelenõ hálózati név helyett a szöveg fog szerepelni. A hálózati név általában annak a gépnek a neve, ahonnan a munkát küldték. -J szöveg A fejléclapon megjelenõ munka neve helyett a szöveg fog megjelenni. A munka neve általában a benne szereplõ elsõ állomány nevével egyezik meg, ha a szabványos bemenetrõl nyomtatunk, akkor egyszerûen csak stdin. -h Ne nyomtasson fejléclapot. Bizonyos helyeken elõfordulhat, hogy ennek a kapcsolónak nincs semmilyen hatása a fejléclapok létrehozásának módszerébõl fakadóan. A részleteket lásd a Fejléclapok szakaszban. A nyomtatók vezérlése A nyomtatóink rendszergazdájaként nekünk kell telepítenük, üzembe helyeznünk és kipróbálnunk ezeket. Az &man.lpc.8; parancs használatával még jobban képesek vagyunk kapcsolatba lépni velük. Az &man.lpc.8; paranccsal: el tudjuk indítani és le tudjuk állítani a nyomtatókat; be- és ki tudjuk kapcsolni a nyomtatási soraikat; át tudjuk rendezni az egyes sorokban található munkákat. Elõször is essen pár a fogalmakról: ha a nyomtató leállt, akkor semmit sem fog kinyomtatni a sorából. A felhasználók továbbra is képesek munkákat küldeni, amik azonban egészen addig fognak várakozni, amíg a nyomtatót el nem indítjuk vagy a sorát ki nem ürítjük. Ha egy sort kikapcsolunk, akkor (a root kivételével) egyetlen felhasználó sem képes munkákat küldeni a nyomtatónak. A bekapcsolt sorok képesek csak munkát fogadni. A nyomtató elindítható kikapcsolt sorral is, ilyenkor egészen addig folytatja a munkák kinyomtatását, amíg a sor ki nem ürül. Általánosan elmondható, hogy az &man.lpc.8; parancs használatához a root felhasználó jogosultságaira van szükségünk. Az &man.lpc.8; parancsot minden más esetben csak a nyomtató állapotának ellenõrzésére vagy a megakadt nyomtató újraindítására használhatjuk. Foglaljuk röviden össze az &man.lpc.8; parancsait. A legtöbb parancs kiadásához még szükséges egy nyomtatónév paraméter megadása is, amivel megnevezzük az utasítani kívánt nyomtatót. Helyette használható az all szó is, amivel az /etc/printcap állományban szereplõ összes nyomtatót egyszerre utasíthatjuk. abort nyomtatónév Az aktuális munka megszakítása és a nyomtató leállítása. Ha a nyomtatási sort még nem kapcsoltuk ki, a felhasználók küldhetnek további munkákat. clean nyomtatónév A nyomtató könyvtárából töröljük a régi állományokat. Esetenként adódhat, hogy bizonyos munkák állományait nem takarította el az LPD, különösen abban az esetben, amikor a nyomtatás vagy az adminisztrálás során keletkezett valamilyen hiba. Ez a parancs segít megtalálni a nyomtatási könyvtárból már kikopott állományokat és törli ezeket. disable nyomtatónév Az újonnan érkezõ munkák besorolásának kikapcsolása. Ha a nyomtató még mûködik, akkor folytatni fogja a sorban még bennmaradt munkák nyomtatását. A rendszergazda (a root) még a kikapcsolt sorok esetén is küldhet munkákat. Ez a parancs valójában akkor hasznos, ha egy új nyomtató vagy egy új szûrõ mûködését próbálgatjuk: ilyenkor érdemes kikapcsolni a nyomtatási sort és root felhasználóként munkákat küldeni. A többi felhasználó a tesztelés befejezéséig nem tud majd munkákat küldeni, vagyis egészen addig, amíg a nyomtatási sort vissza nem kapcsoljuk az enable paranccsal. down nyomtatónév üzenet A nyomtató üzemen kívül helyezése. Lényegében megegyezik egy disable és utána egy stop parancs kiadásával. Az üzenet akkor jelenik meg, amikor a valaki megpróbálja lekérdezni a nyomtató állapotát az lpc status paranccsal, vagy amikor megnézi a nyomtatási sorát az &man.lpq.1; paranccsal. enable nyomtatónév A nyomtatóhoz tartozó nyomtatási sor bekapcsolása. A felhasználók ezután már képesek lesznek a nyomtatónak munkákat küldeni, azonban egészen addig nem nyomtatódik ki semmi, amíg a nyomtató el nem indítjuk. help parancsnév Megmutatja a parancsnév parancshoz tartozó súgót. A parancsnév megadása nélkül a rendelkezésre álló parancsok listáját kapjuk meg. restart nyomtatónév Elindítja a nyomtatót. A felhasználók ezt a parancsot tudják használni abban az esetben, amikor valamilyen megmagyarázhatatlan okból az LPD mûködése megáll, viszont ezzel nem tudják elindítani a stop vagy down parancsokkal leállított nyomtatót. A restart parancs megegyezik az abort és a start egymás utáni kiadásával. start nyomtatónév Elindítja a nyomtatót, és a nyomtató nekilát kinyomtatni a sorában levõ munkákat. stop nyomtatónév Leállítja a nyomtatót, és a nyomtató az aktuális munka befejezése után már nem kezd neki újabbnak. Ettõl függetlenül a felhasználók még továbbra is képesek munkákat küldeni a nyomtatási sorába. topq nyomtatónév munka-vagy-felhasználónév Átrendezi a nyomtatónév nevû nyomtató sorát úgy, hogy a megadott azonosítójú munkát vagy a megadott felhasználónévhez tartozó munkákat a sor elejére teszi. Ennél a parancsnál nyomtatónévnek nem adhatjuk meg az all értéket. up nyomtatónév Üzembe helyezi a nyomtatót, tulajdonképpen a down parancs ellentéte. Megegyezik egy egymás után kiadott start és enable paranccsal. Az &man.lpc.8; a fenti parancsokat a parancssorból fogadja el. Ha itt nem adunk meg neki semmilyen parancsot, akkor az &man.lpc.8; interaktív módba vált, ahol ugyanezeket a parancsokat adhatjuk ki, egészen az exit, quit parancsok vagy az állományvége jelzés begépeléséig. Más nyomtatási rendszerek Ha derekasan végigolvastuk eddig ezt a fejezetet, akkor mostanra már valószínûleg mindent tudunk a &os;-ben található LPD nyomtatási rendszerrõl. Ezzel együtt tisztában vagyunk a hiányosságaival is, aminek kapcsán természetes módon felmerülhet bennünk a kérdés: Milyen más (&os;-vel is mûködni képes) nyomtatási rendszerek léteznek még? LPRng LPRng Az LPRng, aminek jelentése LPR Next Generation (Az LPR következõ generációja), a PLP teljesen újraírt változata. Patrick Powell és Justin Mason (a PLP eredeti karbantartója) együttes munkájának gyümölcse az LPRng. Az LPRng honlapja: . CUPS CUPS A CUPS, vagy más néven a Common UNIX Printing System (Közös &unix;-os nyomtatási rendszer), egy hordozható nyomtatási réteg nyújt a &unix;-alapú operációs rendszerek számára. Az Easy Software Products fejlesztése és szinte az összes &unix; gyártó és felhasználó szemében elfogadott szabványos nyomtatási rendszer. A CUPS a nyomtatási munkák és sorok kezelését az internetes nyomtatási protokollon (Internet Printing Protocol, IPP) használatával oldja meg. Csökkentett képességekkel ugyan, de a sornyomtató démon (Line Printer Daemon, LPD), szerverüzenet-blokk (Server Message Block, SMB), és AppSocket (más néven JetDirect) protokollokat is ismeri. A CUPS a komolyabb &unix;-os nyomtatási feladatokhoz ezeken felül még a hálózati nyomtatók közti választást és PostScript nyomtatók leírásán (PostScript Printer Description, PPD) alapuló nyomtatási beállításokat is támogatja. A CUPS honlapja: . HPLIP HPLIP A HPLIP, másnéven HP &linux; Imaging and Printing, egy HP által kidolgozott programcsalád, amely támogatja a HP eszközök nyomtatási, lapolvasási és faxolási lehetõségeit. A benne található programok bizonyos nyomtatási feladatokhoz backendként a CUPS nyomtatási rendszert használják. A HPLIP honlapja a címen érhetõ el. Hibakeresés Miután az &man.lptest.1; programmal elvégeztünk néhány egyszerû próbát, a várt helyett a következõk egyikét kaphatuk eredményül: Egy kis idõ után minden remekül mûködött, vagy nem dobta ki az egész lapot. A nyomtató nyomtatott egy keveset, aztán egy ideig csendben maradt és nem csinált semmit. Ilyenkor a nyomtatnivalók megjelenéséhez minden bizonnyal meg kell nyomnunk a nyomtatón levõ PRINT REMAINING vagy FORM FEED feliratú gombokat. Ebben az esetben a nyomtató valószínûleg még arra várt, hogy még a nyomtatás megkezdése elõtt érkezik valamilyen további adat. Ettõl a gondtól úgy szabadulhatunk meg, ha beállítunk egy szövegszûrõt, amely minden (szükséges) esetben küld egy FORM FEED (lapdobás) jelzést is a nyomtatónak. Ez kell általában ahhoz, hogy a szöveg a nyomtató belsõ pufferében megmaradt része azonnal kinyomtatódjon. Akkor is a javunkra válhat ez, ha minden egyes munkát külön lapon akarunk kezdeni, mivel így a következõ munka sosem közvetlenül ott kezdõdik, ahol az elõzõ munka befejezte a nyomtatást. A /usr/local/libexec/if-simple szûrõ helyett a következõ szkript használhatával tudunk minden munka után elküldeni egy lapdobást: #!/bin/sh # # if-simple - Egyszerû lpd szövegszûrõ # Helye: /usr/local/libexec/if-simple # # Egyszerûen átmásolja a szabvány bemenetet a szabvány kimenetre, # és figyelmen kívül hagyja az összes többi paramétert. # Minden nyomtatási munka után küld egy lapdobást (\f). /bin/cat && printf "\f" && exit 0 exit 2 Lépcsõsen jelentek meg a sorok. Ekkor a következõt látjuk a lapon: !"#$%&'()*+,-./01234 "#$%&'()*+,-./012345 #$%&'()*+,-./0123456 MS-DOS OS/2 ASCII Az ún. lépcsõhatás áldozatává váltunk, amelyet a sortörést jelzõ karakter eltérõ értelmezései okoznak. A &unix; stílusú operációs rendszerek erre mindössze egyetlen karaktert használnak: ez a 10-es kódú ASCII karakter (sordobás, Line Feed, LF). Az &ms-dos;, &os2; és mások pedig két karakterrel oldják meg ezt a feladatot: a 10-es és 13-as kódú (kocsivissza, Carriage Return, CR) ASCII karakterekkel. A sortöréseknél sok nyomtató az &ms-dos; szokásait követi. Amikor a &os;-vel nyomtatunk, akkor csak egyetlen karaktert használunk sortörésre. Ennek láttán a nyomtató lépteti a sort, azonban a fej vízszintes pozícióját nem változtatja meg a következõ sor nyomtatásának megkezdésekor. Erre lenne a kocsivissza karakter, vagyis ennek hatására fogja a nyomtató a papír bal oldalára visszaállítani a következõ nyomtatandó karakter pozícióját. A &os; így szeretné utasítani a nyomtatót: A nyomtató kocsivisszát kap A nyomtató visszalépteti a pozíciót A nyomtató sordobást kap A nyomtató új sort kezd Néhány módszer ennek kiváltására: A nyomtatón található kapcsolók vagy vezérlõpanel segítségével próbáljuk meg átállítani a vezérlõkarakterek nyomtató szerinti értelmezését. Keressük meg a nyomtató kézikönyvében, hogyan tudjuk ezt megcsinálni. Ha a &os; mellett más operációs rendszerekkel is használni akarjuk a nyomtatót, akkor azok indítása elõtt mindig át kell állítani a nyomtatót a megfelelõ értelmezés alkalmazására. Ilyenkor valószínûleg a lentebb szereplõ megoldásokat részesítjük majd inkább elõnyben. Állítsuk be úgy a &os; soros vonali meghajtóját, hogy magától alakítsa át az LF karaktereket CR+LF párokká. Természetesen ez a megoldás csak a soros portra csatlakozó nyomtatók esetében mûködhet. Ehhez az /etc/printcap állományban a nyomtató leírásánál az ms# tulajdonságnál adjuk meg az onlcr módot. Küldjünk olyan kódot a nyomtatónak, amelynek hatására ideiglenesen máshogy fogja kezelni az LF karaktereket. Nézzük meg a nyomtatóhoz mellékelt útmutatóban, hogy milyen kódokat tudunk ilyen célra használni. Ha találtunk ilyen kódot, akkor írjuk át úgy a hozzátartozó szövegszûrõt, hogy a munkák elõtt mindig elküldjük azt. PCL Most bemutatjuk egy olyan szövegszûrõ kódját, amely a Hewlett-Packard PCL kódjait ismerõ nyomtatókhoz készült. Ebben a szûrõben elõször kiadjuk, hogy az LF karaktereket LF és CR karakterek kombinációjának tekintse a nyomtató, majd elküldjük magát a munkát, és a munka utolsó lapja után pedig elküldünk egy lapdobást. Szinte az összes Hewlett Packard nyomtatóval mûködnie kell. #!/bin/sh # # hpif - Egyszerû lpd bemeneti szûrõ a HP-PCL alapú nyomtatókhoz # Helye: /usr/local/libexec/hpif # # Egyszerûen átmásolja a szabvány kimenetet a szabvány bemenetre, és # figyelmen kívül hagyja a paramétereket. Elküldi a nyomtatónak, hogy # az LF karaktereket CR+LF-ként kezelje, majd a feladat befejeztével # lapot dobat. printf "\033&k2G" && cat && printf "\033&l0H" && exit 0 exit 2 Példaként megadjuk még az orchid nevû számítógép /etc/printcap állományát is. Ebben egyetlen nyomtató csatlakozik a párhuzamos portra, amelynek a típusa LaserJet 3Si és a neve teak. Az elõbb bemutatott szövegszûrõt használja: # # /etc/printcap (orchid) # teak|hp|laserjet|Hewlett Packard LaserJet 3Si:\ :lp=/dev/lpt0:sh:sd=/var/spool/lpd/teak:mx#0:\ :if=/usr/local/libexec/hpif: Egymásra írja a sorokat. A nyomtató nem lépteti a sorokat, ezért az összes sor egymáson jelenik meg. Ez pontosan a ritka ellentéte a fentebb leírt lépcsõhatásnak. A &os; által sortörésre használt LF karakterek valamiért CR karakterekként viselkednek, ezért a nyomtató nem sort vált, hanem a lap bal szélére állítja a fejet. A nyomtatón található kapcsolókkal vagy vezérlõpanellel így állítsuk be az sordobás és kocsivissza karakterek értelmezését: Amit a nyomtató kap Arra a nyomtató nyomtat CR CR LF CR + LF A nyomtató elhagy karaktereket. Miközben nyomtatunk, a nyomtató bizonyos karaktereket nem hajlandó megjeleníteni. A probléma ennél nagyobb, ha a nyomtató mûködése közben egyre több és több karaktert hagy ki. Itt az a gond, hogy a nyomtató nem képes tartani az iramot a számítógép által a soros vonalon átküldött adatok sebességével (ez a probléma nem jelentkezhet a párhuzamos nyomtatók esetén). Két módon kerekedhetünk felül ezen: Ha a nyomtató ismeri a XON/XOFF típusú forgalomirányítást, akkor az ms# tulajdonságnál adjuk meg a &os; számára az ixon beállítást. Ha a nyomtató ismeri a Request to Send / Clear to Send alapú hardveres kézfogást (más néven RTS/CTS forgalomirányítást), akkor az ms# tulajdonságnál a crtscts beállítást adjuk meg. Gondoskodjunk róla, hogy a számítógépet és a nyomtató összekötõ kábel meg tudjon majd bírkózni ezzel a típusú forgalomirányítással. Mindenféle szemetet nyomtat. A nyomtató nem a nyomtatni kívánt szöveget hozza létre, hanem össze-vissza nyomtat. Ez a soros nyomtatók helytelen kommunikációs beállításának egy másik jellemzõ tünete. Ellenõrizzük a br tulajdonságnál megadott adatátviteli sebességet és az ms# tulajdonságnál megadott paritási beállításokat. Egyeztessük a nyomtató saját és az /etc/printcap állományban tárolt beállításait. Semmi sem történik. Ha semmi sem történt, akkor a gond magával a &os;-vel lehet, nem pedig a hardverrel. Az /etc/printcap állományba a vizsgálni kívánt nyomtató leírásához (az lf tulajdonsággal) illesszünk be naplózást. Például így fog kinézni a rattan nevû nyomtató bejegyzése az lf tulajdonság megadásával kibõvítve: rattan|line|diablo|lp|Diablo 630 Line Printer:\ :sh:sd=/var/spool/lpd/rattan:\ :lp=/dev/lpt0:\ :if=/usr/local/libexec/if-simple:\ :lf=/var/log/rattan.log Miután ezt megcsináltuk, próbálkozzunk újra. Nézzük meg a naplóállományban (ami a példánkban a /var/log/rattan.log nevén érhetõ el), hogy látunk-e valamilyen hibaüzenetet. Az itt tapasztalt hibaüzenetek nyomán elindulva igyekezzünk megszüntetni a probléma forrását. Ha nem adjuk meg az lf tulajdonságot, akkor az LPD erre a célra alapértelmezés szerint a /dev/console állományt használja.