/usr/share/doc/HOWTO/de-html/DE-Samba-HOWTO-9.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<HTML>
<HEAD>
 <META NAME="GENERATOR" CONTENT="LinuxDoc-Tools 0.9.65">
 <TITLE>Linux Samba HOWTO: Gemeinsame Nutzung eines Windows-Druckers</TITLE>
 <LINK HREF="DE-Samba-HOWTO-8.html" REL=previous>
 <LINK HREF="DE-Samba-HOWTO.html#toc9" REL=contents>
</HEAD>
<BODY>
<IMG SRC="next.png" ALT="Weiter">
<A HREF="DE-Samba-HOWTO-8.html"><IMG SRC="prev.png" ALT="Zurück"></A>
<A HREF="DE-Samba-HOWTO.html#toc9"><IMG SRC="toc.png" ALT="Inhalt"></A>
<HR>
<H2><A NAME="s9">9.</A> <A HREF="DE-Samba-HOWTO.html#toc9">Gemeinsame Nutzung eines Windows-Druckers</A></H2>

<P>Um einen an einem Windows-Rechner angeschlossenen Drucker auch von
Linux aus nutzen zu k&ouml;nnen, mu&szlig; folgenderma&szlig;en vorgegangen werden:
<OL>
<LI>Es m&uuml;ssen die entsprechenden Eintr&auml;ge aus der Datei 
<CODE>/etc/printcap</CODE> vorliegen. Diese m&uuml;ssen zur lokalen
Verzeichnisstruktur passen -also zum Spool-Verzeichnis u.s.w.-.</LI>
<LI>Das Skript <CODE>/usr/bin/smbprint</CODE> mu&szlig; vorhanden sein. Es
ist Bestandteil der Quellcodes von Samba. Dieses Skript liegt
aber nicht allen bin&auml;ren Distributionen bei. Deshalb folgt unten
die Vorstellung einer leicht ge&auml;nderten Kopie des Skripts.</LI>
<LI>Sollen ASCII-Dateien nach Postscript konvertiert werden,
dann mu&szlig; <CODE>nenscript</CODE> oder ein vergleichbaren Produkt
vorhanden sein. Bei <CODE>nenscript</CODE> handelt es sich um ein
Postscript-Konvertierprogramm, das i. allg. im Verzeichnis
<CODE>/usr/bin</CODE> installiert ist.</LI>
</OL>
</P>
<P>
<DL>
<DT><B>Anmerkung</B><DD>
<P>Das weiter unten vorgestellte Perl-Skript vereinfacht
das Drucken unter Samba. Es erm&ouml;glicht das Drucken
von ASCII, Postscript und erzeugtem Postscript.</P>
</DL>
</P>

<P>Der Eintrag in der <CODE>/etc/printcap</CODE> bezieht sich auf einen
HP 5MP-Drucker, der an einen WindowsNT-Rechner angeschlossen ist.
Doch zun&auml;chst wird die Bedeutung der dort verwendeten Abk&uuml;rzungen
erl&auml;utert. Weitergehende Informationen enthalten die
<EM>Linux Drucker HOWTO</EM> und die <CODE>man-pages</CODE> f&uuml;r die
Datei <CODE>printcap</CODE>.</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
    cm - Kommentar
    lp - Name des Geraetes, das f&uuml;r die Ausgabe geoeffnet werden soll
    sd - das sich auf dem lokalen Rechner befindende Spoolverzeichnis
          fuer den Drucker
    af - die Datei f&uuml;r die Protokollierung der Druckerzugriffe
    mx - die maximale Dateilaenge (Null bedeutet unbegrenzt)
    if - Name des Skripts f&uuml;r den Eingabefilter
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Und hier nun ein Auszug aus der <CODE>/etc/printcap</CODE> f&uuml;r den
Drucker HP 5MP.</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
    # /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:
</PRE>
</CODE></BLOCKQUOTE>
</P>

