Um einen an einem Windows-Rechner angeschlossenen Drucker auch von Linux aus nutzen zu können, muß folgendermaßen vorgegangen werden:
/etc/printcap vorliegen. Diese müssen zur lokalen
Verzeichnisstruktur passen -also zum Spool-Verzeichnis u.s.w.-./usr/bin/smbprint muß vorhanden sein. Es
ist Bestandteil der Quellcodes von Samba. Dieses Skript liegt
aber nicht allen binären Distributionen bei. Deshalb folgt unten
die Vorstellung einer leicht geänderten Kopie des Skripts.nenscript oder ein vergleichbaren Produkt
vorhanden sein. Bei nenscript handelt es sich um ein
Postscript-Konvertierprogramm, das i. allg. im Verzeichnis
/usr/bin installiert ist.
Das weiter unten vorgestellte Perl-Skript vereinfacht das Drucken unter Samba. Es ermöglicht das Drucken von ASCII, Postscript und erzeugtem Postscript.
Der Eintrag in der /etc/printcap bezieht sich auf einen
HP 5MP-Drucker, der an einen WindowsNT-Rechner angeschlossen ist.
Doch zunächst wird die Bedeutung der dort verwendeten Abkürzungen
erläutert. Weitergehende Informationen enthalten die
Linux Drucker HOWTO und die man-pages für die
Datei printcap.
cm - Kommentar
lp - Name des Geraetes, das für die Ausgabe geoeffnet werden soll
sd - das sich auf dem lokalen Rechner befindende Spoolverzeichnis
fuer den Drucker
af - die Datei für die Protokollierung der Druckerzugriffe
mx - die maximale Dateilaenge (Null bedeutet unbegrenzt)
if - Name des Skripts für den Eingabefilter
Und hier nun ein Auszug aus der /etc/printcap für den
Drucker HP 5MP.
# /etc/printcap
#
# //zimmerman/oreilly via smbprint
#
lp:\
:cm=HP 5MP Postscript OReilly on zimmerman:\
:lp=/dev/lp1:\
:sd=/var/spool/lpd/lp:\
:af=/var/spool/lpd/lp/acct:\
:mx#0:\
:if=/usr/bin/smbprint:
Wichtig ist, daß man sich vergewissert, daß die Spool- und Zugriffs-Verzeichnisse existieren und für das Schreiben freigegeben sind.
Es muß sichergestellt werden, daß die if-Zeile den richtigen
Pfad für das unten angegebene Skript smbprint enthält und daß
dabei auf das richtige Ausgabegerät verwiesen wird, also die spezielle
/dev-Datei.
smbprintDies ist ein Skript, das sich i.allg. im
Verzeichnis /usr/bin befindet. Es
stammt wohl von Andrew Tridgell, dem Programmierer
von Samba. Das Skript wird mit der
Quellcode-Distribution von Samba ausgeliefert.
Es fehlt allerdings in einigen binären
Distributionen. Deshalb wird es nachfolgend
aufgeführt. Dabei muß allerdings beachtet werden,
daß es einige kleine Änderungen enthält. Diese
haben sich im Alltagseinsatz als brauchbar
erwiesen.
Ausdruck der modifizierten Datei smbprint:
#!/bin/sh -x
# This script is an input filter for printcap printing on a unix machine.
# It uses the smbclient program to print the file to the specified
# smb-based server and service.
# For example you could have a printcap entry like this
#
# smb:lp=/dev/null:sd=/usr/spool/smb:sh:if=/usr/local/samba/smbprint
#
# which would create a unix printer called "smb" that will print via
# this script. You will need to create the spool directory /usr/spool/smb
# with appropriate permissions and ownerships for your system.
# Set these to the server and service you wish to print to
# In this example I have a WfWg PC called "lapland" that has a printer
# exported called "printer" with no password.
#
# Script further altered by hamiltom@ecnz.co.nz (Michael Hamilton)
# so that the server, service, and password can be read from
# a /usr/var/spool/lpd/PRINTNAME/.config file.
#
# In order for this to work the /etc/printcap entry must include an
# accounting file (af=...):
#
# cdcolour:\
# :cm=CD IBM Colorjet on 6th:\
# :sd=/var/spool/lpd/cdcolour:\
# :af=/var/spool/lpd/cdcolour/acct:\
# :if=/usr/local/etc/smbprint:\
# :mx=0:\
# :lp=/dev/null:
#
# The /usr/var/spool/lpd/PRINTNAME/.config file should contain:
# server=PC_SERVER
# service=PR_SHARENAME
# password="password"
#
# E.g.
# server=PAULS_PC
# service=CJET_371
# password=""
#
# Debugging log file, change to /dev/null if you like.
#
logfile=/tmp/smb-print.log
# logfile=/dev/null
#
# The last parameter to the filter is the accounting file name.
#
spool_dir=/var/spool/lpd/lp
config_file=$spool_dir/.config
# Should read the following variables set in the config file:
# server
# service
# password
# user
eval `cat $config_file`
#
# Some debugging help, change the >> to > if you want to same space.
#
echo "server $server, service $service" >> $logfile
(
# NOTE You may wish to add the line `echo translate' if you want
# automatic CR/LF translation when printing.
echo translate
echo "print -"
cat
) | /usr/bin/smbclient
"\\\\$server\\$service" $password -U $user -N -P >> $logfile
Die meisten Linux-Distributionen enthalten nenscript,
um ASCII-Dateien in Postskript zu konvertieren. Das folgende
Perl-Skript gestaltet die Handhabung jedoch einfacher, in dem es
eine einfache Schnittstelle zum Drucken unter Linux mit
smbprint zur Verfügung stellt.
Usage: print [-a|c|p] <filename>
-a prints <filename> as ASCII
-c prints <filename> formatted as source code
-p prints <filename> as Postscript
Wird kein Schalter gesetzt, so geht das Skript davon
aus, dass es selbst den Dateityp ermitteln und
die Datei dann entsprechend ausdrucken soll.
Wird smbprint genutzt, um ASCII-Dateien zu drucken, so werden
zu lange Zeilen abgeschnitten. Falls es möglich ist, bricht das
Skript dabei die zu langen Zeilen bei Leerzeichen um und nicht in der
Mitte eines Wortes.
Die Formatierung des Quellcodes erfolgt mit nenscript. Es
wird eine ASCII-Datei genommen und zweispaltig einschließlich
Kopfzeile formatiert. Diese Kopfzeile enthält u. a. das Datum und
den Dateinamen. Die Zeilen werden numeriert. Wenn man dieses Skript
als Beispiel verwendet, lassen sich auch andere Formatierungen
gestalten. Dabei sind Postskript-Dokumente sind schon geeignet
formatiert, so daß sie unmittelbar weitergeleitet werden.
Und nun das Listing des Skriptes print:
#!/usr/bin/perl
# Script: print
# Authors: Brad Marshall, David Wood
# Plugged In Communications
# Date: 960808
#
# Script to print to oreilly which is currently on zimmerman
# Purpose: Takes files of various types as arguments and
# processes them appropriately for piping to a Samba print script.
#
# Currently supported file types:
#
# ASCII - ensures that lines longer than $line_length characters
# wrap on whitespace.
# Postscript - Takes no action.
# Code - Formats in Postscript (using nenscript) to display
# properly (landscape, font, etc).
#
# Set the maximum allowable length for each line of ASCII text.
$line_length = 76;
# Set the path and name of the Samba print script
$print_prog = "/usr/bin/smbprint";
# Set the path and name to nenscript (the ASCII-->Postscript converter)
$nenscript = "/usr/bin/nenscript";
unless ( -f $print_prog ) {
die "Can't find $print_prog!";
}
unless ( -f $nenscript ) {
die "Can't find $nenscript!";
}
&ParseCmdLine(@ARGV);
# DBG
print "filetype is $filetype\n";
if ($filetype eq "ASCII") {
&wrap($line_length);
} elsif ($filetype eq "code") {
&codeformat;
} elsif ($filetype eq "ps") {
&createarray;
} else {
print "Sorry..no known file type.\n";
exit 0;
}
# Pipe the array to smbprint
open(PRINTER, "|$print_prog") || die "Can't open $print_prog: $!\n";
foreach $line (@newlines) {
print PRINTER $line;
}
# Send an extra linefeed in case a file has an incomplete last line.
print PRINTER "\n";
close(PRINTER);
print "Completed\n";
exit 0;
# --------------------------------------------------- #
# Everything below here is a subroutine #
# --------------------------------------------------- #
sub ParseCmdLine {
# Parses the command line, finding out what file type the file is
# Gets $arg and $file to be the arguments (if the exists)
# and the filename
if ($#_ < 0) {
&usage;
}
# DBG
# foreach $element (@_) {
# print "*$element* \n";
# }
$arg = shift(@_);
if ($arg =~ /\-./) {
$cmd = $arg;
# DBG
# print "\$cmd found.\n";
$file = shift(@_);
} else {
$file = $arg;
}
# Defining the file type
unless ($cmd) {
# We have no arguments
if ($file =~ /\.ps$/) {
$filetype = "ps";
} elsif ($file =~;
/\.java$|\.c$|\.h$|\.pl$|\.sh$|\.csh$|\.m4$|\.inc$|\.html$|\.htm$/) {
$filetype = "code";
} else {
$filetype = "ASCII";
}
# Process $file for what type is it and return $filetype
} else {
# We have what type it is in $arg
if ($cmd =~ /^-p$/) {
$filetype = "ps";
} elsif ($cmd =~ /^-c$/) {
$filetype = "code";
} elsif ($cmd =~ /^-a$/) {
$filetype = "ASCII"
}
}
}
sub usage {
print "
Usage: print [-a|c|p] <filename>
-a prints <filename> as ASCII
-c prints <filename> formatted as source code
-p prints <filename> as Postscript
If no switch is given, print attempts to
guess the file type and print appropriately.\n
";
exit(0);
}
sub wrap {
# Create an array of file lines, where each line is < the
# number of characters specified, and wrapped only on whitespace
# Get the number of characters to limit the line to.
$limit = pop(@_);
# DBG
#print "Entering subroutine wrap\n";
#print "The line length limit is $limit\n";
# Read in the file, parse and put into an array.
open(FILE, "<$file") || die "Can't open $file: $!\n";
while(<FILE>) {
$line = $_;
# DBG
#print "The line is:\n$line\n";
# Wrap the line if it is over the limit.
while ( length($line) > $limit ) {
# DBG
#print "Wrapping...";
# Get the first $limit +1 characters.
$part = substr($line,0,$limit +1);
# DBG
#print "The partial line is:\n$part\n";
# Check to see if the last character is a space.
$last_char = substr($part,-1, 1);
if ( " " eq $last_char ) {
# If it is, print the rest.
# DBG
#print "The last character was a space\n";
substr($line,0,$limit + 1) = "";
substr($part,-1,1) = "";
push(@newlines,"$part\n");
} else {
# If it is not, find the last space in the
# sub-line and print up to there.
# DBG
#print "The last character was not a space\n";
# Remove the character past $limit
substr($part,-1,1) = "";
# Reverse the line to make it easy to find
# the last space.
$revpart = reverse($part);
$index = index($revpart," ");
if ( $index > 0 ) {
substr($line,0,$limit-$index) = "";
push(@newlines,substr($part,0,$limit-$index)
. "\n");
} else {
# There was no space in the line, so
# print it up to $limit.
substr($line,0,$limit) = "";
push(@newlines,substr($part,0,$limit)
. "\n");
}
}
}
push(@newlines,$line);
}
close(FILE);
}
sub codeformat {
# Call subroutine wrap then filter through nenscript
&wrap($line_length);
# Pipe the results through nenscript to create a Postscript
# file that adheres to some decent format for printing
# source code (landscape, Courier font, line numbers).
# Print this to a temporary file first.
$tmpfile = "/tmp/nenscript$$";
open(FILE, "|$nenscript -2G -i$file -N -p$tmpfile -r") ||
die "Can't open nenscript: $!\n";
foreach $line (@newlines) {
print FILE $line;
}
close(FILE);
# Read the temporary file back into an array so it can be
# passed to the Samba print script.
@newlines = ("");
open(FILE, "<$tmpfile") || die "Can't open $file: $!\n";
while(<FILE&>) {
push(@newlines,$_);
}
close(FILE);
system("rm $tmpfile");
}
sub createarray {
# Create the array for postscript
open(FILE, "<$file") || die "Can't open $file: $!\n";
while(<FILE>) {
push(@newlines,$_);
}
close(FILE);
}