diff --git a/hu_HU.ISO8859-2/books/handbook/printing/chapter.sgml b/hu_HU.ISO8859-2/books/handbook/printing/chapter.sgml index bd38eb4483..bad74e4cf7 100644 --- a/hu_HU.ISO8859-2/books/handbook/printing/chapter.sgml +++ b/hu_HU.ISO8859-2/books/handbook/printing/chapter.sgml @@ -1,6950 +1,6980 @@ Sean Kelly Írta: Jim Mock Átdolgozta és frissítette: Nyomtatás Áttekintés LPD nyomtatási rendszer nyomtatás A &os; a nyomtatók széles skálájával képes 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ásainkkal 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 + nyomtatási informá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ási - korlátozásokat, például a nyomtatási - munkák méretét, amivel egyes - felhasználók nyomtatását + korlátozásokat, például a + nyomtatási feladatok 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 a Kezdeti - beállítások címû + 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 + feladatok Lehetõvé teszi az átküldött állományok kinyomtatását, - amelyeket munkáknak + amelyeket nyomtatási feladatoknak 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üldi a munkákat egy másik - számítógép + átküldi a nyomtatási feladatokat egy + másik számítógép LPD sorába. - A nyomtatandó munkák + A nyomtatási feladatok 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, amíg az adat átmásolódik a nyomtatóra. &tex; Az LPD tetszõlegesen - tudja alakítani a nyomtatási munkákat: + tudja alakítani a nyomtatási feladatokat: 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 annak 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 + nyomtatóbeállítás szakaszban bemutatjuk, hogyan nyomtassunk ki különféle speciális állományokat, hogyan készíttessünk fejléceket, hogyan nyomtassunk 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û + 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û + 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 + linkend="printing-advanced-network-net-if">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 legnehezebb 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 nyomtattunk is vele, akkor rögtön ugorhatunk is a Szoftveres - beállításokat tartalmazó + linkend="printing-software">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 tintapatronokban levõ tinta mennyiségét. A második esetben a nyomtató ismeri a &postscript; nyelvet. - A &postscript; nyelvû munkák + A &postscript; nyelvû nyomtatási feladatok valójában a nyomtatónak küldött programok. Használatukhoz még papírra sincs feltétlenül szükség, és elõfordulhat, 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õ, 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, amely leginkább a null-modem kábelekhez hasonlít, 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 a nyomtató által használt portra. Ehhez A rendszermag - beállítása szakaszban + beállítása szakaszban olvashatjuk el, 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 + linkend="printing-testing">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 az 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, amelyben 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 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ódszert 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 az &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 a 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 a 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 + linkend="printing-naming">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 + linkend="printing-no-header-pages">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 + linkend="printing-spooldir">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û + 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 + linkend="printing-commparam">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 + linkend="printing-textfilter">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 + 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õl a Szöveges - nyomtatási feladatok &postscript; - nyomtatókon címû fejezetben + formájában érkezõ nyomtatási + feladatok 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õl 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 kezdjük felsorolni, mindegyik álnevet egy függõleges vonallal válasszunk el, és az utolsó után tegyünk pontosvesszõt. A most következõ példában egy olyan vázt mutatunk be az /etc/printcap állományhoz, amelyben 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. + betûkkel tartalmazza a nyomtatási feladatot + 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 (úgymint 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 bal szélsõ oszlopban kezdõdik, 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 + feladatok 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é). + rendszer végre szeretne hajtani egy nyomtatási + feladatot, 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özt fogja használni, ha nem adjuk meg az lp tulajdonságot az /etc/printcap állományban. A /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. + linkend="printing-textfilter">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ítsuk most 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 + nyomtatási feladatok eszközre 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 + szabványos bemenetére elküldi az + elvégzendõ nyomtatási feladatot, + é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 + linkend="printing-advanced-filters">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 + szkript, ami a nyomtatóra a nyomtatási + feladatot 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û + 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 + 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 + linkend="printing-troubleshooting">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 megbirkó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) + 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 tabulálá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? + 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 + linkend="printing-advanced-if-conversion"> 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 + linkend="printing-advanced-ps">&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 + 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), + linkend="printing-advanced-header-pages">Fejléclapok), akkor ezt a szakaszt nyugodtan kihagyhatjuk. Az lpf - szövegszûrõ szakaszban + szövegszûrõ szakaszban bemutatásra kerül a &os;-ben alapból megtalálható lpf szûrõ, amely egy sornyomtatókná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 + nyomtatási feladatok 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 + nyomtatási feladatok 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 + ö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 + akkor jelenik meg, ha egy nyomtatási feladatot 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 + nyomtatási feladat é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 + linkend="printing-advanced-convfilters">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 + 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 + feladatok 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 + tartalmazó nyomtatási feladatot 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 nyomtatási feladat 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 nyomtatási + feladatot 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 + megmondani az érkezõ nyomtatási feladat + 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 + nyomtatási feladat, 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 + linkend="printing-simple">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 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û + linkend="printing-lpr-options-format">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 + linkend="printing-textfilter">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 + ahova a nyomtatási feladatot 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õ életrekelté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 + azonban ezt a feladata 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. +# az LPD-nek, hogy ne hajtsa végre újra a nyomtatási feladatot. # 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. +# Ha a felhasználó eltávolítja a nyomtatási feladatot 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ásokat, 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 + semmilyen segítséget a nyomtatási feladaton 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 + nyomtatási feladatban 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. + linkend="printing-textfilter">A szövegszûrõ + telepítése szakaszt. Tová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 + linkend="printing-advanced-header-pages">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 + nyomtatási feladatot a kimeneti szûrõnek. + Ahogy már korábban is említettük, a + kimeneti szûrõ a nyomtatási feladatban + 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 + szûrõ), amely képes (az lpr + paranccsal hozzáadott + nyomtatási feladatokat) 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. + nyomtatási feladatokban) a + vezérlõkaraktereket figyelemen kívül + hagyni, a nyomtatási feladatban 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. + által küldött nyomtatási feladat. 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 + munka- vagy elválasztó lapok - segítik elõ a kinyomtatott munkák - azonosítását. A többi + segítik elõ az elvégzett nyomtatási + feladatok azonosítását. A többi dokumentumtól eltérõ 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 a - munkákban levõ állományokhoz - egyenként, ezért nem is akkora pazarlás - ez.) + elküldött nyomtatási feladataik + eredményét. Természetesen a + fejléclapok nyilvánvaló + hátulütõje, hogy így minden + nyomtatási feladathoz 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 + nyomtatási feladatonként jönnek létre, + nem pedig a nyomtatási feladatokban 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. + linkend="printing-advanced-header-pages-ps">Fejléclapok + &postscript; nyomtatókon szakaszt. A fejléclapok engedélyezése Az Alacsonyszintû - nyomtatóbeállítás + 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össze 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 + linkend="printing-advanced-of">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 + nyomtatón akarnak nyomtatni, minden nyomtatási + feladathoz 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, - a 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 + a gépet és a nyomtatási feladatot + 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 küldte az outline elnevezésû - munkát): + nyomtatási feladatot): 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. + maga a nyomtatási feladat eredménye 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. + fejléclapot, majd a nyomtatási feladatot + végzi el. 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 + eggyel a nyomtatási feladatban, 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û + linkend="printing-lpd-alternatives">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 + nyomtatási feladathoz 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õnek az adatok 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üldik a nyomtatási feladataikat. 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: + gép és a nyomtatási feladat + 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. +% felhasználó nyomtatási feladatának végrehajtásá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: + létrehoz egy fejléclapot, majd elvégzi a + felhasználó nyomtatási feladatá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). + linkend="printing-advanced-filters">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 + hiszen a szûrõk minden nyomtatási feladathoz 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 + linkend="printing-advanced-header-pages-accounting">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 + nyomtatási feladatot küldeni. A hálózati nyomtatás kifejezés általánosságban véve két különbözõ dologra 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. + linkend="printing-advanced-network-rm">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 + képes nyomtatási feladatokat 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 + 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 + nyomtatási feladatok + 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 + számítógépekre nyomtatási + feladatokat 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 + linkend="printing-simple">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. + linkend="printing-advanced">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). + linkend="printing-advanced-restricting-remote">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 + itt fogja összegyûjteni a nyomtatási + feladatokat, 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 + linkend="printing-advanced-header-pages-enabling"> + 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: +# A "rattan" rose-hoz csatlakozik, így küldhetünk neki nyomtatási +# feladatot: # 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ár 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 + ezt a nyomtatási feladatot 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 + linkend="printing-advanced-network-rm">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 + és egyenként mekkora nyomtatási feladatokat 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 + a felhasználó egy nyomtatási feladat + kiküldéséhez az lpr + parancsot használja, + akkor a nyomtatási feladatban 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 + kapcsolóval küldenek el feladatokat 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 + linkend="printing-advanced-network-rm">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 meg 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: + nyomtatási feladatban 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össze 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 + linkend="printing-advanced-network-rm">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ót 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 + <title>A beküldött nyomtatási feladatok méretének szabályozása nyomtatási - munkák + feladatok 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. + arról, hogy mindenki nyomtatási feladatát + el tudjuk rendesen tárolni. - nyomtatási munkák + nyomtatási feladatok szabályozása Az LPD az mx tulajdonsággal lehetõséget ad arra, hogy - lekorlátozzuk a munkákban + lekorlátozzuk a nyomtatási feladatokban 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. + Ez az érték a nyomtatási + feladatokban levõ egyes + állományok méretére + vonatkozik, nem pedig a + nyomtatási feladatok 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: +# Itt nincs korlát a nyomtatási feladatokra: # 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 + linkend="printing-advanced-network-rm">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 + 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: + feladatok 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 - fogadásához. + távolról beérkezõ nyomtatási + feladat fogadá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. + nyomtatási feladatokat 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 + számára a távoli nyomtatási + feladatok 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 + felhasználóktól nyomtatási + feladatot, ha az adott feladatot + 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 nekik 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 + linkend="printing-advanced-filter-intro">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 + egyszerûbb. Amikor valaki végrehajt egy + nyomtatási feladatot, 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. + számítógépek neveit, a + nyomtatási feladatok 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 + 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), + linkend="printing-advanced-filters">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íttethetjü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 + lapot használt egy nyomtatási feladat 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 + nyomtatási feladatban 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 + 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 kinyomtatta-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. + Nyomtatási feladatokat hajt végre. &man.lpq.1; Ellenõrzi a nyomtatási sorokat. &man.lprm.1; - Munkákat vesz ki a nyomtatási + Feladatokat 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û + 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, + képesek vagyunk nyomtatási feladatokat 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 + Nyomtatási feladatok + végrehajtá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û + linkend="printing-lpr-options">Nyomtatási + beállítások címû szakaszban lesz szó. - Munkák felügyelete + Nyomtatási feladatok felügyelete nyomtatási - munkák + feladatok 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 + feladatnak 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 + nyomtatási feladatokat találhatjuk. A + nyomtató ezután ezeket é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 + Itt három nyomtatási feladatot + láthatunk a bamboo nyomtatási + sorában. Az elsõ nyomtatási feladat, amit a + kelly nevû felhasználó + küldött, a 9-es feladatszámot + kapta. A nyomtatóhoz tartozó összes feladat + 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û + hozzátartozó nyomtatási feladatot. Ezzel + majd a Nyomtatási feladatok + 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 + A kilences számú nyomtatási feladat + két állományt tartalmaz: ha a parancssorban + több állományt adunk meg az &man.lpr.1; + programnak, akkor az egy nyomtatási feladatnak + számít. Ez egyben a pillanatnyilag aktív + nyomtatási feladat (ezt a Rank oszlopban + szereplõ active érték + jelzi), tehát a nyomtató éppen ezzel + foglalatoskodik. A második nyomtatási feladat 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. + nagyobb méretû nyomtatási feladat. 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 + Nyomtatási feladatok + eltávolítása + + Ha meggondoltuk volna magunkat egy nyomtatási + feladattal kapcsolatban, az &man.lprm.1; paranccsal még + törölni tudjuk a sorból. Az &man.lprm.1; + gyakran még a folyamatban levõ nyomtatási + feladatot is képes eltávolítani, azonban + elõfordulhat, hogy a nyomtatási feladat egy + része már elvégzésre 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 + sorából csak úgy tudunk nyomtatási + feladatokat 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 + &prompt.user; lprm feladatá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: + nyomtatási feladatot törölni. A most + következõ parancs a bamboo + nevû nyomtatóról törli a 10-es + számú nyomtatási feladatot: &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). + tartozó az összes nyomtatási feladatot + (az alapértelmezett nyomtatón). lprm felhasználó Eltávolítja az adott felhasználóhoz - tartozó összes munkát (az + tartozó összes nyomtatási feladatot (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 + csak a saját nyomtatási feladataikat 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. + A nyomtatási feladat 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 + nyomtatási feladatot, amennyiben az a miénk. Csak a rendszergazdák képesek - bármilyen aktív munkát + bármilyen aktív nyomtatási feladatot 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: + nyomtatási feladatot 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 + törölni a nyomtatási feladatokat, + 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ó. + készítését, nyomtatási + feladatok 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ó + nyomtatási feladatokban 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 a &man.pr.1; segédprogrammal. + beállításokat, ha a nyomtatási + feladat nem tartalmaz nyers szöveget, vagy ha nyers + szöveget akarunk formázni a &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. + Ezek a beállítások a + nyomtatási feladatban szereplõ minden egyes + állományra vonatkoznak, ezért nem + keverhetjük (például) a DVI és + ditroff formátumú állományokat egy + nyomtatási feladaton belül. Ehelyett + külön nyomtatási feladatokban kell + elküldenünk az eltérõ + formátumú állományokat, és + mindegyik nyomtatási feladathoz 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. + linkend="printing-advanced-convfilters">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 feladatot 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 + Nyomtatási feladatok 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: + utasítani, hogy a nyomtatási feladatot + 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ó + nyomtatási feladatban 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. + linkend="printing-advanced-restricting-copies">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 nyomtassunk 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 + A rendszer küldjön levelet a + nyomtatási feladat teljesítése + után. Ekkor az LPD a + nyomtatási feladat 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 + Egy nagyobb nyomtatási feladat + elvégzése 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. + nyomtatási feladatok 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 + nyomtatási feladat 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 + küldjük a nyomtatási feladatot, 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. + átmásolni a nyomtatási feladatot, + í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 + Törölje a nyomtatási feladatban + 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 + beállításai a nyomtatási feladatok 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 + linkend="printing-advanced-header-pages">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. + ahonnan a nyomtatási feladatot + 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 + A fejléclapon megjelenõ + nyomtatási feladat neve helyett a + szöveg fog megjelenni. + A nyomtatási feladat 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. + linkend="printing-advanced-header-pages">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. + található nyomtatási + feladatokat. Elõször is essen pár szó 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. + nyomtatási feladatokat 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 + felhasználó sem képes nyomtatási + feladatokat küldeni a nyomtatónak. A bekapcsolt sorok képesek csak - munkát fogadni. A nyomtató + nyomtatási feladatot 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. + is, ilyenkor egészen addig folytatja a nyomtatási + feladatok elvégzé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ó + Az aktuális nyomtatási feladat + 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. + nyomtatási feladatokat. 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 + adódhat, hogy bizonyos nyomtatási feladatok á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 + Az újonnan érkezõ nyomtatási + feladatok 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. + nyomtatási feladatok + elvégzését. A rendszergazda (a + root) még a kikapcsolt sorok + esetén is küldhet nyomtatási + feladatokat. 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, + felhasználóként nyomtatási + feladatokat küldeni. A többi + felhasználó a tesztelés + befejezéséig nem tud majd nyomtatási + feladatokat 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 + nyomtatónak feladatokat küldeni, azonban egészen addig nem nyomtatódik ki semmi, amíg a nyomtatót 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. + sorában levõ nyomtatási + feladatokat. 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 + a nyomtató az aktuális nyomtatási + feladat 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 + képesek feladatokat küldeni a nyomtatási sorába. topq nyomtatónév - munka-vagy-felhasználónév + feladat-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 + feladatot vagy a megadott felhasználónévhez - tartozó munkákat a sor elejére teszi. - Ennél a parancsnál + tartozó nyomtatási feladatokat 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éteget 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 + feladatok é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 kaphatjuk 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övegnek 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. + ez, ha minden egyes nyomtatási feladatot + külön lapon akarunk kezdeni, mivel így a + következõ nyomtatási feladat sosem + közvetlenül ott kezdõdik, ahol az + elõzõ feladat 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: + használhatával tudunk minden nyomtatási + feladat elvégzése 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). +# 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 +# nyomtatási feladat elvégzése 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 + hogy a nyomtatási feladatok 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 elküldünk egy lapdobást. - Szinte az összes Hewlett Packard nyomtatóval - mûködnie kell. + nyomtatási feladatot, és a + nyomtatási feladat eredményének + utolsó lapja után 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 a 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ót összekötõ kábel meg tudjon majd birkó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 összevissza 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.