<P>Wichtig ist, da&szlig; man sich vergewissert, da&szlig; die Spool- und
Zugriffs-Verzeichnisse existieren und f&uuml;r das Schreiben
freigegeben sind. </P>
<P>Es mu&szlig; sichergestellt werden, da&szlig; die <CODE>if</CODE>-Zeile den richtigen
Pfad f&uuml;r das unten angegebene Skript <CODE>smbprint</CODE> enth&auml;lt und da&szlig;
dabei auf das richtige Ausgabeger&auml;t verwiesen wird, also die spezielle
<CODE>/dev</CODE>-Datei.</P>
<P>
<DL>
<DT><B><CODE>smbprint</CODE></B><DD>
<P>Dies ist ein Skript, das sich i.allg. im
Verzeichnis <CODE>/usr/bin</CODE> 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&auml;ren
Distributionen. Deshalb wird es nachfolgend
aufgef&uuml;hrt. Dabei mu&szlig; allerdings beachtet werden,
da&szlig; es einige kleine &Auml;nderungen enth&auml;lt. Diese
haben sich im Alltagseinsatz als brauchbar
erwiesen.</P>
</DL>
</P>
<P>Ausdruck der modifizierten Datei <CODE>smbprint</CODE>:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
    #!/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
</PRE>
</CODE></BLOCKQUOTE>
</P>

<P>Die meisten Linux-Distributionen enthalten <CODE>nenscript</CODE>,
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
<CODE>smbprint</CODE> zur Verf&uuml;gung stellt.</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
    Usage: print [-a|c|p] &lt;filename&gt;
           -a prints &lt;filename> as ASCII
           -c prints &lt;filename> formatted as source code
           -p prints &lt;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.
</PRE>
</CODE></BLOCKQUOTE>
</P>

<P>Wird <CODE>smbprint</CODE> genutzt, um ASCII-Dateien zu drucken, so werden
zu lange Zeilen abgeschnitten. Falls es m&ouml;glich ist, bricht das
Skript dabei die zu langen Zeilen bei Leerzeichen um und nicht in der
Mitte eines Wortes.</P>
<P>Die Formatierung des Quellcodes erfolgt mit <CODE>nenscript</CODE>. Es
wird eine ASCII-Datei genommen und zweispaltig einschlie&szlig;lich 
Kopfzeile formatiert. Diese Kopfzeile enth&auml;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&szlig; sie unmittelbar weitergeleitet werden.</P>

<P>Und nun das Listing des Skriptes <CODE>print</CODE>:
<BLOCKQUOTE><CODE>
<PRE>
  #!/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!";
  }

  &amp;ParseCmdLine(@ARGV);

  # DBG
  print "filetype is $filetype\n";

  if ($filetype eq "ASCII") {
          &amp;wrap($line_length);
  } elsif ($filetype eq "code") {
          &amp;codeformat;
  } elsif ($filetype eq "ps") {
          &amp;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 ($#_ &lt; 0) {
                  &amp;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] &lt;filename&gt;
         -a prints &lt;filename> as ASCII
         -c prints &lt;filename> formatted as source code
         -p prints &lt;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 &lt; 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, "&lt;$file") || die "Can't open $file: $!\n";
          while(&lt;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
          &amp;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, "&lt;$tmpfile") || die "Can't open $file: $!\n";
          while(&lt;FILE&amp;>) {
                  push(@newlines,$_);
          }
          close(FILE);
          system("rm $tmpfile");
  }

  sub createarray {
          # Create the array for postscript
          open(FILE, "&lt;$file") || die "Can't open $file: $!\n";
          while(&lt;FILE>) {
                  push(@newlines,$_);
          }
          close(FILE);
  }
</PRE>
</CODE></BLOCKQUOTE>
</P>
<HR>
<IMG SRC="next.png" ALT="Weiter">
<A HREF="DE-Samba-HOWTO-8.html"><IMG SRC="prev.png" ALT="Zurück"></A>
<A HREF="DE-Samba-HOWTO.html#toc9"><IMG SRC="toc.png" ALT="Inhalt"></A>
</BODY>
</HTML>
doc-linux-de 2003.10-5 / usr / share / doc / HOWTO / de-html / DE-Samba-HOWTO-9.html
