/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * particular file as subject to the "Classpath" exception as provided

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 */

package sun.print;

import java.io.BufferedReader;

import java.io.FileInputStream;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Vector;

import java.security.AccessController;

import java.security.PrivilegedActionException;

import java.security.PrivilegedExceptionAction;

import javax.print.DocFlavor;

import javax.print.MultiDocPrintService;

import javax.print.PrintService;

import javax.print.PrintServiceLookup;

import javax.print.attribute.Attribute;

import javax.print.attribute.AttributeSet;

import javax.print.attribute.HashPrintRequestAttributeSet;

import javax.print.attribute.HashPrintServiceAttributeSet;

import javax.print.attribute.PrintRequestAttribute;

import javax.print.attribute.PrintRequestAttributeSet;

import javax.print.attribute.PrintServiceAttribute;

import javax.print.attribute.PrintServiceAttributeSet;

import javax.print.attribute.standard.PrinterName;

import java.io.File;

import java.io.FileReader;

import java.net.URL;

/*

 * Remind: This class uses solaris commands. We also need a linux

 * version

 */

public class UnixPrintServiceLookup extends PrintServiceLookup

    implements BackgroundServiceLookup, Runnable {

    /* Remind: the current implementation is static, as its assumed

     * its preferable to minimise creation of PrintService instances.

     * Later we should add logic to add/remove services on the fly which

     * will take a hit of needing to regather the list of services.

     */

    private String defaultPrinter;

    private PrintService defaultPrintService;

    private PrintService[] printServices; /* includes the default printer */

    private Vector lookupListeners = null;

    private static String debugPrefix = "UnixPrintServiceLookup>> ";

    private static boolean pollServices = true;

    private static final int DEFAULT_MINREFRESH = 120;  // 2 minutes

    private static int minRefreshTime = DEFAULT_MINREFRESH;

    static String osname;

    static {

        /* The system property "sun.java2d.print.polling"

         * can be used to force the printing code to poll or not poll

         * for PrintServices.

         */

        String pollStr = java.security.AccessController.doPrivileged(

            new sun.security.action.GetPropertyAction("sun.java2d.print.polling"));

        if (pollStr != null) {

            if (pollStr.equalsIgnoreCase("true")) {

                pollServices = true;

            } else if (pollStr.equalsIgnoreCase("false")) {

                pollServices = false;

            }

        }

        /* The system property "sun.java2d.print.minRefreshTime"

         * can be used to specify minimum refresh time (in seconds)

         * for polling PrintServices.  The default is 120.

         */

        String refreshTimeStr = java.security.AccessController.doPrivileged(

            new sun.security.action.GetPropertyAction(

                "sun.java2d.print.minRefreshTime"));

        if (refreshTimeStr != null) {

            try {

                minRefreshTime = (new Integer(refreshTimeStr)).intValue();

            } catch (NumberFormatException e) {

            }

            if (minRefreshTime < DEFAULT_MINREFRESH) {

                minRefreshTime = DEFAULT_MINREFRESH;

            }

        }

        osname = java.security.AccessController.doPrivileged(

            new sun.security.action.GetPropertyAction("os.name"));

    }

    static boolean isSysV() {

        return osname.equals("SunOS");

    }

    static boolean isBSD() {

        return osname.equals("Linux");

    }

    static final int UNINITIALIZED = -1;

    static final int BSD_LPD = 0;

    static final int BSD_LPD_NG = 1;

    static int cmdIndex = UNINITIALIZED;

    String[] lpcFirstCom = {

        "/usr/sbin/lpc status | grep : | sed -ne '1,1 s/://p'",

        "/usr/sbin/lpc status | grep -E '^[ 0-9a-zA-Z_-]*@' | awk -F'@' '{print $1}'"

    };

    String[] lpcAllCom = {

        "/usr/sbin/lpc status | grep : | sed -e 's/://'",

        "/usr/sbin/lpc -a status | grep -E '^[ 0-9a-zA-Z_-]*@' | awk -F'@' '{print $1}' | sort"

    };

    String[] lpcNameCom = {

        "| grep : | sed -ne 's/://p'",

        "| grep -E '^[ 0-9a-zA-Z_-]*@' | awk -F'@' '{print $1}'"

    };

    static int getBSDCommandIndex() {

        String command  = "/usr/sbin/lpc status";

        String[] names = execCmd(command);

        if ((names == null) || (names.length == 0)) {

            return BSD_LPD_NG;

        }

        for (int i=0; i<names.length; i++) {

            if (names[i].indexOf('@') != -1) {

                return BSD_LPD_NG;

            }

        }

        return BSD_LPD;

    }

    public UnixPrintServiceLookup() {

        // start the printer listener thread

        if (pollServices) {

            PrinterChangeListener thr = new PrinterChangeListener();

            thr.setDaemon(true);

            thr.start();

            IPPPrintService.debug_println(debugPrefix+"polling turned on");

        }

    }

    /* Want the PrintService which is default print service to have

     * equality of reference with the equivalent in list of print services

     * This isn't required by the API and there's a risk doing this will

     * lead people to assume its guaranteed.

     */

    public synchronized PrintService[] getPrintServices() {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkPrintJobAccess();

        }

        if (printServices == null || !pollServices) {

            refreshServices();

        }

        if (printServices == null) {

            return new PrintService[0];

        } else {

            return printServices;

        }

    }

    // refreshes "printServices"

    public synchronized void refreshServices() {

        /* excludes the default printer */

        String[] printers = null; // array of printer names

        String[] printerURIs = null; //array of printer URIs

        getDefaultPrintService();

        if (CUPSPrinter.isCupsRunning()) {

            printerURIs = CUPSPrinter.getAllPrinters();

            if ((printerURIs != null) && (printerURIs.length > 0)) {

                printers = new String[printerURIs.length];

                for (int i=0; i<printerURIs.length; i++) {

                    int lastIndex = printerURIs[i].lastIndexOf("/");

                    printers[i] = printerURIs[i].substring(lastIndex+1);

                }

            }

        } else {

            if (isSysV()) {

                printers = getAllPrinterNamesSysV();

            } else { //BSD

                printers = getAllPrinterNamesBSD();

            }

        }

        if (printers == null) {

            if (defaultPrintService != null) {

                printServices = new PrintService[1];

                printServices[0] = defaultPrintService;

            } else {

                printServices = null;

            }

            return;

        }

        ArrayList printerList = new ArrayList();

        int defaultIndex = -1;

        for (int p=0; p<printers.length; p++) {

            if (printers[p] == null) {

                continue;

            }

            if ((defaultPrintService != null)

                && printers[p].equals(defaultPrintService.getName())) {

                printerList.add(defaultPrintService);

                defaultIndex = printerList.size() - 1;

            } else {

                if (printServices == null) {

                    IPPPrintService.debug_println(debugPrefix+

                                                  "total# of printers = "+printers.length);

                    if (CUPSPrinter.isCupsRunning()) {

                        try {

                            printerList.add(new IPPPrintService(printers[p],

                                                                printerURIs[p],

                                                                true));

                        } catch (Exception e) {

                            IPPPrintService.debug_println(debugPrefix+

                                                          " getAllPrinters Exception "+

                                                          e);

                        }

                    } else {

                        printerList.add(new UnixPrintService(printers[p]));

                    }

                } else {

                    int j;

                    for (j=0; j<printServices.length; j++) {

                        if ((printServices[j] != null) &&

                            (printers[p].equals(printServices[j].getName()))) {

                            printerList.add(printServices[j]);

                            printServices[j] = null;

                            break;

                        }

                    }

                    if (j == printServices.length) {      // not found?

                        if (CUPSPrinter.isCupsRunning()) {

                            try {

                                printerList.add(new IPPPrintService(

                                                               printers[p],

                                                               printerURIs[p],

                                                               true));

                            } catch (Exception e) {

                                IPPPrintService.debug_println(debugPrefix+

                                                              " getAllPrinters Exception "+

                                                              e);

                            }

                        } else {

                            printerList.add(new UnixPrintService(printers[p]));

                        }

                    }

                }

            }

        }

        // Look for deleted services and invalidate these

        if (printServices != null) {

            for (int j=0; j < printServices.length; j++) {

                if ((printServices[j] instanceof UnixPrintService) &&

                    (!printServices[j].equals(defaultPrintService))) {

                    ((UnixPrintService)printServices[j]).invalidateService();

                }

            }

        }

        //if defaultService is not found in printerList

        if (defaultIndex == -1 && defaultPrintService != null) {

            //add default to the list

            printerList.add(defaultPrintService);

            defaultIndex = printerList.size() - 1;

        }

        printServices = (PrintService[])printerList.toArray(

                                      new PrintService[] {});

        // swap default with the first in the list

        if (defaultIndex > 0) {

            PrintService saveService = printServices[0];

            printServices[0] = printServices[defaultIndex];

            printServices[defaultIndex] = saveService;

        }

    }

    private boolean matchesAttributes(PrintService service,

                                      PrintServiceAttributeSet attributes) {

        Attribute [] attrs =  attributes.toArray();

        Attribute serviceAttr;

        for (int i=0; i<attrs.length; i++) {

            serviceAttr

                = service.getAttribute((Class<PrintServiceAttribute>)attrs[i].getCategory());

            if (serviceAttr == null || !serviceAttr.equals(attrs[i])) {

                return false;

            }

        }

        return true;

    }

      /* This checks for validity of the printer name before passing as

       * parameter to a shell command.

       */

      private boolean checkPrinterName(String s) {

        char c;

        for (int i=0; i < s.length(); i++) {

          c = s.charAt(i);

          if (Character.isLetterOrDigit(c) ||

              c == '-' || c == '_' || c == '.' || c == '/') {

            continue;

          } else {

            return false;

          }

        }

        return true;

      }

    /* On a network with many (hundreds) of network printers, it

     * can save several seconds if you know all you want is a particular

     * printer, to ask for that printer rather than retrieving all printers.

     */

    private PrintService getServiceByName(PrinterName nameAttr) {

        String name = nameAttr.getValue();

        PrintService printer = null;

        if (name == null || name.equals("") || !checkPrinterName(name)) {

            return null;

        }

        if (isSysV()) {

            printer = getNamedPrinterNameSysV(name);

        } else {

            printer = getNamedPrinterNameBSD(name);

        }

        return printer;

    }

    private PrintService[]

        getPrintServices(PrintServiceAttributeSet serviceSet) {

        if (serviceSet == null || serviceSet.isEmpty()) {

            return getPrintServices();

        }

        /* Typically expect that if a service attribute is specified that

         * its a printer name and there ought to be only one match.

         * Directly retrieve that service and confirm

         * that it meets the other requirements.

         * If printer name isn't mentioned then go a slow path checking

         * all printers if they meet the reqiremements.

         */

        PrintService[] services;

        PrinterName name = (PrinterName)serviceSet.get(PrinterName.class);

        PrintService defService;

        if (name != null && (defService = getDefaultPrintService()) != null) {

            /* To avoid execing a unix command  see if the client is asking

             * for the default printer by name, since we already have that

             * initialised.

             */

            PrinterName defName =

                (PrinterName)defService.getAttribute(PrinterName.class);

            if (defName != null && name.equals(defName)) {

                if (matchesAttributes(defService, serviceSet)) {

                    services = new PrintService[1];

                    services[0] = defService;

                    return services;

                } else {

                    return new PrintService[0];

                }

            } else {

                /* Its not the default service */

                PrintService service = getServiceByName(name);

                if (service != null &&

                    matchesAttributes(service, serviceSet)) {

                    services = new PrintService[1];

                    services[0] = service;

                    return services;

                } else {

                    return new PrintService[0];

                }

            }

        } else {

            /* specified service attributes don't include a name.*/

            Vector matchedServices = new Vector();

            services = getPrintServices();

            for (int i = 0; i< services.length; i++) {

                if (matchesAttributes(services[i], serviceSet)) {

                    matchedServices.add(services[i]);

                }

            }

            services = new PrintService[matchedServices.size()];

            for (int i = 0; i< services.length; i++) {

                services[i] = (PrintService)matchedServices.elementAt(i);

            }

            return services;

        }

    }

    /*

     * If service attributes are specified then there must be additional

     * filtering.

     */

    public PrintService[] getPrintServices(DocFlavor flavor,

                                           AttributeSet attributes) {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

          security.checkPrintJobAccess();

        }

        PrintRequestAttributeSet requestSet = null;

        PrintServiceAttributeSet serviceSet = null;

        if (attributes != null && !attributes.isEmpty()) {

            requestSet = new HashPrintRequestAttributeSet();

            serviceSet = new HashPrintServiceAttributeSet();

            Attribute[] attrs = attributes.toArray();

            for (int i=0; i<attrs.length; i++) {

                if (attrs[i] instanceof PrintRequestAttribute) {

                    requestSet.add(attrs[i]);

                } else if (attrs[i] instanceof PrintServiceAttribute) {

                    serviceSet.add(attrs[i]);

                }

            }

        }

        PrintService[] services = getPrintServices(serviceSet);

        if (services.length == 0) {

            return services;

        }

        if (CUPSPrinter.isCupsRunning()) {

            ArrayList matchingServices = new ArrayList();

            for (int i=0; i<services.length; i++) {

                try {

                    if (services[i].

                        getUnsupportedAttributes(flavor, requestSet) == null) {

                        matchingServices.add(services[i]);

                    }

                } catch (IllegalArgumentException e) {

                }

            }

            services = new PrintService[matchingServices.size()];

            return (PrintService[])matchingServices.toArray(services);

        } else {

            // We only need to compare 1 PrintService because all

            // UnixPrintServices are the same anyway.  We will not use

            // default PrintService because it might be null.

            PrintService service = services[0];

            if ((flavor == null ||

                 service.isDocFlavorSupported(flavor)) &&

                 service.getUnsupportedAttributes(flavor, requestSet) == null)

            {

                return services;

            } else {

                return new PrintService[0];

            }

        }

    }

    /*

     * return empty array as don't support multi docs

     */

    public MultiDocPrintService[]

        getMultiDocPrintServices(DocFlavor[] flavors,

                                 AttributeSet attributes) {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

          security.checkPrintJobAccess();

        }

        return new MultiDocPrintService[0];

    }

    public synchronized PrintService getDefaultPrintService() {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

          security.checkPrintJobAccess();

        }

        // clear defaultPrintService

        defaultPrintService = null;

        IPPPrintService.debug_println("isRunning ? "+

                                      (CUPSPrinter.isCupsRunning()));

        if (CUPSPrinter.isCupsRunning()) {

            defaultPrinter = CUPSPrinter.getDefaultPrinter();

        } else {

            if (isSysV()) {

                defaultPrinter = getDefaultPrinterNameSysV();