1 /*

     2  * Copyright (c) 2003, 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 javax.print.attribute.*;

    29 import javax.print.attribute.standard.*;

    30 import javax.print.DocFlavor;

    31 import javax.print.DocPrintJob;

    32 import javax.print.PrintService;

    33 import javax.print.ServiceUIFactory;

    34 import java.util.ArrayList;

    35 import java.util.HashMap;

    36 import java.util.Locale;

    37 import java.util.Date;

    38 import java.util.Arrays;

    39 import java.security.AccessController;

    40 import java.security.PrivilegedActionException;

    41 import java.security.PrivilegedExceptionAction;

    42 import javax.print.event.PrintServiceAttributeListener;

    43 

    44 import java.net.URI;

    45 import java.net.URISyntaxException;

    46 import java.net.URL;

    47 import java.net.URLConnection;

    48 import java.net.HttpURLConnection;

    49 import java.io.File;

    50 import java.io.InputStream;

    51 import java.io.OutputStream;

    52 import java.io.OutputStreamWriter;

    53 import java.io.DataInputStream;

    54 import java.io.ByteArrayOutputStream;

    55 import java.io.ByteArrayInputStream;

    56 import java.io.BufferedReader;

    57 import java.io.InputStreamReader;

    58 import java.nio.charset.Charset;

    59 

    60 import java.util.Iterator;

    61 import java.util.HashSet;

    62 import java.util.Map;

    63 

    64 

    65 public class IPPPrintService implements PrintService, SunPrinterJobService {

    66 

    67     public static final boolean debugPrint;

    68     private static final String debugPrefix = "IPPPrintService>> ";

    69     protected static void debug_println(String str) {

    70         if (debugPrint) {

    71             System.out.println(str);

    72         }

    73     }

    74 

    75     private static final String FORCE_PIPE_PROP = "sun.print.ippdebug";

    76 

    77     static {

    78         String debugStr = java.security.AccessController.doPrivileged(

    79                   new sun.security.action.GetPropertyAction(FORCE_PIPE_PROP));

    80 

    81         debugPrint = "true".equalsIgnoreCase(debugStr);

    82     }

    83 

    84     private String printer;

    85     private URI    myURI;

    86     private URL    myURL;

    87     private transient ServiceNotifier notifier = null;

    88 

    89     private static int MAXCOPIES = 1000;

    90     private static short MAX_ATTRIBUTE_LENGTH = 255;

    91 

    92     private CUPSPrinter cps;

    93     private HttpURLConnection urlConnection = null;

    94     private DocFlavor[] supportedDocFlavors;

    95     private Class<?>[] supportedCats;

    96     private MediaTray[] mediaTrays;

    97     private MediaSizeName[] mediaSizeNames;

    98     private CustomMediaSizeName[] customMediaSizeNames;

    99     private int defaultMediaIndex;

   100     private int[] rawResolutions = null;

   101     private PrinterResolution[] printerResolutions = null;

   102     private boolean isCupsPrinter;

   103     private boolean init;

   104     private Boolean isPS;

   105     private HashMap<String, AttributeClass> getAttMap;

   106     private boolean pngImagesAdded = false;

   107     private boolean gifImagesAdded = false;

   108     private boolean jpgImagesAdded = false;

   109 

   110 

   111     /**

   112      * IPP Status Codes

   113      */

   114     private static final byte STATUSCODE_SUCCESS = 0x00;

   115 

   116     /**

   117      * IPP Group Tags.  Each tag is used once before the first attribute

   118      * of that group.

   119      */

   120     // operation attributes group

   121     private static final byte GRPTAG_OP_ATTRIBUTES = 0x01;

   122     // job attributes group

   123     private static final byte GRPTAG_JOB_ATTRIBUTES = 0x02;

   124     // printer attributes group

   125     private static final byte GRPTAG_PRINTER_ATTRIBUTES = 0x04;

   126     // used as the last tag in an IPP message.

   127     private static final byte GRPTAG_END_ATTRIBUTES = 0x03;

   128 

   129     /**

   130      * IPP Operation codes

   131      */

   132     // gets the attributes for a printer

   133     public static final String OP_GET_ATTRIBUTES = "000B";

   134     // gets the default printer

   135     public static final String OP_CUPS_GET_DEFAULT = "4001";

   136     // gets the list of printers

   137     public static final String OP_CUPS_GET_PRINTERS = "4002";

   138 

   139 

   140     /**

   141      * List of all PrintRequestAttributes.  This is used

   142      * for looping through all the IPP attribute name.

   143      */

   144     private static Object[] printReqAttribDefault = {

   145         Chromaticity.COLOR,

   146         new Copies(1),

   147         Fidelity.FIDELITY_FALSE,

   148         Finishings.NONE,

   149         //new JobHoldUntil(new Date()),

   150         //new JobImpressions(0),

   151         //JobImpressions,

   152         //JobKOctets,

   153         //JobMediaSheets,

   154         new JobName("", Locale.getDefault()),

   155         //JobPriority,

   156         JobSheets.NONE,

   157         (Media)MediaSizeName.NA_LETTER,

   158         //MediaPrintableArea.class, // not an IPP attribute

   159         //MultipleDocumentHandling.SINGLE_DOCUMENT,

   160         new NumberUp(1),

   161         OrientationRequested.PORTRAIT,

   162         new PageRanges(1),

   163         //PresentationDirection,

   164                  // CUPS does not supply printer-resolution attribute

   165         //new PrinterResolution(300, 300, PrinterResolution.DPI),

   166         //PrintQuality.NORMAL,

   167         new RequestingUserName("", Locale.getDefault()),

   168         //SheetCollate.UNCOLLATED, //CUPS has no sheet collate?

   169         Sides.ONE_SIDED,

   170     };

   171 

   172 

   173     /**

   174      * List of all PrintServiceAttributes.  This is used

   175      * for looping through all the IPP attribute name.

   176      */

   177     private static Object[][] serviceAttributes = {

   178         {ColorSupported.class, "color-supported"},

   179         {PagesPerMinute.class,  "pages-per-minute"},

   180         {PagesPerMinuteColor.class, "pages-per-minute-color"},

   181         {PDLOverrideSupported.class, "pdl-override-supported"},

   182         {PrinterInfo.class, "printer-info"},

   183         {PrinterIsAcceptingJobs.class, "printer-is-accepting-jobs"},

   184         {PrinterLocation.class, "printer-location"},

   185         {PrinterMakeAndModel.class, "printer-make-and-model"},

   186         {PrinterMessageFromOperator.class, "printer-message-from-operator"},

   187         {PrinterMoreInfo.class, "printer-more-info"},

   188         {PrinterMoreInfoManufacturer.class, "printer-more-info-manufacturer"},

   189         {PrinterName.class, "printer-name"},

   190         {PrinterState.class, "printer-state"},

   191         {PrinterStateReasons.class, "printer-state-reasons"},

   192         {PrinterURI.class, "printer-uri"},

   193         {QueuedJobCount.class, "queued-job-count"}

   194     };

   195 

   196 

   197     /**

   198      * List of DocFlavors, grouped based on matching mime-type.

   199      * NOTE: For any change in the predefined DocFlavors, it must be reflected

   200      * here also.

   201      */

   202     // PDF DocFlavors

   203     private static DocFlavor[] appPDF = {

   204         DocFlavor.BYTE_ARRAY.PDF,

   205         DocFlavor.INPUT_STREAM.PDF,

   206         DocFlavor.URL.PDF

   207     };

   208 

   209     // Postscript DocFlavors

   210     private static DocFlavor[] appPostScript = {

   211         DocFlavor.BYTE_ARRAY.POSTSCRIPT,

   212         DocFlavor.INPUT_STREAM.POSTSCRIPT,

   213         DocFlavor.URL.POSTSCRIPT

   214     };

   215 

   216     // Autosense DocFlavors

   217     private static DocFlavor[] appOctetStream = {

   218         DocFlavor.BYTE_ARRAY.AUTOSENSE,

   219         DocFlavor.INPUT_STREAM.AUTOSENSE,

   220         DocFlavor.URL.AUTOSENSE

   221     };

   222 

   223     // Text DocFlavors

   224     private static DocFlavor[] textPlain = {

   225         DocFlavor.BYTE_ARRAY.TEXT_PLAIN_UTF_8,

   226         DocFlavor.BYTE_ARRAY.TEXT_PLAIN_UTF_16,

   227         DocFlavor.BYTE_ARRAY.TEXT_PLAIN_UTF_16BE,

   228         DocFlavor.BYTE_ARRAY.TEXT_PLAIN_UTF_16LE,

   229         DocFlavor.BYTE_ARRAY.TEXT_PLAIN_US_ASCII,

   230         DocFlavor.INPUT_STREAM.TEXT_PLAIN_UTF_8,

   231         DocFlavor.INPUT_STREAM.TEXT_PLAIN_UTF_16,

   232         DocFlavor.INPUT_STREAM.TEXT_PLAIN_UTF_16BE,

   233         DocFlavor.INPUT_STREAM.TEXT_PLAIN_UTF_16LE,

   234         DocFlavor.INPUT_STREAM.TEXT_PLAIN_US_ASCII,

   235         DocFlavor.URL.TEXT_PLAIN_UTF_8,

   236         DocFlavor.URL.TEXT_PLAIN_UTF_16,

   237         DocFlavor.URL.TEXT_PLAIN_UTF_16BE,

   238         DocFlavor.URL.TEXT_PLAIN_UTF_16LE,

   239         DocFlavor.URL.TEXT_PLAIN_US_ASCII,

   240         DocFlavor.CHAR_ARRAY.TEXT_PLAIN,

   241         DocFlavor.STRING.TEXT_PLAIN,

   242         DocFlavor.READER.TEXT_PLAIN

   243     };

   244 

   245     private static DocFlavor[] textPlainHost = {

   246         DocFlavor.BYTE_ARRAY.TEXT_PLAIN_HOST,

   247         DocFlavor.INPUT_STREAM.TEXT_PLAIN_HOST,

   248         DocFlavor.URL.TEXT_PLAIN_HOST

   249     };

   250 

   251     // JPG DocFlavors

   252     private static DocFlavor[] imageJPG = {

   253         DocFlavor.BYTE_ARRAY.JPEG,

   254         DocFlavor.INPUT_STREAM.JPEG,

   255         DocFlavor.URL.JPEG

   256     };

   257 

   258     // GIF DocFlavors

   259     private static DocFlavor[] imageGIF = {

   260         DocFlavor.BYTE_ARRAY.GIF,

   261         DocFlavor.INPUT_STREAM.GIF,

   262         DocFlavor.URL.GIF

   263     };

   264 

   265     // PNG DocFlavors

   266     private static DocFlavor[] imagePNG = {

   267         DocFlavor.BYTE_ARRAY.PNG,

   268         DocFlavor.INPUT_STREAM.PNG,

   269         DocFlavor.URL.PNG

   270     };

   271 

   272     // HTML DocFlavors

   273     private  static DocFlavor[] textHtml = {

   274         DocFlavor.BYTE_ARRAY.TEXT_HTML_UTF_8,

   275         DocFlavor.BYTE_ARRAY.TEXT_HTML_UTF_16,

   276         DocFlavor.BYTE_ARRAY.TEXT_HTML_UTF_16BE,

   277         DocFlavor.BYTE_ARRAY.TEXT_HTML_UTF_16LE,

   278         DocFlavor.BYTE_ARRAY.TEXT_HTML_US_ASCII,

   279         DocFlavor.INPUT_STREAM.TEXT_HTML_UTF_8,

   280         DocFlavor.INPUT_STREAM.TEXT_HTML_UTF_16,

   281         DocFlavor.INPUT_STREAM.TEXT_HTML_UTF_16BE,

   282         DocFlavor.INPUT_STREAM.TEXT_HTML_UTF_16LE,

   283         DocFlavor.INPUT_STREAM.TEXT_HTML_US_ASCII,

   284         DocFlavor.URL.TEXT_HTML_UTF_8,

   285         DocFlavor.URL.TEXT_HTML_UTF_16,

   286         DocFlavor.URL.TEXT_HTML_UTF_16BE,

   287         DocFlavor.URL.TEXT_HTML_UTF_16LE,

   288         DocFlavor.URL.TEXT_HTML_US_ASCII,

   289         // These are not handled in UnixPrintJob so commenting these

   290         // for now.

   291         /*

   292         DocFlavor.CHAR_ARRAY.TEXT_HTML,

   293         DocFlavor.STRING.TEXT_HTML,

   294         DocFlavor.READER.TEXT_HTML,

   295         */

   296     };

   297 

   298     private  static DocFlavor[] textHtmlHost = {

   299         DocFlavor.BYTE_ARRAY.TEXT_HTML_HOST,

   300         DocFlavor.INPUT_STREAM.TEXT_HTML_HOST,

   301         DocFlavor.URL.TEXT_HTML_HOST,

   302     };

   303 

   304 

   305     // PCL DocFlavors

   306     private static DocFlavor[] appPCL = {

   307         DocFlavor.BYTE_ARRAY.PCL,

   308         DocFlavor.INPUT_STREAM.PCL,

   309         DocFlavor.URL.PCL

   310     };

   311 

   312     // List of all DocFlavors, used in looping

   313     // through all supported mime-types

   314     private static Object[] allDocFlavors = {

   315         appPDF, appPostScript, appOctetStream,

   316         textPlain, imageJPG, imageGIF, imagePNG,

   317         textHtml, appPCL,

   318     };

   319 

   320 

   321     IPPPrintService(String name, URL url) {

   322         if ((name == null) || (url == null)){

   323             throw new IllegalArgumentException("null uri or printer name");

   324         }

   325         try {

   326             printer = java.net.URLDecoder.decode(name, "UTF-8");

   327         } catch (java.io.UnsupportedEncodingException e) {

   328             printer = name;

   329         }

   330         supportedDocFlavors = null;

   331         supportedCats = null;

   332         mediaSizeNames = null;

   333         customMediaSizeNames = null;

   334         mediaTrays = null;

   335         myURL = url;

   336         cps = null;

   337         isCupsPrinter = false;

   338         init = false;

   339         defaultMediaIndex = -1;

   340 

   341         String host = myURL.getHost();

   342         if (host!=null && host.equals(CUPSPrinter.getServer())) {

   343             isCupsPrinter = true;

   344             try {

   345                 myURI =  new URI("ipp://"+host+

   346                                  "/printers/"+printer);

   347                 debug_println(debugPrefix+"IPPPrintService myURI : "+myURI);

   348             } catch (java.net.URISyntaxException e) {

   349                 throw new IllegalArgumentException("invalid url");

   350             }

   351         }

   352     }

   353 

   354 

   355     IPPPrintService(String name, String uriStr, boolean isCups) {

   356         if ((name == null) || (uriStr == null)){

   357             throw new IllegalArgumentException("null uri or printer name");

   358         }

   359         try {

   360             printer = java.net.URLDecoder.decode(name, "UTF-8");

   361         } catch (java.io.UnsupportedEncodingException e) {

   362             printer = name;

   363         }

   364         supportedDocFlavors = null;

   365         supportedCats = null;

   366         mediaSizeNames = null;

   367         customMediaSizeNames = null;

   368         mediaTrays = null;

   369         cps = null;

   370         init = false;

   371         defaultMediaIndex = -1;

   372         try {

   373             myURL =

   374                 new URL(uriStr.replaceFirst("ipp", "http"));

   375         } catch (Exception e) {

   376             IPPPrintService.debug_println(debugPrefix+

   377                                           " IPPPrintService, myURL="+

   378                                           myURL+" Exception= "+

   379                                           e);

   380             throw new IllegalArgumentException("invalid url");

   381         }

   382 

   383         isCupsPrinter = isCups;

   384         try {

   385             myURI =  new URI(uriStr);

   386             debug_println(debugPrefix+"IPPPrintService myURI : "+myURI);

   387         } catch (java.net.URISyntaxException e) {

   388             throw new IllegalArgumentException("invalid uri");

   389         }

   390     }

   391 

   392 

   393     /*

   394      * Initialize mediaSizeNames, mediaTrays and other attributes.

   395      * Media size/trays are initialized to non-null values, may be 0-length

   396      * array.

   397      * NOTE: Must be called from a synchronized block only.

   398      */

   399     private void initAttributes() {

   400         if (!init) {

   401             // init customMediaSizeNames

   402             customMediaSizeNames = new CustomMediaSizeName[0];

   403 

   404             if ((urlConnection = getIPPConnection(myURL)) == null) {

   405                 mediaSizeNames = new MediaSizeName[0];

   406                 mediaTrays = new MediaTray[0];

   407                 debug_println(debugPrefix+"initAttributes, NULL urlConnection ");

   408                 init = true;

   409                 return;

   410             }

   411 

   412             // get all supported attributes through IPP

   413             opGetAttributes();

   414 

   415             if (isCupsPrinter) {

   416                 // note, it is possible to query media in CUPS using IPP

   417                 // right now we always get it from PPD.

   418                 // maybe use "&& (usePPD)" later?

   419                 // Another reason why we use PPD is because

   420                 // IPP currently does not support it but PPD does.

   421 

   422                 try {

   423                     cps = new CUPSPrinter(printer);

   424                     mediaSizeNames = cps.getMediaSizeNames();

   425                     mediaTrays = cps.getMediaTrays();

   426                     customMediaSizeNames = cps.getCustomMediaSizeNames();

   427                     defaultMediaIndex = cps.getDefaultMediaIndex();

   428                     rawResolutions = cps.getRawResolutions();

   429                     urlConnection.disconnect();

   430                     init = true;

   431                     return;

   432                 } catch (Exception e) {

   433                     IPPPrintService.debug_println(debugPrefix+

   434                                        "initAttributes, error creating CUPSPrinter e="+e);

   435                 }

   436             }

   437 

   438             // use IPP to get all media,

   439             Media[] allMedia = getSupportedMedia();

   440             ArrayList<Media> sizeList = new ArrayList<>();

   441             ArrayList<Media> trayList = new ArrayList<>();

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

   443                 if (allMedia[i] instanceof MediaSizeName) {

   444                     sizeList.add(allMedia[i]);

   445                 } else if (allMedia[i] instanceof MediaTray) {

   446                     trayList.add(allMedia[i]);

   447                 }

   448             }

   449 

   450             if (sizeList != null) {

   451                 mediaSizeNames = new MediaSizeName[sizeList.size()];

   452                 mediaSizeNames = sizeList.toArray(mediaSizeNames);

   453             }

   454             if (trayList != null) {

   455                 mediaTrays = new MediaTray[trayList.size()];

   456                 mediaTrays = trayList.toArray(mediaTrays);

   457             }

   458             urlConnection.disconnect();

   459 

   460             init = true;

   461         }

   462     }

   463 

   464 

   465     public DocPrintJob createPrintJob() {

   466         SecurityManager security = System.getSecurityManager();

   467         if (security != null) {

   468             security.checkPrintJobAccess();

   469         }

   470         // REMIND: create IPPPrintJob

   471         return new UnixPrintJob(this);

   472     }

   473 

   474 

   475     public synchronized Object

   476         getSupportedAttributeValues(Class<? extends Attribute> category,

   477                                     DocFlavor flavor,

   478                                     AttributeSet attributes)

   479     {

   480         if (category == null) {

   481             throw new NullPointerException("null category");

   482         }

   483         if (!Attribute.class.isAssignableFrom(category)) {

   484             throw new IllegalArgumentException(category +

   485                                  " does not implement Attribute");

   486         }

   487         if (flavor != null) {

   488             if (!isDocFlavorSupported(flavor)) {

   489                 throw new IllegalArgumentException(flavor +

   490                                                " is an unsupported flavor");

   491             } else if (isAutoSense(flavor)) {

   492                 return null;

   493             }

   494 

   495         }

   496 

   497         if (!isAttributeCategorySupported(category)) {

   498             return null;

   499         }

   500 

   501         /* Test if the flavor is compatible with the attributes */

   502         if (!isDestinationSupported(flavor, attributes)) {

   503             return null;

   504         }

   505 

   506         initAttributes();

   507 

   508         /* Test if the flavor is compatible with the category */

   509         if ((category == Copies.class) ||

   510             (category == CopiesSupported.class)) {

   511             if (flavor == null ||

   512                 !(flavor.equals(DocFlavor.INPUT_STREAM.POSTSCRIPT) ||

   513                   flavor.equals(DocFlavor.URL.POSTSCRIPT) ||

   514                   flavor.equals(DocFlavor.BYTE_ARRAY.POSTSCRIPT))) {

   515                 CopiesSupported cs = new CopiesSupported(1, MAXCOPIES);

   516                 AttributeClass attribClass = (getAttMap != null) ?

   517                     getAttMap.get(cs.getName()) : null;

   518                 if (attribClass != null) {

   519                     int[] range = attribClass.getIntRangeValue();

   520                     cs = new CopiesSupported(range[0], range[1]);

   521                 }

   522                 return cs;

   523             } else {

   524                 return null;

   525             }

   526         } else  if (category == Chromaticity.class) {

   527             if (flavor == null ||

   528                 flavor.equals(DocFlavor.SERVICE_FORMATTED.PAGEABLE) ||

   529                 flavor.equals(DocFlavor.SERVICE_FORMATTED.PRINTABLE) ||

   530                 !isIPPSupportedImages(flavor.getMimeType())) {

   531                 Chromaticity[]arr = new Chromaticity[1];

   532                 arr[0] = Chromaticity.COLOR;

   533                 return (arr);

   534             } else {

   535                 return null;

   536             }

   537         } else if (category == Destination.class) {

   538             if (flavor == null ||

   539                 flavor.equals(DocFlavor.SERVICE_FORMATTED.PAGEABLE) ||

   540                 flavor.equals(DocFlavor.SERVICE_FORMATTED.PRINTABLE)) {

   541                 try {

   542                     return new Destination((new File("out.ps")).toURI());

   543                 } catch (SecurityException se) {

   544                     try {

   545                         return new Destination(new URI("file:out.ps"));

   546                     } catch (URISyntaxException e) {

   547                         return null;

   548                     }

   549                 }

   550             }

   551             return null;

   552         } else if (category == Fidelity.class) {

   553             Fidelity []arr = new Fidelity[2];

   554             arr[0] = Fidelity.FIDELITY_FALSE;

   555             arr[1] = Fidelity.FIDELITY_TRUE;

   556             return arr;

   557         } else if (category == Finishings.class) {

   558             AttributeClass attribClass = (getAttMap != null) ?

   559                 getAttMap.get("finishings-supported")

   560                 : null;

   561             if (attribClass != null) {

   562                 int[] finArray = attribClass.getArrayOfIntValues();

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

   564                     Finishings[] finSup = new Finishings[finArray.length];

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

   566                         finSup[i] = Finishings.NONE;

   567                         Finishings[] fAll = (Finishings[])

   568                             (new ExtFinishing(100)).getAll();

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

   570                             if (finArray[i] == fAll[j].getValue()) {

   571                                 finSup[i] = fAll[j];

   572                                 break;

   573                             }

   574                         }

   575                     }

   576                     return finSup;

   577                 }

   578             }

   579         } else if (category == JobName.class) {

   580             return new JobName("Java Printing", null);

   581         } else if (category == JobSheets.class) {

   582             JobSheets arr[] = new JobSheets[2];

   583             arr[0] = JobSheets.NONE;

   584             arr[1] = JobSheets.STANDARD;

   585             return arr;

   586 

   587         } else if (category == Media.class) {

   588             Media[] allMedia = new Media[mediaSizeNames.length+

   589                                         mediaTrays.length];

   590 

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

   592                 allMedia[i] = mediaSizeNames[i];

   593             }

   594 

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

   596                 allMedia[i+mediaSizeNames.length] = mediaTrays[i];

   597             }

   598 

   599             if (allMedia.length == 0) {

   600                 allMedia = new Media[1];

   601                 allMedia[0] = (Media)getDefaultAttributeValue(Media.class);

   602             }

   603 

   604             return allMedia;

   605         } else if (category == MediaPrintableArea.class) {

   606             MediaPrintableArea[] mpas = null;

   607             if (cps != null) {

   608                 mpas = cps.getMediaPrintableArea();

   609             }

   610 

   611             if (mpas == null) {

   612                 mpas = new MediaPrintableArea[1];

   613                 mpas[0] = (MediaPrintableArea)

   614                     getDefaultAttributeValue(MediaPrintableArea.class);

   615             }

   616 

   617             if ((attributes == null) || (attributes.size() == 0)) {

   618                 ArrayList<MediaPrintableArea> printableList =

   619                                        new ArrayList<MediaPrintableArea>();

   620 

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

   622                     if (mpas[i] != null) {

   623                         printableList.add(mpas[i]);

   624                     }

   625                 }

   626                 if (printableList.size() > 0) {

   627                     mpas  = new MediaPrintableArea[printableList.size()];

   628                     printableList.toArray(mpas);

   629                 }

   630                 return mpas;

   631             }

   632 

   633             int match = -1;

   634             Media media = (Media)attributes.get(Media.class);

   635             if (media != null && media instanceof MediaSizeName) {

   636                 MediaSizeName msn = (MediaSizeName)media;

   637 

   638                 // case when no supported mediasizenames are reported

   639                 // check given media against the default

   640                 if (mediaSizeNames.length == 0 &&

   641                     msn.equals(getDefaultAttributeValue(Media.class))) {

   642                     //default printable area is that of default mediasize

   643                     return mpas;

   644                 }

   645 

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

   647                     if (msn.equals(mediaSizeNames[i])) {

   648                         match = i;

   649                     }

   650                 }

   651             }

   652 

   653             if (match == -1) {

   654                 return null;

   655             } else {

   656                 MediaPrintableArea []arr = new MediaPrintableArea[1];

   657                 arr[0] = mpas[match];

   658                 return arr;

   659             }

   660         } else if (category == NumberUp.class) {

   661             AttributeClass attribClass = (getAttMap != null) ?

   662                 getAttMap.get("number-up-supported") : null;

   663             if (attribClass != null) {

   664                 int[] values = attribClass.getArrayOfIntValues();

   665                 if (values != null) {

   666                     NumberUp[] nUp = new NumberUp[values.length];

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

   668                         nUp[i] = new NumberUp(values[i]);

   669                     }

   670                     return nUp;

   671                 } else {

   672                     return null;

   673                 }

   674             }

   675         } else if (category == OrientationRequested.class) {

   676             if ((flavor != null) &&

   677                 (flavor.equals(DocFlavor.INPUT_STREAM.POSTSCRIPT) ||

   678                  flavor.equals(DocFlavor.URL.POSTSCRIPT) ||

   679                  flavor.equals(DocFlavor.BYTE_ARRAY.POSTSCRIPT))) {

   680                 return null;

   681             }

   682 

   683             boolean revPort = false;

   684             OrientationRequested[] orientSup = null;

   685 

   686             AttributeClass attribClass = (getAttMap != null) ?

   687               getAttMap.get("orientation-requested-supported")

   688                 : null;

   689             if (attribClass != null) {

   690                 int[] orientArray = attribClass.getArrayOfIntValues();

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

   692                     orientSup =

   693                         new OrientationRequested[orientArray.length];

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

   695                         switch (orientArray[i]) {

   696                         default:

   697                         case 3 :

   698                             orientSup[i] = OrientationRequested.PORTRAIT;

   699                             break;

   700                         case 4:

   701                             orientSup[i] = OrientationRequested.LANDSCAPE;

   702                             break;

   703                         case 5:

   704                             orientSup[i] =

   705                                 OrientationRequested.REVERSE_LANDSCAPE;

   706                             break;

   707                         case 6:

   708                             orientSup[i] =

   709                                 OrientationRequested.REVERSE_PORTRAIT;

   710                             revPort = true;

   711                             break;

   712                         }

   713                     }

   714                 }

   715             }

   716             if (flavor == null ||

   717                 flavor.equals(DocFlavor.SERVICE_FORMATTED.PAGEABLE) ||

   718                 flavor.equals(DocFlavor.SERVICE_FORMATTED.PRINTABLE)) {

   719 

   720                 if (revPort && flavor == null) {

   721                     OrientationRequested []orSup = new OrientationRequested[4];

   722                     orSup[0] = OrientationRequested.PORTRAIT;

   723                     orSup[1] = OrientationRequested.LANDSCAPE;

   724                     orSup[2] = OrientationRequested.REVERSE_LANDSCAPE;

   725                     orSup[3] = OrientationRequested.REVERSE_PORTRAIT;

   726                     return orSup;

   727                 } else {

   728                     OrientationRequested []orSup = new OrientationRequested[3];

   729                     orSup[0] = OrientationRequested.PORTRAIT;

   730                     orSup[1] = OrientationRequested.LANDSCAPE;

   731                     orSup[2] = OrientationRequested.REVERSE_LANDSCAPE;

   732                     return orSup;

   733                 }

   734             } else {

   735                 return orientSup;

   736             }

   737         } else if (category == PageRanges.class) {

   738            if (flavor == null ||

   739                 flavor.equals(DocFlavor.SERVICE_FORMATTED.PAGEABLE) ||

   740                 flavor.equals(DocFlavor.SERVICE_FORMATTED.PRINTABLE)) {

   741                 PageRanges []arr = new PageRanges[1];

   742                 arr[0] = new PageRanges(1, Integer.MAX_VALUE);

   743                 return arr;

   744             } else {

   745                 // Returning null as this is not yet supported in UnixPrintJob.

   746                 return null;

   747             }

   748         } else if (category == RequestingUserName.class) {

   749             String userName = "";

   750             try {

   751               userName = System.getProperty("user.name", "");

   752             } catch (SecurityException se) {

   753             }

   754             return new RequestingUserName(userName, null);

   755         } else if (category == Sides.class) {

   756             // The printer takes care of Sides so if short-edge

   757             // is chosen in a job, the rotation is done by the printer.

   758             // Orientation is rotated by emulation if pageable

   759             // or printable so if the document is in Landscape, this may

   760             // result in double rotation.

   761             AttributeClass attribClass = (getAttMap != null) ?

   762                 getAttMap.get("sides-supported")

   763                 : null;

   764             if (attribClass != null) {

   765                 String[] sidesArray = attribClass.getArrayOfStringValues();

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

   767                     Sides[] sidesSup = new Sides[sidesArray.length];

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

   769                         if (sidesArray[i].endsWith("long-edge")) {

   770                             sidesSup[i] = Sides.TWO_SIDED_LONG_EDGE;

   771                         } else if (sidesArray[i].endsWith("short-edge")) {

   772                             sidesSup[i] = Sides.TWO_SIDED_SHORT_EDGE;

   773                         } else {

   774                             sidesSup[i] = Sides.ONE_SIDED;

   775                         }

   776                     }

   777                     return sidesSup;

   778                 }

   779             }

   780         } else if (category == PrinterResolution.class) {

   781             PrinterResolution[] supportedRes = getPrintResolutions();

   782             if (supportedRes == null) {

   783                 return null;

   784             }

   785             PrinterResolution []arr =

   786                 new PrinterResolution[supportedRes.length];

   787             System.arraycopy(supportedRes, 0, arr, 0, supportedRes.length);

   788             return arr;

   789         }

   790 

   791         return null;

   792     }

   793 

   794     //This class is for getting all pre-defined Finishings

   795     @SuppressWarnings("serial") // JDK implementation class

   796     private class ExtFinishing extends Finishings {

   797         ExtFinishing(int value) {

   798             super(100); // 100 to avoid any conflicts with predefined values.

   799         }

   800 

   801         EnumSyntax[] getAll() {

   802             EnumSyntax[] es = super.getEnumValueTable();

   803             return es;

   804         }

   805     }

   806 

   807 

   808     public AttributeSet getUnsupportedAttributes(DocFlavor flavor,

   809                                                  AttributeSet attributes) {

   810         if (flavor != null && !isDocFlavorSupported(flavor)) {

   811             throw new IllegalArgumentException("flavor " + flavor +

   812                                                "is not supported");

   813         }

   814 

   815         if (attributes == null) {

   816             return null;

   817         }

   818 

   819         Attribute attr;

   820         AttributeSet unsupp = new HashAttributeSet();

   821         Attribute []attrs = attributes.toArray();

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

   823             try {

   824                 attr = attrs[i];

   825                 if (!isAttributeCategorySupported(attr.getCategory())) {

   826                     unsupp.add(attr);

   827                 } else if (!isAttributeValueSupported(attr, flavor,

   828                                                       attributes)) {

   829                     unsupp.add(attr);

   830                 }

   831             } catch (ClassCastException e) {

   832             }

   833         }

   834         if (unsupp.isEmpty()) {

   835             return null;

   836         } else {

   837             return unsupp;

   838         }

   839     }

   840 

   841 

   842     public synchronized DocFlavor[] getSupportedDocFlavors() {

   843 

   844         if (supportedDocFlavors != null) {

   845             int len = supportedDocFlavors.length;

   846                 DocFlavor[] copyflavors = new DocFlavor[len];

   847                 System.arraycopy(supportedDocFlavors, 0, copyflavors, 0, len);

   848                 return copyflavors;

   849         }

   850         initAttributes();

   851 

   852         if ((getAttMap != null) &&

   853             getAttMap.containsKey("document-format-supported")) {

   854 

   855             AttributeClass attribClass =

   856                 getAttMap.get("document-format-supported");

   857             if (attribClass != null) {

   858                 String mimeType;

   859                 boolean psSupported = false;

   860                 String[] docFlavors = attribClass.getArrayOfStringValues();

   861                 DocFlavor[] flavors;

   862                 HashSet<Object> docList = new HashSet<>();

   863                 int j;

   864                 String hostEnc = DocFlavor.hostEncoding.

   865                     toLowerCase(Locale.ENGLISH);

   866                 boolean addHostEncoding = !hostEnc.equals("utf-8") &&

   867                     !hostEnc.equals("utf-16") && !hostEnc.equals("utf-16be") &&

   868                     !hostEnc.equals("utf-16le") && !hostEnc.equals("us-ascii");

   869 

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

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

   872                         flavors = (DocFlavor[])allDocFlavors[j];

   873 

   874                         mimeType = flavors[0].getMimeType();

   875                         if (mimeType.startsWith(docFlavors[i])) {

   876 

   877                             docList.addAll(Arrays.asList(flavors));

   878 

   879                             if (mimeType.equals("text/plain") &&

   880                                 addHostEncoding) {

   881                                 docList.add(Arrays.asList(textPlainHost));

   882                             } else if (mimeType.equals("text/html") &&

   883                                        addHostEncoding) {

   884                                 docList.add(Arrays.asList(textHtmlHost));

   885                             } else if (mimeType.equals("image/png")) {

   886                                 pngImagesAdded = true;

   887                             } else if (mimeType.equals("image/gif")) {

   888                                 gifImagesAdded = true;

   889                             } else if (mimeType.equals("image/jpeg")) {

   890                                 jpgImagesAdded = true;

   891                             } else if (mimeType.indexOf("postscript") != -1) {

   892                                 psSupported = true;

   893                             }

   894                             break;

   895                         }

   896                     }

   897 

   898                     // Not added? Create new DocFlavors

   899                     if (j == allDocFlavors.length) {

   900                         //  make new DocFlavors

   901                         docList.add(new DocFlavor.BYTE_ARRAY(docFlavors[i]));

   902                         docList.add(new DocFlavor.INPUT_STREAM(docFlavors[i]));

   903                         docList.add(new DocFlavor.URL(docFlavors[i]));

   904                     }

   905                 }

   906 

   907                 // check if we need to add image DocFlavors

   908                 // and Pageable/Printable flavors

   909                 if (psSupported || isCupsPrinter) {

   910                     /*

   911                      Always add Pageable and Printable for CUPS

   912                      since it uses Filters to convert from Postscript

   913                      to device printer language.

   914                     */

   915                     docList.add(DocFlavor.SERVICE_FORMATTED.PAGEABLE);

   916                     docList.add(DocFlavor.SERVICE_FORMATTED.PRINTABLE);

   917 

   918                     docList.addAll(Arrays.asList(imageJPG));

   919                     docList.addAll(Arrays.asList(imagePNG));

   920                     docList.addAll(Arrays.asList(imageGIF));

   921                 }

   922                 supportedDocFlavors = new DocFlavor[docList.size()];

   923                 docList.toArray(supportedDocFlavors);

   924                 int len = supportedDocFlavors.length;

   925                 DocFlavor[] copyflavors = new DocFlavor[len];

   926                 System.arraycopy(supportedDocFlavors, 0, copyflavors, 0, len);

   927                 return copyflavors;

   928             }

   929         }

   930         DocFlavor[] flavor = new DocFlavor[2];

   931         flavor[0] = DocFlavor.SERVICE_FORMATTED.PAGEABLE;

   932         flavor[1] = DocFlavor.SERVICE_FORMATTED.PRINTABLE;

   933         supportedDocFlavors = flavor;

   934         return flavor;

   935     }

   936 

   937 

   938     public boolean isDocFlavorSupported(DocFlavor flavor) {

   939         if (supportedDocFlavors == null) {

   940             getSupportedDocFlavors();

   941         }

   942         if (supportedDocFlavors != null) {

   943             for (int f=0; f<supportedDocFlavors.length; f++) {

   944                 if (flavor.equals(supportedDocFlavors[f])) {

   945                     return true;

   946                 }

   947             }

   948         }

   949         return false;

   950     }

   951 

   952 

   953     /**

   954      * Finds matching CustomMediaSizeName of given media.

   955      */

   956     public CustomMediaSizeName findCustomMedia(MediaSizeName media) {

   957         if (customMediaSizeNames == null) {

   958             return null;

   959         }

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

   961             CustomMediaSizeName custom = customMediaSizeNames[i];

   962             MediaSizeName msn = custom.getStandardMedia();

   963             if (media.equals(msn)) {

   964                 return customMediaSizeNames[i];

   965             }

   966         }

   967         return null;

   968     }

   969 

   970 

   971     /**

   972      * Returns the matching standard Media using string comparison of names.

   973      */

   974     private Media getIPPMedia(String mediaName) {

   975         CustomMediaSizeName sampleSize = new CustomMediaSizeName("sample", "",

   976                                                                  0, 0);

   977         Media[] sizes = sampleSize.getSuperEnumTable();

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

   979             if (mediaName.equals(""+sizes[i])) {

   980                 return sizes[i];

   981             }

   982         }

   983         CustomMediaTray sampleTray = new CustomMediaTray("sample", "");

   984         Media[] trays = sampleTray.getSuperEnumTable();

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

   986             if (mediaName.equals(""+trays[i])) {

   987                 return trays[i];

   988             }

   989         }

   990         return null;

   991     }

   992 

   993     private Media[] getSupportedMedia() {

   994         if ((getAttMap != null) &&

   995             getAttMap.containsKey("media-supported")) {

   996 

   997             AttributeClass attribClass = getAttMap.get("media-supported");

   998 

   999             if (attribClass != null) {

  1000                 String[] mediaVals = attribClass.getArrayOfStringValues();

  1001                 Media msn;

  1002                 Media[] mediaNames =

  1003                     new Media[mediaVals.length];

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

  1005                     msn = getIPPMedia(mediaVals[i]);

  1006                     //REMIND: if null, create custom?

  1007                     mediaNames[i] = msn;

  1008                 }

  1009                 return mediaNames;

  1010             }

  1011         }

  1012         return new Media[0];

  1013     }

  1014 

  1015 

  1016     public synchronized Class<?>[] getSupportedAttributeCategories() {

  1017         if (supportedCats != null) {

  1018             Class<?> [] copyCats = new Class<?>[supportedCats.length];

  1019             System.arraycopy(supportedCats, 0, copyCats, 0, copyCats.length);

  1020             return copyCats;

  1021         }

  1022 

  1023         initAttributes();

  1024 

  1025         ArrayList<Class<?>> catList = new ArrayList<>();

  1026 

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

  1028             PrintRequestAttribute pra =

  1029                 (PrintRequestAttribute)printReqAttribDefault[i];

  1030             if (getAttMap != null &&

  1031                 getAttMap.containsKey(pra.getName()+"-supported")) {

  1032                 catList.add(pra.getCategory());

  1033             }

  1034         }

  1035 

  1036         // Some IPP printers like lexc710 do not have list of supported media

  1037         // but CUPS can get the media from PPD, so we still report as

  1038         // supported category.

  1039         if (isCupsPrinter) {

  1040             if (!catList.contains(Media.class)) {

  1041                 catList.add(Media.class);

  1042             }

  1043 

  1044             // Always add MediaPrintable for cups,

  1045             // because we can get it from PPD.

  1046             catList.add(MediaPrintableArea.class);

  1047 

  1048             // this is already supported in UnixPrintJob

  1049             catList.add(Destination.class);

  1050 

  1051             // It is unfortunate that CUPS doesn't provide a way to query

  1052             // if printer supports collation but since most printers

  1053             // now supports collation and that most OS has a way

  1054             // of setting it, it is a safe assumption to just always

  1055             // include SheetCollate as supported attribute.

  1056 

  1057             catList.add(SheetCollate.class);

  1058 

  1059         }

  1060 

  1061         // With the assumption that  Chromaticity is equivalent to

  1062         // ColorSupported.

  1063         if (getAttMap != null && getAttMap.containsKey("color-supported")) {

  1064             catList.add(Chromaticity.class);

  1065         }

  1066 

  1067         // CUPS does not report printer resolution via IPP but it

  1068         // may be gleaned from the PPD.

  1069         PrinterResolution[] supportedRes = getPrintResolutions();

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

  1071             catList.add(PrinterResolution.class);

  1072         }

  1073 

  1074         supportedCats = new Class<?>[catList.size()];

  1075         catList.toArray(supportedCats);

  1076         Class<?>[] copyCats = new Class<?>[supportedCats.length];

  1077         System.arraycopy(supportedCats, 0, copyCats, 0, copyCats.length);

  1078         return copyCats;

  1079     }

  1080 

  1081 

  1082     public boolean

  1083         isAttributeCategorySupported(Class<? extends Attribute> category)

  1084     {

  1085         if (category == null) {

  1086             throw new NullPointerException("null category");

  1087         }

  1088         if (!(Attribute.class.isAssignableFrom(category))) {

  1089             throw new IllegalArgumentException(category +

  1090                                              " is not an Attribute");

  1091         }

  1092 

  1093         if (supportedCats == null) {

  1094             getSupportedAttributeCategories();

  1095         }

  1096 

  1097         // It is safe to assume that Orientation is always supported

  1098         // and even if CUPS or an IPP device reports it as not,

  1099         // our renderer can do portrait, landscape and

  1100         // reverse landscape.

  1101         if (category == OrientationRequested.class) {

  1102             return true;

  1103         }

  1104 

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

  1106             if (category == supportedCats[i]) {

  1107                 return true;

  1108             }

  1109         }

  1110 

  1111         return false;

  1112     }

  1113 

  1114     @SuppressWarnings("unchecked")

  1115     public synchronized <T extends PrintServiceAttribute>

  1116         T getAttribute(Class<T> category)

  1117     {

  1118         if (category == null) {

  1119             throw new NullPointerException("category");

  1120         }

  1121         if (!(PrintServiceAttribute.class.isAssignableFrom(category))) {

  1122             throw new IllegalArgumentException("Not a PrintServiceAttribute");

  1123         }

  1124 

  1125         initAttributes();

  1126 

  1127         if (category == PrinterName.class) {

  1128             return (T)(new PrinterName(printer, null));

  1129         } else if (category == PrinterInfo.class) {

  1130             PrinterInfo pInfo = new PrinterInfo(printer, null);

  1131             AttributeClass ac = (getAttMap != null) ?

  1132                 getAttMap.get(pInfo.getName())

  1133                 : null;

  1134             if (ac != null) {