/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qprinterinfo.h"

#include <qfile.h>

#include <qfileinfo.h>

#include <qdir.h>

#include <qprintdialog.h>

#include <qlibrary.h>

#include <qtextstream.h>

#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)

#  include <private/qcups_p.h>

#  include <cups/cups.h>

#  include <private/qpdf_p.h>

#endif

#include <private/qprinterinfo_unix_p.h>

QT_BEGIN_NAMESPACE

#ifndef QT_NO_PRINTER

class QPrinterInfoPrivate

{

Q_DECLARE_PUBLIC(QPrinterInfo)

public:

    QPrinterInfoPrivate();

    QPrinterInfoPrivate(const QString& name);

    ~QPrinterInfoPrivate();

    static QPrinter::PaperSize string2PaperSize(const QString& str);

    static QString pageSize2String(QPrinter::PaperSize size);

private:

    QString                     m_name;

    bool                        m_isNull;

    bool                        m_default;

    QPrinterInfo*               q_ptr;

};

static QPrinterInfoPrivate nullQPrinterInfoPrivate;

class QPrinterInfoPrivateDeleter

{

public:

    static inline void cleanup(QPrinterInfoPrivate *d)

    {

        if (d != &nullQPrinterInfoPrivate)

            delete d;

    }

};

/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////

void qt_perhapsAddPrinter(QList<QPrinterDescription> *printers, const QString &name,

                               QString host, QString comment,

                               QStringList aliases)

{

    for (int i = 0; i < printers->size(); ++i)

        if (printers->at(i).samePrinter(name))

            return;

#ifndef QT_NO_PRINTDIALOG

    if (host.isEmpty())

        host = QPrintDialog::tr("locally connected");

#endif

    printers->append(QPrinterDescription(name.simplified(), host.simplified(), comment.simplified(), aliases));

}

void qt_parsePrinterDesc(QString printerDesc, QList<QPrinterDescription> *printers)

{

    if (printerDesc.length() < 1)

        return;

    printerDesc = printerDesc.simplified();

    int i = printerDesc.indexOf(QLatin1Char(':'));

    QString printerName, printerComment, printerHost;

    QStringList aliases;

    if (i >= 0) {

        // have ':' want '|'

        int j = printerDesc.indexOf(QLatin1Char('|'));

        if (j > 0 && j < i) {

            printerName = printerDesc.left(j);

            aliases = printerDesc.mid(j + 1, i - j - 1).split(QLatin1Char('|'));

#ifndef QT_NO_PRINTDIALOG

            // try extracting a comment from the aliases

            printerComment = QPrintDialog::tr("Aliases: %1")

                             .arg(aliases.join(QLatin1String(", ")));

#endif

        } else {

            printerName = printerDesc.left(i);

        }

        // look for lprng pseudo all printers entry

        i = printerDesc.indexOf(QRegExp(QLatin1String(": *all *=")));

        if (i >= 0)

            printerName = QString();

        // look for signs of this being a remote printer

        i = printerDesc.indexOf(QRegExp(QLatin1String(": *rm *=")));

        if (i >= 0) {

            // point k at the end of remote host name

            while (printerDesc[i] != QLatin1Char('='))

                i++;

            while (printerDesc[i] == QLatin1Char('=') || printerDesc[i].isSpace())

                i++;

            j = i;

            while (j < (int)printerDesc.length() && printerDesc[j] != QLatin1Char(':'))

                j++;

            // and stuff that into the string

            printerHost = printerDesc.mid(i, j - i);

        }

    }

    if (printerName.length())

        qt_perhapsAddPrinter(printers, printerName, printerHost, printerComment,

                             aliases);

}

int qt_parsePrintcap(QList<QPrinterDescription> *printers, const QString& fileName)

{

    QFile printcap(fileName);

    if (!printcap.open(QIODevice::ReadOnly))

        return NotFound;

    char *line_ascii = new char[1025];

    line_ascii[1024] = '\0';

    QString printerDesc;

    bool atEnd = false;

    while (!atEnd) {

        if (printcap.atEnd() || printcap.readLine(line_ascii, 1024) <= 0)

            atEnd = true;

        QString line = QString::fromLocal8Bit(line_ascii);

        line = line.trimmed();

        if (line.length() >= 1 && line[int(line.length()) - 1] == QLatin1Char('\\'))

            line.chop(1);

        if (line[0] == QLatin1Char('#')) {

            if (!atEnd)

                continue;

        } else if (line[0] == QLatin1Char('|') || line[0] == QLatin1Char(':')

                || line.isEmpty()) {

            printerDesc += line;

            if (!atEnd)

                continue;

        }

        qt_parsePrinterDesc(printerDesc, printers);

        // add the first line of the new printer definition

        printerDesc = line;

    }

    delete[] line_ascii;

    return Success;

}

/*!

  \internal

  Checks $HOME/.printers for a line matching '_default <name>' (where

  <name> does not contain any white space). The first such match

  results in <name> being returned.

  If no lines match then an empty string is returned.

*/

QString qt_getDefaultFromHomePrinters()

