# kdeprint Library API Documentation

Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Namespaces | Source Files

# kmlpdmanager.cpp

    00001 /*
    00002  *  This file is part of the KDE libraries
    00003  *  Copyright (c) 2001 Michael Goffioul <kdeprint@swing.be>
    00004  *
    00005  *  This library is free software; you can redistribute it and/or
    00006  *  modify it under the terms of the GNU Library General Public
    00007  *  License version 2 as published by the Free Software Foundation.
    00008  *
    00009  *  This library is distributed in the hope that it will be useful,
    00010  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    00011  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00012  *  Library General Public License for more details.
    00013  *
    00014  *  You should have received a copy of the GNU Library General Public License
    00015  *  along with this library; see the file COPYING.LIB.  If not, write to
    00016  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    00017  *  Boston, MA 02111-1307, USA.
    00018  **/
    00019
    00020 #include "kmlpdmanager.h"
    00021 #include "kmprinter.h"
    00022 #include "kmdbentry.h"
    00023 #include "driver.h"
    00024 #include "kmfactory.h"
    00025 #include "lpdtools.h"
    00026 #include "gschecker.h"
    00027 #include "kpipeprocess.h"
    00028
    00029 #include <qfile.h>
    00030 #include <qfileinfo.h>
    00031 #include <qtextstream.h>
    00032 #include <qmap.h>
    00033 #include <qregexp.h>
    00034
    00035 #include <klocale.h>
    00036 #include <kstandarddirs.h>
    00037 #include <kconfig.h>
    00038 #include <kprocess.h>
    00039
    00040 #include <pwd.h>
    00041 #include <unistd.h>
    00042 #include <stdlib.h>
    00043 #include <sys/stat.h>
    00044
    00045 // only there to allow testing on my system. Should be removed
    00046 // when everything has proven to be working and stable
    00047 QString lpdprefix = "";
    00048 QString ptPrinterType(KMPrinter*);
    00049
    00050 //************************************************************************************************
    00051
    00052 KMLpdManager::KMLpdManager(QObject *parent, const char *name)
    00053 : KMManager(parent,name)
    00054 {
    00055     m_entries.setAutoDelete(true);
    00056     m_ptentries.setAutoDelete(true);
    00057     setHasManagement(getuid() == 0);
    00058     setPrinterOperationMask(KMManager::PrinterCreation|KMManager::PrinterConfigure|KMManager::PrinterRemoval|KMManager::PrinterEnabling);
    00059     m_gschecker = new GsChecker(this,"GsChecker");
    00060 }
    00061
    00062 KMLpdManager::~KMLpdManager()
    00063 {
    00064 }
    00065
    00066 QString KMLpdManager::driverDbCreationProgram()
    00067 {
    00068     return QString::fromLatin1("make_driver_db_lpd");
    00069 }
    00070
    00071 QString KMLpdManager::driverDirectory()
    00072 {
    00073     return QString::fromLatin1("/usr/lib/rhs/rhs-printfilters");
    00074 }
    00075
    00076 bool KMLpdManager::completePrinter(KMPrinter *printer)
    00077 {
    00078     return completePrinterShort(printer);
    00079 }
    00080
    00081 bool KMLpdManager::completePrinterShort(KMPrinter *printer)
    00082 {
    00083     PrintcapEntry   *entry = m_entries.find(printer->name());
    00084     if (entry)
    00085     {
    00086         QString type(entry->comment(2)), driver(entry->comment(7)), lp(entry->arg("lp"));
    00087         printer->setDescription(i18n("Local printer queue (%1)").arg(type.isEmpty() ? i18n("Unknown type of local printer queue", "Unknown") : type));
    00088         printer->setLocation(i18n("<Not available>"));
    00089         printer->setDriverInfo(driver.isEmpty() ? i18n("Unknown Driver", "Unknown") : driver);
    00090         // device
    00091         KURL    url;
    00092         if (!entry->arg("rm").isEmpty())
    00093         {
    00094             url = QString::fromLatin1("lpd://%1/%2").arg(entry->arg("rm")).arg(entry->arg("rp"));
    00095             printer->setDescription(i18n("Remote LPD queue %1@%2").arg(entry->arg("rp")).arg(entry->arg("rm")));
    00096         }
    00097         else if (!lp.isEmpty() && lp != "/dev/null")
    00098             url = QString::fromLatin1("parallel:%1").arg(lp);
    00099         else if (QFile::exists(entry->arg("sd")+"/.config"))
    00100         {
    00101             QMap<QString,QString>   map = loadPrinttoolCfgFile(entry->arg("sd")+"/.config");
    00102             if (type == "SMB")
    00103             {
    00104                 QStringList l = QStringList::split('\\',map["share"],false);
    00105                 if (map["workgroup"].isEmpty())
    00106                     url = QString::fromLatin1("smb://%1/%2").arg(l[0]).arg(l[1]);
    00107                 else
    00108                     url = QString::fromLatin1("smb://%1/%2/%3").arg(map["workgroup"]).arg(l[0]).arg(l[1]);
    00109                 url.setUser(map["user"]);
    00110                 url.setPass(map["password"]);
    00111             }
    00112             else if (type == "DIRECT")
    00113                 url = QString::fromLatin1("socket://%1:%2").arg(map["printer_ip"]).arg(map["port"]);
    00114             else if (type == "NCP")
    00115             {
    00116                 url = QString::fromLatin1("ncp://%1/%2").arg(map["server"]).arg(map["queue"]);
    00117                 url.setUser(map["user"]);
    00118                 url.setPass(map["password"]);
    00119             }
    00120         }
    00121         printer->setDevice(url);
    00122         return true;
    00123     }
    00124     else return false;
    00125 }
    00126
    00127 bool KMLpdManager::createPrinter(KMPrinter *printer)
    00128 {
    00129     // 1) create the printcap entry
    00130     PrintcapEntry   *ent = findPrintcapEntry(printer->printerName());
    00131     if (!ent)
    00132     {
    00133         ent = new PrintcapEntry();
    00134         ent->m_name = printer->printerName();
    00135     }
    00136     else
    00137     {
    00138         if (!printer->driver() && printer->option("kde-driver") != "raw")
    00139             printer->setDriver(loadPrinterDriver(printer,true));
    00140         // remove it from current entries
    00141         ent = m_entries.take(ent->m_name);
    00142         ent->m_args.clear();
    00143     }
    00144     // Standard options
    00145     if (printer->device().protocol() == "lpd")
    00146     {
    00147         // remote lpd queue
    00148         ent->m_args["rm"] = printer->device().host();
    00149         ent->m_args["rp"] = printer->device().path().replace("/",QString::fromLatin1(""));
    00150         ent->m_args["lpd_bounce"] = "true";
    00151         ent->m_comment = QString::fromLatin1("##PRINTTOOL3## REMOTE");
    00152     }
    00153     ent->m_args["mx"] = (printer->option("mx").isEmpty() ? "#0" : printer->option("mx"));
    00154     ent->m_args["sh"] = QString::null;
    00155     // create spool directory (if necessary) and update PrintcapEntry object
    00156     if (!createSpooldir(ent))
    00157     {
    00158         setErrorMsg(i18n("Unable to create spool directory %1 for printer %2.").arg(ent->arg("sd")).arg(ent->m_name));
    00159         delete ent;
    00160         return false;
    00161     }
    00162     if (!printer->driver() || printer->driver()->get("drtype") == "printtool")
    00163         if (!createPrinttoolEntry(printer,ent))
    00164         {
    00165             setErrorMsg(i18n("Unable to save information for printer <b>%1</b>.").arg(printer->printerName()));
    00166             delete ent;
    00167             return false;
    00168         }
    00169
    00170     // 2) write the printcap file
    00171     m_entries.insert(ent->m_name,ent);
    00172     if (!writePrinters())
    00173         return false;
    00174
    00175     // 3) save the printer driver (if any)
    00176     if (printer->driver())
    00177     {
    00178         if (!savePrinterDriver(printer,printer->driver()))
    00179         {
    00180             m_entries.remove(ent->m_name);
    00181             writePrinters();
    00182             return false;
    00183         }
    00184     }
    00185
    00186     // 4) change permissions of spool directory
    00187     QCString cmd = "chmod -R o-rwx,g+rwX ";
    00188     cmd += QFile::encodeName(KProcess::quote(ent->arg("sd")));
    00189     cmd += "&& chown -R lp.lp ";
    00190     cmd += QFile::encodeName(KProcess::quote(ent->arg("sd")));
    00191     if (system(cmd.data()) != 0)
    00192     {
    00193         setErrorMsg(i18n("Unable to set correct permissions on spool directory %1 for printer <b>%2</b>.").arg(ent->arg("sd")).arg(ent->m_name));
    00194         return false;
    00195     }
    00196
    00197     return true;
    00198 }
    00199
    00200 bool KMLpdManager::removePrinter(KMPrinter *printer)
    00201 {
    00202     PrintcapEntry   *ent = findPrintcapEntry(printer->printerName());
    00203     if (ent)
    00204     {
    00205         ent = m_entries.take(printer->printerName());
    00206         if (!writePrinters())
    00207         {
    00208             m_entries.insert(ent->m_name,ent);
    00209             return false;
    00210         }
    00211         QCString cmd = "rm -rf ";
    00212         cmd += QFile::encodeName(KProcess::quote(ent->arg("sd")));
    00213         system(cmd.data());
    00214         delete ent;
    00215         return true;
    00216     }
    00217     else
    00218         return false;
    00219 }
    00220
    00221 bool KMLpdManager::enablePrinter(KMPrinter *printer, bool state)
    00222 {
    00223     KPipeProcess    proc;
    00224     QString     cmd = programName(0);
    00225     cmd += " ";
    00226     cmd += state ? "up" : "down";
    00227     cmd += " ";
    00228     cmd += KProcess::quote(printer->printerName());
    00229     if (proc.open(cmd))
    00230     {
    00231         QTextStream t(&proc);
    00232         QString     buffer;
    00233         while (!t.eof())
    00234             buffer.append(t.readLine());
    00235         if (buffer.startsWith("?Privilege"))
    00236         {
    00237             setErrorMsg(i18n("Permission denied: you must be root."));
    00238             return false;
    00239         }
    00240         return true;
    00241     }
    00242     else
    00243     {
    00244         setErrorMsg(i18n("Unable to execute command \"%1\".").arg(cmd));
    00245         return false;
    00246     }
    00247 }
    00248
    00249 bool KMLpdManager::enablePrinter(KMPrinter *printer)
    00250 {
    00251     return enablePrinter(printer,true);
    00252 }
    00253
    00254 bool KMLpdManager::disablePrinter(KMPrinter *printer)
    00255 {
    00256     return enablePrinter(printer,false);
    00257 }
    00258
    00259 void KMLpdManager::listPrinters()
    00260 {
    00261     m_entries.clear();
    00262     loadPrintcapFile(QString::fromLatin1("%1/etc/printcap").arg(lpdprefix));
    00263
    00264     QDictIterator<PrintcapEntry>    it(m_entries);
    00265     for (;it.current();++it)
    00266     {
    00267         KMPrinter   *printer = it.current()->createPrinter();
    00268         addPrinter(printer);
    00269     }
    00270
    00271     checkStatus();
    00272 }
    00273
    00274 QString KMLpdManager::programName(int f)
    00275 {
    00276     KConfig *conf = KMFactory::self()->printConfig();
    00277     conf->setGroup("LPD");
    00278     switch (f)
    00279     {
    00280         case 0: return conf->readPathEntry("LpdCommand","/usr/sbin/lpc");
    00281         case 1: return conf->readPathEntry("LpdQueue","lpq");
    00282         case 2: return conf->readPathEntry("LpdRemove","lprm");
    00283     }
    00284     return QString::null;
    00285 }
    00286
    00287 void KMLpdManager::checkStatus()
    00288 {
    00289     KPipeProcess    proc;
    00290     QString     cmd = programName(0) + " status all";
    00291     if (proc.open(cmd))
    00292     {
    00293         QTextStream t(&proc);
    00294         QString     line;
    00295         KMPrinter   *printer(0);
    00296         int     p(-1);
    00297         while (!t.eof())
    00298         {
    00299             line = t.readLine().stripWhiteSpace();
    00300             if (line.isEmpty())
    00301                 continue;
    00302             if ((p=line.find(':')) != -1)
    00303                 printer = findPrinter(line.left(p));
    00304             else if (line.startsWith("printing") && printer)
    00305                 printer->setState(line.find("enabled") != -1 ? KMPrinter::Idle : KMPrinter::Stopped);
    00306             else if (line.find("entries") != -1 && printer)
    00307                 if (!line.startsWith("no") && printer->state() == KMPrinter::Idle)
    00308                     printer->setState(KMPrinter::Processing);
    00309         }
    00310     }
    00311 }
    00312
    00313 bool KMLpdManager::writePrinters()
    00314 {
    00315     if (!writePrintcapFile(QString::fromLatin1("%1/etc/printcap").arg(lpdprefix)))
    00316     {
    00317         setErrorMsg(i18n("Unable to write printcap file."));
    00318         return false;
    00319     }
    00320     return true;
    00321 }
    00322
    00323 void KMLpdManager::loadPrintcapFile(const QString& filename)
    00324 {
    00325     QFile   f(filename);
    00326     if (f.exists() && f.open(IO_ReadOnly))
    00327     {
    00328         QTextStream t(&f);
    00329         QString     line, comment;
    00330         PrintcapEntry   *entry;
    00331         while (!t.eof())
    00332         {
    00333             line = getPrintcapLine(t,&comment);
    00334             if (line.isEmpty())
    00335                 continue;
    00336             entry = new PrintcapEntry;
    00337             if (entry->readLine(line))
    00338             {
    00339                 m_entries.insert(entry->m_name,entry);
    00340                 entry->m_comment = comment;
    00341             }
    00342             else
    00343             {
    00344                 delete entry;
    00345                 break;
    00346             }
    00347         }
    00348     }
    00349 }
    00350
    00351 bool KMLpdManager::writePrintcapFile(const QString& filename)
    00352 {
    00353     QFile   f(filename);
    00354     if (f.open(IO_WriteOnly))
    00355     {
    00356         QTextStream t(&f);
    00357         t << "# File generated by KDE print (LPD plugin).\n#Don't edit by hand." << endl << endl;
    00358         QDictIterator<PrintcapEntry>    it(m_entries);
    00359         for (;it.current();++it)
    00360             it.current()->writeEntry(t);
    00361         return true;
    00362     }
    00363     return false;
    00364 }
    00365
    00366 PrinttoolEntry* KMLpdManager::findPrinttoolEntry(const QString& name)
    00367 {
    00368     if (m_ptentries.count() == 0)
    00369         loadPrinttoolDb(driverDirectory()+"/printerdb");
    00370     PrinttoolEntry  *ent = m_ptentries.find(name);
    00371     if (!ent)
    00372         setErrorMsg(i18n("Couldn't find driver <b>%1</b> in printtool database.").arg(name));
    00373     return ent;
    00374 }
    00375
    00376 void KMLpdManager::loadPrinttoolDb(const QString& filename)
    00377 {
    00378     QFile   f(filename);
    00379     if (f.exists() && f.open(IO_ReadOnly))
    00380     {
    00381         QTextStream t(&f);
    00382         PrinttoolEntry  *entry = new PrinttoolEntry;
    00383         while (entry->readEntry(t))
    00384         {
    00385             m_ptentries.insert(entry->m_name,entry);
    00386             entry = new PrinttoolEntry;
    00387         }
    00388         delete entry;
    00389     }
    00390 }
    00391
    00392 DrMain* KMLpdManager::loadDbDriver(KMDBEntry *entry)
    00393 {
    00394     QString ptdbfilename = driverDirectory() + "/printerdb";
    00395     if (entry->file == ptdbfilename)
    00396     {
    00397         PrinttoolEntry  *ptentry = findPrinttoolEntry(entry->modelname);
    00398         if (ptentry)
    00399         {
    00400             DrMain  *dr = ptentry->createDriver();
    00401             return dr;
    00402         }
    00403     }
    00404     return NULL;
    00405 }
    00406
    00407 PrintcapEntry* KMLpdManager::findPrintcapEntry(const QString& name)
    00408 {
    00409     PrintcapEntry   *ent = m_entries.find(name);
    00410     if (!ent)
    00411         setErrorMsg(i18n("Couldn't find printer <b>%1</b> in printcap file.").arg(name));
    00412     return ent;
    00413 }
    00414
    00415 DrMain* KMLpdManager::loadPrinterDriver(KMPrinter *printer, bool config)
    00416 {
    00417     PrintcapEntry   *entry = findPrintcapEntry(printer->name());
    00418     if (!entry)
    00419         return NULL;
    00420
    00421     // check for printtool driver (only for configuration)
    00422     QString sd = entry->arg("sd"), dr(entry->comment(7));
    00423     if (QFile::exists(sd+"/postscript.cfg") && config && !dr.isEmpty())
    00424     {
    00425         QMap<QString,QString>   map = loadPrinttoolCfgFile(sd+"/postscript.cfg");
    00426         PrinttoolEntry  *ptentry = findPrinttoolEntry(dr);
    00427         if (!ptentry)
    00428             return NULL;
    00429         DrMain  *dr = ptentry->createDriver();
    00430         dr->setOptions(map);
    00431         map = loadPrinttoolCfgFile(sd+"/general.cfg");
    00432         dr->setOptions(map);
    00433         map = loadPrinttoolCfgFile(sd+"/textonly.cfg");
    00434         dr->setOptions(map);
    00435         return dr;
    00436     }
    00437
    00438     // default
    00439     if (entry->m_comment.startsWith("##PRINTTOOL3##"))
    00440         setErrorMsg(i18n("No driver found (raw printer)"));
    00441     else
    00442         setErrorMsg(i18n("Printer type not recognized."));
    00443     return NULL;
    00444 }
    00445
    00446 bool KMLpdManager::checkGsDriver(const QString& gsdriver)
    00447 {
    00448     if (gsdriver == "ppa" || gsdriver == "POSTSCRIPT" || gsdriver == "TEXT")
    00449         return true;
    00450     else if (!m_gschecker->checkGsDriver(gsdriver))
    00451     {
    00452         setErrorMsg(i18n("The driver device <b>%1</b> is not compiled in your GhostScript distribution. Check your installation or use another driver.").arg(gsdriver));
    00453         return false;
    00454     }
    00455     return true;
    00456 }
    00457
    00458 QMap<QString,QString> KMLpdManager::loadPrinttoolCfgFile(const QString& filename)
    00459 {
    00460     QFile   f(filename);
    00461     QMap<QString,QString>   map;
    00462     if (f.exists() && f.open(IO_ReadOnly))
    00463     {
    00464         QTextStream t(&f);
    00465         QString     line, name, val;
    00466         int         p(-1);
    00467         while (!t.eof())
    00468         {
    00469             line = getPrintcapLine(t);
    00470             if (line.isEmpty())
    00471                 break;
    00472             if (line.startsWith("export "))
    00473                 line.replace(0,7,"");
    00474             if ((p=line.find('=')) != -1)
    00475             {
    00476                 name = line.left(p);
    00477                 val = line.right(line.length()-p-1);
    00478                 val.replace("\"","");
    00479                 val.replace("'","");
    00480                 if (!name.isEmpty() && !val.isEmpty())
    00481                     map[name] = val;
    00482             }
    00483         }
    00484     }
    00485     return map;
    00486 }
    00487
    00488 bool KMLpdManager::savePrinttoolCfgFile(const QString& templatefile, const QString& dirname, const QMap<QString,QString>& options)
    00489 {
    00490     // defines input and output file
    00491     QString fname = QFileInfo(templatefile).fileName();
    00492     fname.replace(QRegExp("\\.in$"),QString::fromLatin1(""));
    00493     QFile   fin(templatefile);
    00494     QFile   fout(dirname + "/" + fname);
    00495     if (fin.exists() && fin.open(IO_ReadOnly) && fout.open(IO_WriteOnly))
    00496     {
    00497         QTextStream tin(&fin), tout(&fout);
    00498         QString     line, name;
    00499         int     p(-1);
    00500         while (!tin.eof())
    00501         {
    00502             line = tin.readLine().stripWhiteSpace();
    00503             if (line.isEmpty() || line[0] == '#')
    00504             {
    00505                 tout << line << endl;
    00506                 continue;
    00507             }
    00508             if (line.startsWith("export "))
    00509             {
    00510                 tout << "export ";
    00511                 line.replace(0,7,QString::fromLatin1(""));
    00512             }
    00513             if ((p=line.find('=')) != -1)
    00514             {
    00515                 name = line.left(p);
    00516                 tout << name << '=' << options[name] << endl;
    00517             }
    00518         }
    00519         return true;
    00520     }
    00521     else return false;
    00522 }
    00523
    00524 bool KMLpdManager::savePrinterDriver(KMPrinter *printer, DrMain *driver)
    00525 {
    00526     // To be able to save a printer driver, a printcap entry MUST exist.
    00527     // We can then retrieve the spool directory from it.
    00528     QString spooldir;
    00529     PrintcapEntry   *ent = findPrintcapEntry(printer->printerName());
    00530     if (!ent)
    00531         return false;
    00532     spooldir = ent->arg("sd");
    00533
    00534     if (driver->get("drtype") == "printtool" && !spooldir.isEmpty())
    00535     {
    00536         QMap<QString,QString>   options;
    00537         driver->getOptions(options,true);
    00538         // add some standard options
    00539         options["DESIRED_TO"] = "ps";
    00540         options["PRINTER_TYPE"] = ent->comment(2);  // get type from printcap entry (works in anycases)
    00541         options["PS_SEND_EOF"] = "NO";
    00542         if (!checkGsDriver(options["GSDEVICE"]))
    00543             return false;
    00544         QString resol(options["RESOLUTION"]), color(options["COLOR"]);
    00545         // update entry comment to make printtool happy and save printcap file
    00546         ent->m_comment = QString::fromLatin1("##PRINTTOOL3## %1 %2 %3 %4 {} {%5} %6 {}").arg(options["PRINTER_TYPE"]).arg(options["GSDEVICE"]).arg((resol.isEmpty() ? QString::fromLatin1("NAxNA") : resol)).arg(options["PAPERSIZE"]).arg(driver->name()).arg((color.isEmpty() ? QString::fromLatin1("Default") : color.right(color.length()-15)));
    00547         ent->m_args["if"] = spooldir+QString::fromLatin1("/filter");
    00548         if (!writePrinters())
    00549             return false;
    00550         // write various driver files using templates
    00551         QCString cmd = "cp ";
    00552         cmd += QFile::encodeName(KProcess::quote(driverDirectory()+"/master-filter"));
    00553         cmd += " ";
    00554         cmd += QFile::encodeName(KProcess::quote(spooldir + "/filter"));
    00555         if (system(cmd.data()) == 0 &&
    00556             savePrinttoolCfgFile(driverDirectory()+"/general.cfg.in",spooldir,options) &&
    00557             savePrinttoolCfgFile(driverDirectory()+"/postscript.cfg.in",spooldir,options) &&
    00558             savePrinttoolCfgFile(driverDirectory()+"/textonly.cfg.in",spooldir,options))
    00559             return true;
    00560         setErrorMsg(i18n("Unable to write driver associated files in spool directory."));
    00561     }
    00562     return false;
    00563 }
    00564
    00565 bool KMLpdManager::createPrinttoolEntry(KMPrinter *printer, PrintcapEntry *entry)
    00566 {
    00567     KURL    dev(printer->device());
    00568     QString prot = dev.protocol(), sd(entry->arg("sd"));
    00569     entry->m_comment = QString::fromLatin1("##PRINTTOOL3## %1").arg(ptPrinterType(printer));
    00570     if (prot == "smb" || prot == "ncp" || prot == "socket")
    00571     {
    00572         entry->m_args["af"] = sd+QString::fromLatin1("/acct");
    00573         QFile   f(sd+QString::fromLatin1("/.config"));
    00574         if (f.open(IO_WriteOnly))
    00575         {
    00576             QTextStream t(&f);
    00577             if (prot == "socket")
    00578             {
    00579                 t << "printer_ip=" << dev.host() << endl;
    00580                 t << "port=" << dev.port() << endl;
    00581                 entry->m_args["if"] = driverDirectory()+QString::fromLatin1("/directprint");
    00582             }
    00583             else if (prot == "smb")
    00584             {
    00585                 QStringList l = QStringList::split('/',dev.path(),false);
    00586                 if (l.count() == 2)
    00587                 {
    00588                     t << "share='\\\\" << l[0] << '\\' << l[1] << '\'' << endl;
    00589                 }
    00590                 else if (l.count() == 1)
    00591                 {
    00592                     t << "share='\\\\" << dev.host() << '\\' << l[0] << '\'' << endl;
    00593                 }
    00594                 t << "hostip=" << endl;
    00595                 t << "user='" << dev.user() << '\'' << endl;
    00596                 t << "password='" << dev.pass() << '\'' << endl;
    00597                 t << "workgroup='" << (l.count() == 2 ? dev.host() : QString::fromLatin1("")) << '\'' << endl;
    00598                 entry->m_args["if"] = driverDirectory()+QString::fromLatin1("/smbprint");
    00599             }
    00600             else if (prot == "ncp")
    00601             {
    00602                 t << "server=" << dev.host() << endl;
    00603                 t << "queue=" << dev.path().replace("/",QString::fromLatin1("")) << endl;
    00604                 t << "user=" << dev.user() << endl;
    00605                 t << "password=" << dev.pass() << endl;
    00606                 entry->m_args["if"] = driverDirectory()+QString::fromLatin1("/ncpprint");
    00607             }
    00608         }
    00609         else return false;
    00610         entry->m_args["lp"] = QString::fromLatin1("/dev/null");
    00611     }
    00612     else if (prot != "lpd")
    00613         entry->m_args["lp"] = dev.path();
    00614     return true;
    00615 }
    00616
    00617 bool KMLpdManager::createSpooldir(PrintcapEntry *entry)
    00618 {
    00619     // first check if it has a "sd" defined
    00620     if (entry->arg("sd").isEmpty())
    00621         entry->m_args["sd"] = QString::fromLatin1("/var/spool/lpd/")+entry->m_name;
    00622     QString sd = entry->arg("sd");
    00623     if (!KStandardDirs::exists(sd))
    00624     {
    00625         if (!KStandardDirs::makeDir(sd,0750))
    00626             return false;
    00627         struct passwd   *lp_pw = getpwnam("lp");
    00628         if (lp_pw && chown(QFile::encodeName(sd),lp_pw->pw_uid,lp_pw->pw_gid) != 0)
    00629             return false;
    00630     }
    00631     return true;
    00632 }
    00633
    00634 bool KMLpdManager::validateDbDriver(KMDBEntry *entry)
    00635 {
    00636     PrinttoolEntry  *ptentry = findPrinttoolEntry(entry->modelname);
    00637     return (ptentry && checkGsDriver(ptentry->m_gsdriver));
    00638 }
    00639
    00640 //************************************************************************************************
    00641
    00642 QString ptPrinterType(KMPrinter *p)
    00643 {
    00644     QString type, prot = p->device().protocol();
    00645     if (prot == "lpd") type = "REMOTE";
    00646     else if (prot == "smb") type = "SMB";
    00647     else if (prot == "ncp") type = "NCP";
    00648     else if (prot == "socket") type = "DIRECT";
    00649     else type = "LOCAL";
    00650     return type;
    00651 }

This file is part of the documentation for kdeprint Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:31:02 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003