1 /*
   2  * Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package sun.print;
  27 
  28 import java.io.BufferedReader;
  29 import java.io.FileInputStream;
  30 import java.io.InputStream;
  31 import java.io.InputStreamReader;
  32 import java.io.IOException;
  33 import java.util.ArrayList;
  34 import java.util.Vector;
  35 import java.security.AccessController;
  36 import java.security.PrivilegedActionException;
  37 import java.security.PrivilegedExceptionAction;
  38 import javax.print.DocFlavor;
  39 import javax.print.MultiDocPrintService;
  40 import javax.print.PrintService;
  41 import javax.print.PrintServiceLookup;
  42 import javax.print.attribute.Attribute;
  43 import javax.print.attribute.AttributeSet;
  44 import javax.print.attribute.HashPrintRequestAttributeSet;
  45 import javax.print.attribute.HashPrintServiceAttributeSet;
  46 import javax.print.attribute.PrintRequestAttribute;
  47 import javax.print.attribute.PrintRequestAttributeSet;
  48 import javax.print.attribute.PrintServiceAttribute;
  49 import javax.print.attribute.PrintServiceAttributeSet;
  50 import javax.print.attribute.standard.PrinterName;
  51 import javax.print.attribute.standard.PrinterURI;
  52 import java.io.File;
  53 import java.io.FileReader;
  54 import java.net.URL;
  55 import java.nio.file.Files;
  56 
  57 /*
  58  * Remind: This class uses solaris commands. We also need a linux
  59  * version
  60  */
  61 public class UnixPrintServiceLookup extends PrintServiceLookup
  62     implements BackgroundServiceLookup, Runnable {
  63 
  64     /* Remind: the current implementation is static, as its assumed
  65      * its preferable to minimize creation of PrintService instances.
  66      * Later we should add logic to add/remove services on the fly which
  67      * will take a hit of needing to regather the list of services.
  68      */
  69     private String defaultPrinter;
  70     private PrintService defaultPrintService;
  71     private PrintService[] printServices; /* includes the default printer */
  72     private Vector lookupListeners = null;
  73     private static String debugPrefix = "UnixPrintServiceLookup>> ";
  74     private static boolean pollServices = true;
  75     private static final int DEFAULT_MINREFRESH = 120;  // 2 minutes
  76     private static int minRefreshTime = DEFAULT_MINREFRESH;
  77 
  78 
  79     static String osname;
  80 
  81     // List of commands used to deal with the printer queues on AIX
  82     String[] lpNameComAix = {
  83       "/usr/bin/lsallq",
  84       "/usr/bin/lpstat -W -p|/usr/bin/expand|/usr/bin/cut -f1 -d' '",
  85       "/usr/bin/lpstat -W -d|/usr/bin/expand|/usr/bin/cut -f1 -d' '",
  86       "/usr/bin/lpstat -W -v"
  87     };
  88     private static final int aix_lsallq = 0;
  89     private static final int aix_lpstat_p = 1;
  90     private static final int aix_lpstat_d = 2;
  91     private static final int aix_lpstat_v = 3;
  92     private static int aix_defaultPrinterEnumeration = aix_lsallq;
  93 
  94     static {
  95         /* The system property "sun.java2d.print.polling"
  96          * can be used to force the printing code to poll or not poll
  97          * for PrintServices.
  98          */
  99         String pollStr = java.security.AccessController.doPrivileged(
 100             new sun.security.action.GetPropertyAction("sun.java2d.print.polling"));
 101 
 102         if (pollStr != null) {
 103             if (pollStr.equalsIgnoreCase("true")) {
 104                 pollServices = true;
 105             } else if (pollStr.equalsIgnoreCase("false")) {
 106                 pollServices = false;
 107             }
 108         }
 109 
 110         /* The system property "sun.java2d.print.minRefreshTime"
 111          * can be used to specify minimum refresh time (in seconds)
 112          * for polling PrintServices.  The default is 120.
 113          */
 114         String refreshTimeStr = java.security.AccessController.doPrivileged(
 115             new sun.security.action.GetPropertyAction(
 116                 "sun.java2d.print.minRefreshTime"));
 117 
 118         if (refreshTimeStr != null) {
 119             try {
 120                 minRefreshTime = (new Integer(refreshTimeStr)).intValue();
 121             } catch (NumberFormatException e) {
 122             }
 123             if (minRefreshTime < DEFAULT_MINREFRESH) {
 124                 minRefreshTime = DEFAULT_MINREFRESH;
 125             }
 126         }
 127 
 128         osname = java.security.AccessController.doPrivileged(
 129             new sun.security.action.GetPropertyAction("os.name"));
 130 
 131         /* The system property "sun.java2d.print.aix.lpstat"
 132          * can be used to force the usage of 'lpstat -p' to enumerate all
 133          * printer queues. By default we use 'lsallq', because 'lpstat -p' can
 134          * take lots of time if thousands of printers are attached to a server.
 135          */
 136         if (isAIX()) {
 137             String aixPrinterEnumerator = java.security.AccessController.doPrivileged(
 138                 new sun.security.action.GetPropertyAction("sun.java2d.print.aix.lpstat"));
 139 
 140             if (aixPrinterEnumerator != null) {
 141                 if (aixPrinterEnumerator.equalsIgnoreCase("lpstat")) {
 142                     aix_defaultPrinterEnumeration = aix_lpstat_p;
 143                 } else if (aixPrinterEnumerator.equalsIgnoreCase("lsallq")) {
 144                     aix_defaultPrinterEnumeration = aix_lsallq;
 145                 }
 146             }
 147         }
 148     }
 149 
 150     static boolean isMac() {
 151         return osname.startsWith("Mac");
 152     }
 153 
 154     static boolean isSysV() {
 155         return osname.equals("SunOS");
 156     }
 157 
 158     static boolean isLinux() {
 159         return (osname.equals("Linux"));
 160     }
 161 
 162     static boolean isBSD() {
 163         return (osname.equals("Linux") ||
 164                 osname.contains("OS X"));
 165     }
 166 
 167     static boolean isAIX() {
 168         return osname.equals("AIX");
 169     }
 170 
 171     static final int UNINITIALIZED = -1;
 172     static final int BSD_LPD = 0;
 173     static final int BSD_LPD_NG = 1;
 174 
 175     static int cmdIndex = UNINITIALIZED;
 176 
 177     String[] lpcFirstCom = {
 178         "/usr/sbin/lpc status | grep : | sed -ne '1,1 s/://p'",
 179         "/usr/sbin/lpc status | grep -E '^[ 0-9a-zA-Z_-]*@' | awk -F'@' '{print $1}'"
 180     };
 181 
 182     String[] lpcAllCom = {
 183         "/usr/sbin/lpc status all | grep : | sed -e 's/://'",
 184         "/usr/sbin/lpc status all | grep -E '^[ 0-9a-zA-Z_-]*@' | awk -F'@' '{print $1}' | sort"
 185     };
 186 
 187     String[] lpcNameCom = {
 188         "| grep : | sed -ne 's/://p'",
 189         "| grep -E '^[ 0-9a-zA-Z_-]*@' | awk -F'@' '{print $1}'"
 190     };
 191 
 192 
 193     static int getBSDCommandIndex() {
 194         String command  = "/usr/sbin/lpc status all";
 195         String[] names = execCmd(command);
 196 
 197         if ((names == null) || (names.length == 0)) {
 198             return BSD_LPD_NG;
 199         }
 200 
 201         for (int i=0; i<names.length; i++) {
 202             if (names[i].indexOf('@') != -1) {
 203                 return BSD_LPD_NG;
 204             }
 205         }
 206 
 207         return BSD_LPD;
 208     }
 209 
 210 
 211     public UnixPrintServiceLookup() {
 212         // start the printer listener thread
 213         if (pollServices) {
 214             PrinterChangeListener thr = new PrinterChangeListener();
 215             thr.setDaemon(true);
 216             thr.start();
 217             IPPPrintService.debug_println(debugPrefix+"polling turned on");
 218         }
 219     }
 220 
 221     /* Want the PrintService which is default print service to have
 222      * equality of reference with the equivalent in list of print services
 223      * This isn't required by the API and there's a risk doing this will
 224      * lead people to assume its guaranteed.
 225      */
 226     public synchronized PrintService[] getPrintServices() {
 227         SecurityManager security = System.getSecurityManager();
 228         if (security != null) {
 229             security.checkPrintJobAccess();
 230         }
 231 
 232         if (printServices == null || !pollServices) {
 233             refreshServices();
 234         }
 235         if (printServices == null) {
 236             return new PrintService[0];
 237         } else {
 238             return printServices.clone();
 239         }
 240     }
 241 
 242     private int addPrintServiceToList(ArrayList printerList, PrintService ps) {
 243         int index = printerList.indexOf(ps);
 244         // Check if PrintService with same name is already in the list.
 245         if (CUPSPrinter.isCupsRunning() && index != -1) {
 246             // Bug in Linux: Duplicate entry of a remote printer
 247             // and treats it as local printer but it is returning wrong
 248             // information when queried using IPP. Workaround is to remove it.
 249             // Even CUPS ignores these entries as shown in lpstat or using
 250             // their web configuration.
 251             PrinterURI uri = ps.getAttribute(PrinterURI.class);
 252             if (uri.getURI().getHost().equals("localhost")) {
 253                 IPPPrintService.debug_println(debugPrefix+"duplicate PrintService, ignoring the new local printer: "+ps);
 254                 return index;  // Do not add this.
 255             }
 256             PrintService oldPS = (PrintService)(printerList.get(index));
 257             uri = oldPS.getAttribute(PrinterURI.class);
 258             if (uri.getURI().getHost().equals("localhost")) {
 259                 IPPPrintService.debug_println(debugPrefix+"duplicate PrintService, removing existing local printer: "+oldPS);
 260                 printerList.remove(oldPS);
 261             } else {
 262                 return index;
 263             }
 264         }
 265         printerList.add(ps);
 266         return (printerList.size() - 1);
 267     }
 268 
 269 
 270     // refreshes "printServices"
 271     public synchronized void refreshServices() {
 272         /* excludes the default printer */
 273         String[] printers = null; // array of printer names
 274         String[] printerURIs = null; //array of printer URIs
 275 
 276         try {
 277             getDefaultPrintService();
 278         } catch (Throwable t) {
 279             IPPPrintService.debug_println(debugPrefix+
 280               "Exception getting default printer : " + t);
 281         }
 282         if (CUPSPrinter.isCupsRunning()) {
 283             try {
 284                 printerURIs = CUPSPrinter.getAllPrinters();
 285                 IPPPrintService.debug_println("CUPS URIs = " + printerURIs);
 286                 if (printerURIs != null) {
 287                     for (int p = 0; p < printerURIs.length; p++) {
 288                        IPPPrintService.debug_println("URI="+printerURIs[p]);
 289                     }
 290                 }
 291             } catch (Throwable t) {
 292             IPPPrintService.debug_println(debugPrefix+
 293               "Exception getting all CUPS printers : " + t);
 294             }
 295             if ((printerURIs != null) && (printerURIs.length > 0)) {
 296                 printers = new String[printerURIs.length];
 297                 for (int i=0; i<printerURIs.length; i++) {
 298                     int lastIndex = printerURIs[i].lastIndexOf("/");
 299                     printers[i] = printerURIs[i].substring(lastIndex+1);
 300                 }
 301             }
 302         } else {
 303             if (isMac() || isSysV()) {
 304                 printers = getAllPrinterNamesSysV();
 305             } else if (isAIX()) {
 306                 printers = getAllPrinterNamesAIX();
 307             } else { //BSD
 308                 printers = getAllPrinterNamesBSD();
 309             }
 310         }
 311 
 312         if (printers == null) {
 313             if (defaultPrintService != null) {
 314                 printServices = new PrintService[1];
 315                 printServices[0] = defaultPrintService;
 316             } else {
 317                 printServices = null;
 318             }
 319             return;
 320         }
 321 
 322         ArrayList printerList = new ArrayList();
 323         int defaultIndex = -1;
 324         for (int p=0; p<printers.length; p++) {
 325             if (printers[p] == null) {
 326                 continue;
 327             }
 328             if ((defaultPrintService != null)
 329                 && printers[p].equals(getPrinterDestName(defaultPrintService))) {
 330                 defaultIndex = addPrintServiceToList(printerList, defaultPrintService);
 331             } else {
 332                 if (printServices == null) {
 333                     IPPPrintService.debug_println(debugPrefix+
 334                                                   "total# of printers = "+printers.length);
 335 
 336                     if (CUPSPrinter.isCupsRunning()) {
 337                         try {
 338                             addPrintServiceToList(printerList,
 339                                                   new IPPPrintService(printers[p],
 340                                                                    printerURIs[p],
 341                                                                    true));
 342                         } catch (Exception e) {
 343                             IPPPrintService.debug_println(debugPrefix+
 344                                                           " getAllPrinters Exception "+
 345                                                           e);
 346 
 347                         }
 348                     } else {
 349                         printerList.add(new UnixPrintService(printers[p]));
 350                     }
 351                 } else {
 352                     int j;
 353                     for (j=0; j<printServices.length; j++) {
 354                         if (printServices[j] != null) {
 355                             if (printers[p].equals(getPrinterDestName(printServices[j]))) {
 356                                 printerList.add(printServices[j]);
 357                                 printServices[j] = null;
 358                                 break;
 359                             }
 360                         }
 361                     }
 362 
 363                     if (j == printServices.length) {      // not found?
 364                         if (CUPSPrinter.isCupsRunning()) {
 365                             try {
 366                                 addPrintServiceToList(printerList,
 367                                              new IPPPrintService(printers[p],
 368                                                                  printerURIs[p],
 369                                                                  true));
 370                             } catch (Exception e) {
 371                                 IPPPrintService.debug_println(debugPrefix+
 372                                                               " getAllPrinters Exception "+
 373                                                               e);
 374 
 375                             }
 376                         } else {
 377                             printerList.add(new UnixPrintService(printers[p]));
 378                         }
 379                     }
 380                 }
 381             }
 382         }
 383 
 384         // Look for deleted services and invalidate these
 385         if (printServices != null) {
 386             for (int j=0; j < printServices.length; j++) {
 387                 if ((printServices[j] instanceof UnixPrintService) &&
 388                     (!printServices[j].equals(defaultPrintService))) {
 389                     ((UnixPrintService)printServices[j]).invalidateService();
 390                 }
 391             }
 392         }
 393 
 394         //if defaultService is not found in printerList
 395         if (defaultIndex == -1 && defaultPrintService != null) {
 396             defaultIndex = addPrintServiceToList(printerList, defaultPrintService);
 397         }
 398 
 399         printServices = (PrintService[])printerList.toArray(
 400                                       new PrintService[] {});
 401 
 402         // swap default with the first in the list
 403         if (defaultIndex > 0) {
 404             PrintService saveService = printServices[0];
 405             printServices[0] = printServices[defaultIndex];
 406             printServices[defaultIndex] = saveService;
 407         }
 408     }
 409 
 410     private boolean matchesAttributes(PrintService service,
 411                                       PrintServiceAttributeSet attributes) {
 412 
 413         Attribute [] attrs =  attributes.toArray();
 414         Attribute serviceAttr;
 415         for (int i=0; i<attrs.length; i++) {
 416             serviceAttr
 417                 = service.getAttribute((Class<PrintServiceAttribute>)attrs[i].getCategory());
 418             if (serviceAttr == null || !serviceAttr.equals(attrs[i])) {
 419                 return false;
 420             }
 421         }
 422         return true;
 423     }
 424 
 425       /* This checks for validity of the printer name before passing as
 426        * parameter to a shell command.
 427        */
 428       private boolean checkPrinterName(String s) {
 429         char c;
 430 
 431         for (int i=0; i < s.length(); i++) {
 432           c = s.charAt(i);
 433           if (Character.isLetterOrDigit(c) ||
 434               c == '-' || c == '_' || c == '.' || c == '/') {
 435             continue;
 436           } else {
 437             return false;
 438           }
 439         }
 440         return true;
 441       }
 442 
 443     /*
 444      * Gets the printer name compatible with the list of printers returned by
 445      * the system when we query default or all the available printers.
 446      */
 447     private String getPrinterDestName(PrintService ps) {
 448         if (isMac()) {
 449             return ((IPPPrintService)ps).getDest();
 450         }
 451         return ps.getName();
 452     }
 453 
 454     /* On a network with many (hundreds) of network printers, it
 455      * can save several seconds if you know all you want is a particular
 456      * printer, to ask for that printer rather than retrieving all printers.
 457      */
 458     private PrintService getServiceByName(PrinterName nameAttr) {
 459         String name = nameAttr.getValue();
 460         if (name == null || name.equals("") || !checkPrinterName(name)) {
 461             return null;
 462         }
 463         /* check if all printers are already available */
 464         if (printServices != null) {
 465             for (PrintService printService : printServices) {
 466                 PrinterName printerName = printService.getAttribute(PrinterName.class);
 467                 if (printerName.getValue().equals(name)) {
 468                     return printService;
 469                 }
 470             }
 471         }
 472         /* take CUPS into account first */
 473         if (CUPSPrinter.isCupsRunning()) {
 474             try {
 475                 return new IPPPrintService(name,
 476                                            new URL("http://"+
 477                                                    CUPSPrinter.getServer()+":"+
 478                                                    CUPSPrinter.getPort()+"/"+
 479                                                    name));
 480             } catch (Exception e) {
 481                 IPPPrintService.debug_println(debugPrefix+
 482                                               " getServiceByName Exception "+
 483                                               e);
 484             }
 485         }
 486         /* fallback if nothing not having a printer at this point */
 487         PrintService printer = null;
 488         if (isMac() || isSysV()) {
 489             printer = getNamedPrinterNameSysV(name);
 490         } else if (isAIX()) {
 491             printer = getNamedPrinterNameAIX(name);
 492         } else {
 493             printer = getNamedPrinterNameBSD(name);
 494         }
 495         return printer;
 496     }
 497 
 498     private PrintService[]
 499         getPrintServices(PrintServiceAttributeSet serviceSet) {
 500 
 501         if (serviceSet == null || serviceSet.isEmpty()) {
 502             return getPrintServices();
 503         }
 504 
 505         /* Typically expect that if a service attribute is specified that
 506          * its a printer name and there ought to be only one match.
 507          * Directly retrieve that service and confirm
 508          * that it meets the other requirements.
 509          * If printer name isn't mentioned then go a slow path checking
 510          * all printers if they meet the reqiremements.
 511          */
 512         PrintService[] services;
 513         PrinterName name = (PrinterName)serviceSet.get(PrinterName.class);
 514         PrintService defService;
 515         if (name != null && (defService = getDefaultPrintService()) != null) {
 516             /* To avoid execing a unix command  see if the client is asking
 517              * for the default printer by name, since we already have that
 518              * initialised.
 519              */
 520 
 521             PrinterName defName = defService.getAttribute(PrinterName.class);
 522 
 523             if (defName != null && name.equals(defName)) {
 524                 if (matchesAttributes(defService, serviceSet)) {
 525                     services = new PrintService[1];
 526                     services[0] = defService;
 527                     return services;
 528                 } else {
 529                     return new PrintService[0];
 530                 }
 531             } else {
 532                 /* Its not the default service */
 533                 PrintService service = getServiceByName(name);
 534                 if (service != null &&
 535                     matchesAttributes(service, serviceSet)) {
 536                     services = new PrintService[1];
 537                     services[0] = service;
 538                     return services;
 539                 } else {
 540                     return new PrintService[0];
 541                 }
 542             }
 543         } else {
 544             /* specified service attributes don't include a name.*/
 545             Vector matchedServices = new Vector();
 546             services = getPrintServices();
 547             for (int i = 0; i< services.length; i++) {
 548                 if (matchesAttributes(services[i], serviceSet)) {
 549                     matchedServices.add(services[i]);
 550                 }
 551             }
 552             services = new PrintService[matchedServices.size()];
 553             for (int i = 0; i< services.length; i++) {
 554                 services[i] = (PrintService)matchedServices.elementAt(i);
 555             }
 556             return services;
 557         }
 558     }
 559 
 560     /*
 561      * If service attributes are specified then there must be additional
 562      * filtering.
 563      */
 564     public PrintService[] getPrintServices(DocFlavor flavor,
 565                                            AttributeSet attributes) {
 566         SecurityManager security = System.getSecurityManager();
 567         if (security != null) {
 568           security.checkPrintJobAccess();
 569         }
 570         PrintRequestAttributeSet requestSet = null;
 571         PrintServiceAttributeSet serviceSet = null;
 572 
 573         if (attributes != null && !attributes.isEmpty()) {
 574 
 575             requestSet = new HashPrintRequestAttributeSet();
 576             serviceSet = new HashPrintServiceAttributeSet();
 577 
 578             Attribute[] attrs = attributes.toArray();
 579             for (int i=0; i<attrs.length; i++) {
 580                 if (attrs[i] instanceof PrintRequestAttribute) {
 581                     requestSet.add(attrs[i]);
 582                 } else if (attrs[i] instanceof PrintServiceAttribute) {
 583                     serviceSet.add(attrs[i]);
 584                 }
 585             }
 586         }
 587 
 588         PrintService[] services = getPrintServices(serviceSet);
 589         if (services.length == 0) {
 590             return services;
 591         }
 592 
 593         if (CUPSPrinter.isCupsRunning()) {
 594             ArrayList matchingServices = new ArrayList();
 595             for (int i=0; i<services.length; i++) {
 596                 try {
 597                     if (services[i].
 598                         getUnsupportedAttributes(flavor, requestSet) == null) {
 599                         matchingServices.add(services[i]);
 600                     }
 601                 } catch (IllegalArgumentException e) {
 602                 }
 603             }
 604             services = new PrintService[matchingServices.size()];
 605             return (PrintService[])matchingServices.toArray(services);
 606 
 607         } else {
 608             // We only need to compare 1 PrintService because all
 609             // UnixPrintServices are the same anyway.  We will not use
 610             // default PrintService because it might be null.
 611             PrintService service = services[0];
 612             if ((flavor == null ||
 613                  service.isDocFlavorSupported(flavor)) &&
 614                  service.getUnsupportedAttributes(flavor, requestSet) == null)
 615             {
 616                 return services;
 617             } else {
 618                 return new PrintService[0];
 619             }
 620         }
 621     }
 622 
 623     /*
 624      * return empty array as don't support multi docs
 625      */
 626     public MultiDocPrintService[]
 627         getMultiDocPrintServices(DocFlavor[] flavors,
 628                                  AttributeSet attributes) {
 629         SecurityManager security = System.getSecurityManager();
 630         if (security != null) {
 631           security.checkPrintJobAccess();
 632         }
 633         return new MultiDocPrintService[0];
 634     }
 635 
 636 
 637     public synchronized PrintService getDefaultPrintService() {
 638         SecurityManager security = System.getSecurityManager();
 639         if (security != null) {
 640           security.checkPrintJobAccess();
 641         }
 642 
 643         // clear defaultPrintService
 644         defaultPrintService = null;
 645         String psuri = null;
 646 
 647         IPPPrintService.debug_println("isRunning ? "+
 648                                       (CUPSPrinter.isCupsRunning()));
 649         if (CUPSPrinter.isCupsRunning()) {
 650             String[] printerInfo = CUPSPrinter.getDefaultPrinter();
 651             if (printerInfo != null && printerInfo.length >= 2) {
 652                 defaultPrinter = printerInfo[0];
 653                 psuri = printerInfo[1];
 654             }
 655         } else {
 656             if (isMac() || isSysV()) {
 657                 defaultPrinter = getDefaultPrinterNameSysV();
 658             } else if (isAIX()) {
 659                 defaultPrinter = getDefaultPrinterNameAIX();
 660             } else {
 661                 defaultPrinter = getDefaultPrinterNameBSD();
 662             }
 663         }
 664         if (defaultPrinter == null) {
 665             return null;
 666         }
 667         defaultPrintService = null;
 668         if (printServices != null) {
 669             for (int j=0; j<printServices.length; j++) {
 670                 if (defaultPrinter.equals(getPrinterDestName(printServices[j]))) {
 671                     defaultPrintService = printServices[j];
 672                     break;
 673                 }
 674             }
 675         }
 676         if (defaultPrintService == null) {
 677             if (CUPSPrinter.isCupsRunning()) {
 678                 try {
 679                     PrintService defaultPS;
 680                     if ((psuri != null) && !psuri.startsWith("file")) {
 681                         defaultPS = new IPPPrintService(defaultPrinter,
 682                                                         psuri, true);
 683                     } else {
 684                         defaultPS = new IPPPrintService(defaultPrinter,
 685                                             new URL("http://"+
 686                                                     CUPSPrinter.getServer()+":"+
 687                                                     CUPSPrinter.getPort()+"/"+
 688                                                     defaultPrinter));
 689                     }
 690                     defaultPrintService = defaultPS;
 691                 } catch (Exception e) {
 692                 }
 693             } else {
 694                 defaultPrintService = new UnixPrintService(defaultPrinter);
 695             }
 696         }
 697 
 698         return defaultPrintService;
 699     }
 700 
 701     public synchronized void
 702         getServicesInbackground(BackgroundLookupListener listener) {
 703         if (printServices != null) {
 704             listener.notifyServices(printServices);
 705         } else {
 706             if (lookupListeners == null) {
 707                 lookupListeners = new Vector();
 708                 lookupListeners.add(listener);
 709                 Thread lookupThread = new Thread(this);
 710                 lookupThread.start();
 711             } else {
 712                 lookupListeners.add(listener);
 713             }
 714         }
 715     }
 716 
 717     /* This method isn't used in most cases because we rely on code in
 718      * javax.print.PrintServiceLookup. This is needed just for the cases
 719      * where those interfaces are by-passed.
 720      */
 721     private PrintService[] copyOf(PrintService[] inArr) {
 722         if (inArr == null || inArr.length == 0) {
 723             return inArr;
 724         } else {
 725             PrintService []outArr = new PrintService[inArr.length];
 726             System.arraycopy(inArr, 0, outArr, 0, inArr.length);
 727             return outArr;
 728         }
 729     }
 730 
 731     public void run() {
 732         PrintService[] services = getPrintServices();
 733         synchronized (this) {
 734             BackgroundLookupListener listener;
 735             for (int i=0; i<lookupListeners.size(); i++) {
 736                 listener =
 737                     (BackgroundLookupListener)lookupListeners.elementAt(i);
 738                 listener.notifyServices(copyOf(services));
 739             }
 740             lookupListeners = null;
 741         }
 742     }
 743 
 744     private String getDefaultPrinterNameBSD() {
 745         if (cmdIndex == UNINITIALIZED) {
 746             cmdIndex = getBSDCommandIndex();
 747         }
 748         String[] names = execCmd(lpcFirstCom[cmdIndex]);
 749         if (names == null || names.length == 0) {
 750             return null;
 751         }
 752 
 753         if ((cmdIndex==BSD_LPD_NG) &&
 754             (names[0].startsWith("missingprinter"))) {
 755             return null;
 756         }
 757         return names[0];
 758     }
 759 
 760     private PrintService getNamedPrinterNameBSD(String name) {
 761       if (cmdIndex == UNINITIALIZED) {
 762         cmdIndex = getBSDCommandIndex();
 763       }
 764       String command = "/usr/sbin/lpc status " + name + lpcNameCom[cmdIndex];
 765       String[] result = execCmd(command);
 766 
 767       if (result == null || !(result[0].equals(name))) {
 768           return null;
 769       }
 770       return new UnixPrintService(name);
 771     }
 772 
 773     private String[] getAllPrinterNamesBSD() {
 774         if (cmdIndex == UNINITIALIZED) {
 775             cmdIndex = getBSDCommandIndex();
 776         }
 777         String[] names = execCmd(lpcAllCom[cmdIndex]);
 778         if (names == null || names.length == 0) {
 779           return null;
 780         }
 781         return names;
 782     }
 783 
 784     static String getDefaultPrinterNameSysV() {
 785         String defaultPrinter = "lp";
 786         String command = "/usr/bin/lpstat -d";
 787 
 788         String [] names = execCmd(command);
 789         if (names == null || names.length == 0) {
 790             return defaultPrinter;
 791         } else {
 792             int index = names[0].indexOf(":");
 793             if (index == -1  || (names[0].length() <= index+1)) {
 794                 return null;
 795             } else {
 796                 String name = names[0].substring(index+1).trim();
 797                 if (name.length() == 0) {
 798                     return null;
 799                 } else {
 800                     return name;
 801                 }
 802             }
 803         }
 804     }
 805 
 806     private PrintService getNamedPrinterNameSysV(String name) {
 807 
 808         String command = "/usr/bin/lpstat -v " + name;
 809         String []result = execCmd(command);
 810 
 811         if (result == null || result[0].indexOf("unknown printer") > 0) {
 812             return null;
 813         } else {
 814             return new UnixPrintService(name);
 815         }
 816     }
 817 
 818     private String[] getAllPrinterNamesSysV() {
 819         String defaultPrinter = "lp";
 820         String command = "/usr/bin/lpstat -v|/usr/bin/expand|/usr/bin/cut -f3 -d' ' |/usr/bin/cut -f1 -d':' | /usr/bin/sort";
 821 
 822         String [] names = execCmd(command);
 823         ArrayList printerNames = new ArrayList();
 824         for (int i=0; i < names.length; i++) {
 825             if (!names[i].equals("_default") &&
 826                 !names[i].equals(defaultPrinter) &&
 827                 !names[i].equals("")) {
 828                 printerNames.add(names[i]);
 829             }
 830         }
 831         return (String[])printerNames.toArray(new String[printerNames.size()]);
 832     }
 833 
 834     private String getDefaultPrinterNameAIX() {
 835         String[] names = execCmd(lpNameComAix[aix_lpstat_d]);
 836         // Remove headers and bogus entries added by remote printers.
 837         names = UnixPrintService.filterPrinterNamesAIX(names);
 838         if (names == null || names.length != 1) {
 839             // No default printer found
 840             return null;
 841         } else {
 842             return names[0];
 843         }
 844     }
 845 
 846     private PrintService getNamedPrinterNameAIX(String name) {
 847         // On AIX there should be no blank after '-v'.
 848         String[] result = execCmd(lpNameComAix[aix_lpstat_v] + name);
 849         // Remove headers and bogus entries added by remote printers.
 850         result = UnixPrintService.filterPrinterNamesAIX(result);
 851         if (result == null || result.length != 1) {
 852             return null;
 853         } else {
 854             return new UnixPrintService(name);
 855         }
 856     }
 857 
 858     private String[] getAllPrinterNamesAIX() {
 859         // Determine all printers of the system.
 860         String [] names = execCmd(lpNameComAix[aix_defaultPrinterEnumeration]);
 861 
 862         // Remove headers and bogus entries added by remote printers.
 863         names = UnixPrintService.filterPrinterNamesAIX(names);
 864 
 865         ArrayList<String> printerNames = new ArrayList<String>();
 866         for ( int i=0; i < names.length; i++) {
 867             printerNames.add(names[i]);
 868         }
 869         return printerNames.toArray(new String[printerNames.size()]);
 870     }
 871 
 872     static String[] execCmd(final String command) {
 873         ArrayList results = null;
 874         try {
 875             final String[] cmd = new String[3];
 876             if (isSysV() || isAIX()) {
 877                 cmd[0] = "/usr/bin/sh";
 878                 cmd[1] = "-c";
 879                 cmd[2] = "env LC_ALL=C " + command;
 880             } else {
 881                 cmd[0] = "/bin/sh";
 882                 cmd[1] = "-c";
 883                 cmd[2] = "LC_ALL=C " + command;
 884             }
 885 
 886             results = (ArrayList)AccessController.doPrivileged(
 887                 new PrivilegedExceptionAction() {
 888                     public Object run() throws IOException {
 889 
 890                         Process proc;
 891                         BufferedReader bufferedReader = null;
 892                         File f = Files.createTempFile("prn","xc").toFile();
 893                         cmd[2] = cmd[2]+">"+f.getAbsolutePath();
 894 
 895                         proc = Runtime.getRuntime().exec(cmd);
 896                         try {
 897                             boolean done = false; // in case of interrupt.
 898                             while (!done) {
 899                                 try {
 900                                     proc.waitFor();
 901                                     done = true;
 902                                 } catch (InterruptedException e) {
 903                                 }
 904                             }
 905 
 906                             if (proc.exitValue() == 0) {
 907                                 FileReader reader = new FileReader(f);
 908                                 bufferedReader = new BufferedReader(reader);
 909                                 String line;
 910                                 ArrayList results = new ArrayList();
 911                                 while ((line = bufferedReader.readLine())
 912                                        != null) {
 913                                     results.add(line);
 914                                 }
 915                                 return results;
 916                             }
 917                         } finally {
 918                             f.delete();
 919                             // promptly close all streams.
 920                             if (bufferedReader != null) {
 921                                 bufferedReader.close();
 922                             }
 923                             proc.getInputStream().close();
 924                             proc.getErrorStream().close();
 925                             proc.getOutputStream().close();
 926                         }
 927                         return null;
 928                     }
 929                 });
 930         } catch (PrivilegedActionException e) {
 931         }
 932         if (results == null) {
 933             return new String[0];
 934         } else {
 935             return (String[])results.toArray(new String[results.size()]);
 936         }
 937     }
 938 
 939     private class PrinterChangeListener extends Thread {
 940 
 941         public void run() {
 942             int refreshSecs;
 943             while (true) {
 944                 try {
 945                     refreshServices();
 946                 } catch (Exception se) {
 947                     IPPPrintService.debug_println(debugPrefix+"Exception in refresh thread.");
 948                     break;
 949                 }
 950 
 951                 if ((printServices != null) &&
 952                     (printServices.length > minRefreshTime)) {
 953                     // compute new refresh time 1 printer = 1 sec
 954                     refreshSecs = printServices.length;
 955                 } else {
 956                     refreshSecs = minRefreshTime;
 957                 }
 958                 try {
 959                     sleep(refreshSecs * 1000);
 960                 } catch (InterruptedException e) {
 961                     break;
 962                 }
 963             }
 964         }
 965     }
 966 }
--- EOF ---