{

    QFile file(QDir::homePath() + QLatin1String("/.printers"));

    if (!file.open(QIODevice::ReadOnly))

        return QString();

    QString all(QLatin1String(file.readAll()));

    QStringList words = all.split(QRegExp(QLatin1String("\\W+")), QString::SkipEmptyParts);

    const int i = words.indexOf(QLatin1String("_default"));

    if (i != -1 && i < words.size() - 1)

        return words.at(i + 1);

    return QString();

}

// solaris, not 2.6

void qt_parseEtcLpPrinters(QList<QPrinterDescription> *printers)

{

    QDir lp(QLatin1String("/etc/lp/printers"));

    QFileInfoList dirs = lp.entryInfoList();

    if (dirs.isEmpty())

        return;

    QString tmp;

    for (int i = 0; i < dirs.size(); ++i) {

        QFileInfo printer = dirs.at(i);

        if (printer.isDir()) {

            tmp.sprintf("/etc/lp/printers/%s/configuration",

                         printer.fileName().toAscii().data());

            QFile configuration(tmp);

            char *line = new char[1025];

            QString remote(QLatin1String("Remote:"));

            QString contentType(QLatin1String("Content types:"));

            QString printerHost;

            bool canPrintPostscript = false;

            if (configuration.open(QIODevice::ReadOnly)) {

                while (!configuration.atEnd() &&

                        configuration.readLine(line, 1024) > 0) {

                    if (QString::fromLatin1(line).startsWith(remote)) {

                        const char *p = line;

                        while (*p != ':')

                            p++;

                        p++;

                        while (isspace((uchar) *p))

                            p++;

                        printerHost = QString::fromLocal8Bit(p);

                        printerHost = printerHost.simplified();

                    } else if (QString::fromLatin1(line).startsWith(contentType)) {

                        char *p = line;

                        while (*p != ':')

                            p++;

                        p++;

                        char *e;

                        while (*p) {

                            while (isspace((uchar) *p))

                                p++;

                            if (*p) {

                                char s;

                                e = p;

                                while (isalnum((uchar) *e))

                                    e++;

                                s = *e;

                                *e = '\0';

                                if (!qstrcmp(p, "postscript") ||

                                     !qstrcmp(p, "any"))

                                    canPrintPostscript = true;

                                *e = s;

                                if (s == ',')

                                    e++;

                                p = e;

                            }

                        }

                    }

                }

                if (canPrintPostscript)

                    qt_perhapsAddPrinter(printers, printer.fileName(),

                                         printerHost, QLatin1String(""));

            }

            delete[] line;

        }

    }

}

// solaris 2.6

char *qt_parsePrintersConf(QList<QPrinterDescription> *printers, bool *found)

{

    QFile pc(QLatin1String("/etc/printers.conf"));

    if (!pc.open(QIODevice::ReadOnly)) {

        if (found)

            *found = false;

        return 0;

    }

    if (found)

        *found = true;

    char *line = new char[1025];

    line[1024] = '\0';

    QString printerDesc;

    int lineLength = 0;

    char *defaultPrinter = 0;

    while (!pc.atEnd() &&

            (lineLength=pc.readLine(line, 1024)) > 0) {

        if (*line == '#') {

            *line = '\0';

            lineLength = 0;

        }

        if (lineLength >= 2 && line[lineLength-2] == '\\') {

            line[lineLength-2] = '\0';

            printerDesc += QString::fromLocal8Bit(line);

        } else {

            printerDesc += QString::fromLocal8Bit(line);

            printerDesc = printerDesc.simplified();

            int i = printerDesc.indexOf(QLatin1Char(':'));

            QString printerName, printerHost, printerComment;

            QStringList aliases;

            if (i >= 0) {

                // have : want |

                int j = printerDesc.indexOf(QLatin1Char('|'));

                if (j >= i)

                    j = -1;

                printerName = printerDesc.mid(0, j < 0 ? i : j);

                if (printerName == QLatin1String("_default")) {

                    i = printerDesc.indexOf(

                        QRegExp(QLatin1String(": *use *=")));

                    while (printerDesc[i] != QLatin1Char('='))

                        i++;

                    while (printerDesc[i] == QLatin1Char('=') || printerDesc[i].isSpace())

                        i++;

                    j = i;

                    while (j < (int)printerDesc.length() &&

                            printerDesc[j] != QLatin1Char(':') && printerDesc[j] != QLatin1Char(','))

                        j++;

                    // that's our default printer

                    defaultPrinter =

                        qstrdup(printerDesc.mid(i, j-i).toAscii().data());

                    printerName = QString();

                    printerDesc = QString();

                } else if (printerName == QLatin1String("_all")) {

                    // skip it.. any other cases we want to skip?

                    printerName = QString();

                    printerDesc = QString();

                }

                if (j > 0) {

                    // try extracting a comment from the aliases

                    aliases = printerDesc.mid(j + 1, i - j - 1).split(QLatin1Char('|'));

#ifndef QT_NO_PRINTDIALOG

                    printerComment = QPrintDialog::tr("Aliases: %1")

                                     .arg(aliases.join(QLatin1String(", ")));

#endif

                }

                // look for signs of this being a remote printer

                i = printerDesc.indexOf(

                    QRegExp(QLatin1String(": *bsdaddr *=")));

                if (i >= 0) {

                    // point k at the end of remote host name

                    while (printerDesc[i] != QLatin1Char('='))

                        i++;

                    while (printerDesc[i] == QLatin1Char('=') || printerDesc[i].isSpace())

                        i++;

                    j = i;

                    while (j < (int)printerDesc.length() &&

                            printerDesc[j] != QLatin1Char(':') && printerDesc[j] != QLatin1Char(','))

                        j++;

                    // and stuff that into the string

                    printerHost = printerDesc.mid(i, j-i);

                    // maybe stick the remote printer name into the comment

                    if (printerDesc[j] == QLatin1Char(',')) {

                        i = ++j;

                        while (printerDesc[i].isSpace())

                            i++;

                        j = i;

                        while (j < (int)printerDesc.length() &&

                                printerDesc[j] != QLatin1Char(':') && printerDesc[j] != QLatin1Char(','))

                            j++;

                        if (printerName != printerDesc.mid(i, j-i)) {

                            printerComment =

                                QLatin1String("Remote name: ");

                            printerComment += printerDesc.mid(i, j-i);

                        }

                    }

                }

            }

            if (printerComment == QLatin1String(":"))

                printerComment = QString(); // for cups

            if (printerName.length())

                qt_perhapsAddPrinter(printers, printerName, printerHost,

                                     printerComment, aliases);

            // chop away the line, for processing the next one

            printerDesc = QString();

        }

    }

    delete[] line;

    return defaultPrinter;

}

#ifndef QT_NO_NIS

#if defined(Q_C_CALLBACKS)

extern "C" {

#endif

int qt_pd_foreach(int /*status */, char * /*key */, int /*keyLen */,

                    char *val, int valLen, char *data)

{

    qt_parsePrinterDesc(QString::fromLatin1(val, valLen), (QList<QPrinterDescription> *)data);

    return 0;

}

#if defined(Q_C_CALLBACKS)

}

#endif

int qt_retrieveNisPrinters(QList<QPrinterDescription> *printers)

{

    typedef int (*WildCast)(int, char *, int, char *, int, char *);

    char printersConfByname[] = "printers.conf.byname";

    char *domain;

    int err;

    QLibrary lib(QLatin1String("nsl"));

    typedef int (*ypGetDefaultDomain)(char **);

    ypGetDefaultDomain _ypGetDefaultDomain = (ypGetDefaultDomain)lib.resolve("yp_get_default_domain");

    typedef int (*ypAll)(const char *, const char *, const struct ypall_callback *);

    ypAll _ypAll = (ypAll)lib.resolve("yp_all");

    if (_ypGetDefaultDomain && _ypAll) {

        err = _ypGetDefaultDomain(&domain);

        if (err == 0) {

            ypall_callback cb;

            // wild cast to support K&R-style system headers

            (WildCast &) cb.foreach = (WildCast) qt_pd_foreach;

            cb.data = (char *) printers;

            err = _ypAll(domain, printersConfByname, &cb);

        }

        if (!err)

            return Success;

    }

    return Unavail;

}

#endif // QT_NO_NIS

char *qt_parseNsswitchPrintersEntry(QList<QPrinterDescription> *printers, char *line)

{

#define skipSpaces() \

    while (line[k] != '\0' && isspace((uchar) line[k])) \

        k++

    char *defaultPrinter = 0;

    bool stop = false;

    int lastStatus = NotFound;

    int k = 8;

    skipSpaces();

    if (line[k] != ':')

        return 0;

    k++;

    char *cp = strchr(line, '#');

    if (cp != 0)

        *cp = '\0';

    while (line[k] != '\0') {

        if (isspace((uchar) line[k])) {

            k++;

        } else if (line[k] == '[') {

            k++;

            skipSpaces();

            while (line[k] != '\0') {

                char status = tolower(line[k]);

                char action = '?';

                while (line[k] != '=' && line[k] != ']' && line[k] != '\0')

                    k++;

                if (line[k] == '=') {

                    k++;

                    skipSpaces();

                    action = tolower(line[k]);

                    while (line[k] != '\0' && !isspace((uchar) line[k]) && line[k] != ']')

                        k++;

                } else if (line[k] == ']') {

                    k++;

                    break;

                }

                skipSpaces();

                if (lastStatus == status)

                    stop = (action == (char) Return);

            }

        } else {

            if (stop)

                break;

            QByteArray source;

            while (line[k] != '\0' && !isspace((uchar) line[k]) && line[k] != '[') {

                source += line[k];

                k++;

            }

            if (source == "user") {

                lastStatus = qt_parsePrintcap(printers,

                        QDir::homePath() + QLatin1String("/.printers"));

            } else if (source == "files") {

                bool found;

                defaultPrinter = qt_parsePrintersConf(printers, &found);

                if (found)

                    lastStatus = Success;

#ifndef QT_NO_NIS

            } else if (source == "nis") {

                lastStatus = qt_retrieveNisPrinters(printers);

#endif

            } else {

                // nisplus, dns, etc., are not implemented yet

                lastStatus = NotFound;