1 /*
   2  * Copyright (c) 2012, 2017, 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 com.sun.javafx.tools.packager;
  27 
  28 import com.oracle.tools.packager.Bundlers;
  29 import com.oracle.tools.packager.ConfigException;
  30 import com.oracle.tools.packager.Log;
  31 import com.oracle.tools.packager.Platform;
  32 import com.oracle.tools.packager.UnsupportedPlatformException;
  33 import com.sun.javafx.tools.packager.JarSignature.InputStreamSource;
  34 import com.sun.javafx.tools.packager.bundlers.BundleParams;
  35 import com.sun.javafx.tools.packager.bundlers.Bundler.BundleType;
  36 import com.sun.javafx.tools.resource.PackagerResource;
  37 
  38 import java.io.BufferedReader;
  39 import java.io.File;
  40 import java.io.FileInputStream;
  41 import java.io.FileNotFoundException;
  42 import java.io.FileOutputStream;
  43 import java.io.FileWriter;
  44 import java.io.IOException;
  45 import java.io.InputStream;
  46 import java.io.InputStreamReader;
  47 import java.io.OutputStream;
  48 import java.io.Writer;
  49 import java.lang.reflect.Method;
  50 import java.net.MalformedURLException;
  51 import java.net.URL;
  52 import java.net.URLClassLoader;
  53 import java.nio.file.Files;
  54 import java.nio.file.StandardCopyOption;
  55 import java.security.InvalidKeyException;
  56 import java.security.KeyStore;
  57 import java.security.KeyStoreException;
  58 import java.security.NoSuchAlgorithmException;
  59 import java.security.PrivateKey;
  60 import java.security.SignatureException;
  61 import java.security.UnrecoverableKeyException;
  62 import java.security.cert.Certificate;
  63 import java.security.cert.CertificateException;
  64 import java.security.cert.X509Certificate;
  65 import java.text.MessageFormat;
  66 import java.util.ArrayList;
  67 import java.util.Base64;
  68 import java.util.Enumeration;
  69 import java.util.HashMap;
  70 import java.util.HashSet;
  71 import java.util.List;
  72 import java.util.Map;
  73 import java.util.Map.Entry;
  74 import java.util.ResourceBundle;
  75 import java.util.Set;
  76 import java.util.jar.Attributes;
  77 import java.util.jar.JarEntry;
  78 import java.util.jar.JarFile;
  79 import java.util.jar.JarOutputStream;
  80 import java.util.jar.Manifest;
  81 import java.util.zip.ZipEntry;
  82 import java.util.zip.ZipOutputStream;
  83 
  84 /**
  85  * @deprecated use {@link ToolProvider} to locate the {@code "javapackager"} tool instead.
  86  */
  87 @Deprecated(since="10", forRemoval=true)
  88 public class PackagerLib {
  89     public static final String JAVAFX_VERSION = System.getProperty("java.version");
  90 
  91     private static final ResourceBundle bundle =
  92             ResourceBundle.getBundle("com/sun/javafx/tools/packager/Bundle");
  93 
  94     private CreateJarParams createJarParams;
  95     private CreateBSSParams createBssParams;
  96     private File bssTmpDir;
  97 
  98 
  99     private enum Filter {ALL, CLASSES_ONLY, RESOURCES}
 100 
 101     private ClassLoader classLoader;
 102 
 103     private ClassLoader getClassLoader() throws PackagerException {
 104         if (classLoader == null) {
 105             try {
 106                 URL[] urls = {new URL(getJfxrtPath())};
 107                 classLoader = URLClassLoader.newInstance(urls);
 108             } catch (MalformedURLException ex) {
 109                 throw new PackagerException(ex, "ERR_CantFindRuntime");
 110             }
 111         }
 112         return classLoader;
 113     }
 114 
 115     //  if set of input resources consist of SINGLE element and
 116     //   this element is jar file then we expect this to be request to
 117     //   "update" jar file
 118     //  Input jar file MUST be executable jar file
 119     //
 120     // Check if we are in "special case" scenario
 121     private File jarFileToUpdate(CreateJarParams params) {
 122         if (params.resources.size() == 1) {
 123             PackagerResource p = params.resources.get(0);
 124             File f = p.getFile();
 125             if (!f.isFile() || !f.getAbsolutePath().toLowerCase().endsWith(".jar")) {
 126                 return null;
 127             }
 128             try (JarFile jf = new JarFile(f)) {
 129                 jf.getManifest(); //try to read manifest to validate it is jar
 130                 return f;
 131             } catch (Exception e) {
 132                 //treat any exception as "not a special case" scenario
 133                 com.oracle.tools.packager.Log.verbose(e);
 134             }
 135         }
 136         return null;
 137     }
 138 
 139     public void packageAsJar(CreateJarParams createJarParams) throws PackagerException {
 140         if (createJarParams == null) {
 141             throw new IllegalArgumentException("Parameters must not be null");
 142         }
 143 
 144         if (createJarParams.outfile == null) {
 145             throw new IllegalArgumentException("Output file is not specified");
 146         }
 147 
 148         this.createJarParams = createJarParams;
 149 
 150         //Special case: could be request for "update jar file"
 151         File jarToUpdate = jarFileToUpdate(createJarParams);
 152         Manifest m = null;
 153 
 154         if (jarToUpdate != null) {
 155             com.oracle.tools.packager.Log.info(MessageFormat.format(bundle.getString("MSG_UpdatingJar"), jarToUpdate.getAbsolutePath()));
 156             try (JarFile jf = new JarFile(jarToUpdate)) {
 157                 //extract data we want to preserve
 158                 m = jf.getManifest();
 159                 if (m != null) {
 160                     Attributes attrs = m.getMainAttributes();
 161                     if (createJarParams.applicationClass == null) {
 162                         createJarParams.applicationClass =
 163                                 attrs.getValue(Attributes.Name.MAIN_CLASS);
 164                     }
 165                     if (createJarParams.classpath == null) {
 166                         createJarParams.classpath =
 167                                 attrs.getValue(Attributes.Name.CLASS_PATH);
 168                     }
 169                     if (createJarParams.codebase == null) {
 170                         createJarParams.codebase =
 171                                 attrs.getValue(new Attributes.Name("Codebase"));
 172                     }
 173                     if (createJarParams.allPermissions == null) {
 174                         String value  =
 175                                 attrs.getValue(new Attributes.Name("Permissions"));
 176                         if (value != null) {
 177                             createJarParams.allPermissions = Boolean.valueOf(value);
 178                         }
 179                     }
 180                 }
 181             } catch (IOException ex) {
 182                 throw new PackagerException(
 183                         ex, "ERR_FileReadFailed", jarToUpdate.getAbsolutePath());
 184             }
 185         }
 186 
 187         if (createJarParams.applicationClass == null) {
 188             throw new IllegalArgumentException(
 189                     "Main application class is not specified");
 190         }
 191 
 192         //NOTE: This should be a save-to-temp file, then rename operation
 193         File applicationJar = new File(createJarParams.outdir,
 194                 createJarParams.outfile.endsWith(".jar")
 195                         ? createJarParams.outfile
 196                         : createJarParams.outfile + ".jar");
 197 
 198         if (jarToUpdate != null &&
 199                 applicationJar.getAbsoluteFile().equals(jarToUpdate.getAbsoluteFile())) {
 200             try {
 201                 File newInputJar = File.createTempFile("tempcopy", ".jar");
 202                 Files.move(jarToUpdate.toPath(), newInputJar.toPath(),
 203                         StandardCopyOption.REPLACE_EXISTING);
 204                 jarToUpdate = newInputJar;
 205             } catch (IOException ioe) {
 206                 throw new PackagerException(
 207                         ioe, "ERR_FileCopyFailed", jarToUpdate.getAbsolutePath());
 208             }
 209         }
 210 
 211         File parentFile = applicationJar.getParentFile();
 212         if (parentFile != null) {
 213             parentFile.mkdirs();
 214         }
 215 
 216         if (m == null) {
 217             m = new Manifest();
 218         }
 219         Attributes attr = m.getMainAttributes();
 220         attr.put(Attributes.Name.MANIFEST_VERSION, "1.0");
 221         attr.put(new Attributes.Name("Created-By"), "JavaFX Packager");
 222 
 223         if (createJarParams.manifestAttrs != null) {
 224             for (Entry<String, String> e: createJarParams.manifestAttrs.entrySet()) {
 225                 attr.put(new Attributes.Name(e.getKey()), e.getValue());
 226             }
 227         }
 228 
 229         attr.put(Attributes.Name.MAIN_CLASS, createJarParams.applicationClass);
 230         if (createJarParams.classpath != null) {
 231             // Allow comma or semicolon as delimeter (turn them into spaces)
 232             String cp = createJarParams.classpath;
 233             cp = cp.replace(';', ' ').replace(',', ' ');
 234             attr.put(Attributes.Name.CLASS_PATH, cp);
 235         }
 236 
 237         String existingSetting = attr.getValue("Permissions");
 238         if (existingSetting == null) {
 239             attr.put(new Attributes.Name("Permissions"),
 240                     Boolean.TRUE.equals(createJarParams.allPermissions) ? "all-permissions" : "sandbox");
 241         } else if (createJarParams.allPermissions != null && !Boolean.valueOf(existingSetting).equals(createJarParams.allPermissions)) {
 242             throw new PackagerException(
 243                 "ERR_ContradictorySetting", "Permissions");
 244         }
 245 
 246         existingSetting = attr.getValue("Codebase");
 247         if (existingSetting == null) {
 248             if (createJarParams.codebase != null) {
 249                 attr.put(new Attributes.Name("Codebase"), createJarParams.codebase);
 250             }
 251         } else if (createJarParams.codebase != null && !existingSetting.equals(createJarParams.codebase)) {
 252             throw new PackagerException(
 253                     "ERR_ContradictorySetting", "Codebase");
 254         }
 255 
 256         attr.put(new Attributes.Name("JavaFX-Version"), createJarParams.fxVersion);
 257 
 258         if (createJarParams.preloader != null) {
 259             attr.put(new Attributes.Name("JavaFX-Preloader-Class"), createJarParams.preloader);
 260         }
 261 
 262 
 263         if (createJarParams.arguments != null) {
 264             int idx = 1;
 265             for (String arg: createJarParams.arguments) {
 266                 attr.put(new Attributes.Name("JavaFX-Argument-"+idx),
 267                         encodeAsBase64(arg.getBytes()));
 268                 idx++;
 269             }
 270         }
 271         if (createJarParams.params != null) {
 272             int idx = 1;
 273             for (Param p : createJarParams.params) {
 274                 if (p.name != null) { //otherwise it is something weird and we skip it
 275                     attr.put(new Attributes.Name("JavaFX-Parameter-Name-" + idx),
 276                             encodeAsBase64(p.name.getBytes()));
 277                     if (p.value != null) { //legal, means not value specified
 278                         attr.put(new Attributes.Name("JavaFX-Parameter-Value-" + idx),
 279                                 encodeAsBase64(p.value.getBytes()));
 280                     }
 281                     idx++;
 282                 }
 283             }
 284         }
 285 
 286 
 287         if (createJarParams.css2bin) {
 288             try {
 289                 bssTmpDir = File.createTempFile("bssfiles", "");
 290             } catch (IOException ex) {
 291                 throw new PackagerException(ex, "ERR_CreatingTempFileFailed");
 292             }
 293             bssTmpDir.delete();
 294         }
 295 
 296         if (applicationJar.exists() && !applicationJar.delete()) {
 297             throw new PackagerException(
 298                     "ERR_CantDeleteFile", createJarParams.outfile);
 299         }
 300         try {
 301             jar(m, createJarParams.resources, jarToUpdate,
 302                     new JarOutputStream(new FileOutputStream(applicationJar)),
 303                     Filter.ALL);
 304         } catch (IOException ex) {
 305             throw new PackagerException(
 306                     ex, "ERR_CreatingJarFailed", createJarParams.outfile);
 307         }
 308 
 309         // cleanup
 310         deleteDirectory(bssTmpDir);
 311         this.createJarParams = null;
 312     }
 313 
 314     public void generateDeploymentPackages(DeployParams deployParams) throws PackagerException {
 315         if (deployParams == null) {
 316             throw new IllegalArgumentException("Parameters must not be null.");
 317         }
 318 
 319         try {
 320             BundleParams bp = deployParams.getBundleParams();
 321 
 322             if (bp != null) {
 323                 switch(deployParams.getBundleType()) {
 324                     case NATIVE: {
 325                         // Generate disk images.
 326                         generateNativeBundles(deployParams.outdir,
 327                                               bp.getBundleParamsAsMap(),
 328                                               BundleType.IMAGE.toString(),
 329                                               deployParams.getTargetFormat());
 330 
 331                         // Generate installers.
 332                         generateNativeBundles(deployParams.outdir,
 333                                               bp.getBundleParamsAsMap(),
 334                                               BundleType.INSTALLER.toString(),
 335                                               deployParams.getTargetFormat());
 336                         break;
 337                     }
 338 
 339                     case JNLP:
 340                     case NONE: {
 341                         // Old school default. Just generate JNLP.
 342                         generateNativeBundles(deployParams.outdir,
 343                                               bp.getBundleParamsAsMap(),
 344                                               BundleType.JNLP.toString(),
 345                                               "jnlp");
 346                         break;
 347                     }
 348 
 349                     default: {
 350                         // A specefic output format, just generate that.
 351                         generateNativeBundles(deployParams.outdir,
 352                                               bp.getBundleParamsAsMap(),
 353                                               deployParams.getBundleType().toString(),
 354                                               deployParams.getTargetFormat());
 355                     }
 356                 }
 357             }
 358         } catch (PackagerException ex) {
 359             throw ex;
 360         } catch (Exception ex) {
 361             throw new PackagerException(ex, "ERR_DeployFailed", ex.getMessage());
 362         }
 363 
 364     }
 365 
 366     private void generateNativeBundles(File outdir, Map<String, ? super Object> params, String bundleType, String bundleFormat) throws PackagerException {
 367         for (com.oracle.tools.packager.Bundler bundler : Bundlers.createBundlersInstance().getBundlers(bundleType)) {
 368             // if they specify the bundle format, require we match the ID
 369             if (bundleFormat != null && !bundleFormat.equalsIgnoreCase(bundler.getID())) continue;
 370 
 371             Map<String, ? super Object> localParams = new HashMap<>(params);
 372             try {
 373                 if (bundler.validate(localParams)) {
 374                     File result = bundler.execute(localParams, outdir);
 375                     bundler.cleanup(localParams);
 376                     if (result == null) {
 377                         throw new PackagerException("MSG_BundlerFailed", bundler.getID(), bundler.getName());
 378                     }
 379                 }
 380             } catch (UnsupportedPlatformException e) {
 381                 com.oracle.tools.packager.Log.debug(MessageFormat.format(bundle.getString("MSG_BundlerPlatformException"), bundler.getName()));
 382             } catch (ConfigException e) {
 383                 com.oracle.tools.packager.Log.debug(e);
 384                 if (e.getAdvice() != null) {
 385                     com.oracle.tools.packager.Log.info(MessageFormat.format(bundle.getString("MSG_BundlerConfigException"), bundler.getName(), e.getMessage(), e.getAdvice()));
 386                 } else {
 387                     com.oracle.tools.packager.Log.info(MessageFormat.format(bundle.getString("MSG_BundlerConfigExceptionNoAdvice"), bundler.getName(), e.getMessage()));
 388                 }
 389             } catch (RuntimeException re) {
 390                 com.oracle.tools.packager.Log.info(MessageFormat.format(bundle.getString("MSG_BundlerRuntimeException"), bundler.getName(), re.toString()));
 391                 com.oracle.tools.packager.Log.debug(re);
 392             }
 393         }
 394     }
 395 
 396     public void generateBSS(CreateBSSParams params) throws PackagerException {
 397         if (params == null) {
 398             throw new IllegalArgumentException("Parameters must not be null.");
 399         }
 400         this.createBssParams = params;
 401         createBinaryCss(createBssParams.resources, createBssParams.outdir);
 402         this.createBssParams = null;
 403     }
 404 
 405     public void signJar(SignJarParams params) throws PackagerException {
 406         try {
 407             JarSignature signature = retrieveSignature(params);
 408 
 409             for (PackagerResource pr: params.resources) {
 410                 signFile(pr, signature, params.outdir, params.verbose);
 411             }
 412 
 413         } catch (Exception ex) {
 414             com.oracle.tools.packager.Log.verbose(ex);
 415             throw new PackagerException("ERR_SignFailed", ex);
 416         }
 417 
 418     }
 419 
 420 
 421     private JarSignature retrieveSignature(SignJarParams params) throws KeyStoreException,
 422             NoSuchAlgorithmException, UnrecoverableKeyException, IOException,
 423             CertificateException, InvalidKeyException {
 424         if (params.keyPass == null) {
 425             params.keyPass = params.storePass;
 426         }
 427 
 428         if (params.keyStore == null) {
 429             throw new IOException("No keystore specified");
 430         }
 431 
 432         if (params.storePass == null) {
 433             throw new IOException("No store password specified");
 434         }
 435 
 436         if (params.storeType == null) {
 437             throw new IOException("No store type is specified");
 438         }
 439 
 440         KeyStore store = KeyStore.getInstance(params.storeType);
 441         store.load(new FileInputStream(params.keyStore), params.storePass.toCharArray());
 442 
 443         Certificate[] chain = store.getCertificateChain(params.alias);
 444         X509Certificate certChain[] = new X509Certificate[chain.length];
 445         for (int i=0; i<chain.length; i++) {
 446             certChain[i] = (X509Certificate) chain[i];
 447         }
 448 
 449         PrivateKey privateKey = (PrivateKey)
 450                 store.getKey(params.alias, params.keyPass.toCharArray());
 451 
 452         return JarSignature.create(privateKey, certChain);
 453     }
 454 
 455     private void signFile(
 456             PackagerResource pr, JarSignature signature, File outdir, boolean verbose)
 457             throws NoSuchAlgorithmException, IOException, SignatureException {
 458         if (pr.getFile().isDirectory()) {
 459             File[] children = pr.getFile().listFiles();
 460             if (children != null) {
 461                 for (File innerFile : children) {
 462                     signFile(new PackagerResource(
 463                             pr.getBaseDir(), innerFile), signature, outdir, verbose);
 464                 }
 465             }
 466         } else {
 467             File jar = pr.getFile();
 468             File parent = jar.getParentFile();
 469             String name = "bsigned_" + jar.getName();
 470             File signedJar = new File(parent, name);
 471 
 472             System.out.println("Signing (BLOB) " + jar.getPath());
 473 
 474             signAsBLOB(jar, signedJar, signature);
 475 
 476             File destJar;
 477             if (outdir != null) {
 478                 destJar = new File(outdir, pr.getRelativePath());
 479             } else {
 480                 // in-place
 481                 jar.delete();
 482                 destJar = jar;
 483             }
 484             destJar.delete();
 485             destJar.getParentFile().mkdirs();
 486             signedJar.renameTo(destJar);
 487             if (verbose) {
 488                 System.out.println("Signed as " + destJar.getPath());
 489             }
 490         }
 491     }
 492 
 493     private void signAsBLOB(final File jar, File signedJar, JarSignature signature)
 494             throws IOException, NoSuchAlgorithmException, SignatureException
 495     {
 496         if (signature == null) {
 497             throw new IllegalStateException("Should retrieve signature first");
 498         }
 499 
 500         InputStreamSource in = () -> new FileInputStream(jar);
 501         if (!signedJar.isFile()) {
 502             signedJar.createNewFile();
 503         }
 504         FileOutputStream fos = new FileOutputStream(signedJar);
 505         signature.signJarAsBLOB(in, new ZipOutputStream(fos));
 506     }
 507 
 508     public void makeAll(MakeAllParams makeAllParams) throws PackagerException {
 509         final String exe = (Platform.getPlatform() == Platform.WINDOWS) ? ".exe" : "";
 510         String jHome = System.getenv("JAVA_HOME");
 511         if (jHome == null) {
 512             jHome = System.getProperty("java.home");
 513         }
 514         if (jHome == null) {
 515             throw new PackagerException("ERR_MissingJavaHome");
 516         }
 517 
 518         final File javac = new File(new File(jHome), "bin/javac" + exe);
 519 
 520         String jfxHome = System.getenv("JAVAFX_HOME");
 521         if (jfxHome == null) {
 522             jfxHome = System.getProperty("javafx.home");
 523         }
 524         if (jfxHome == null) {
 525             throw new PackagerException("ERR_MissingJavaFxHome");
 526         }
 527 
 528         final String srcDirName = "src";
 529         final String compiledDirName = "compiled";
 530         final String distDirName = "dist";
 531         final String outfileName = "dist";
 532         final String jarName = outfileName + ".jar";
 533 
 534         final File distDir = new File(distDirName);
 535 
 536         final File compiledDir = new File(compiledDirName);
 537         compiledDir.mkdir();
 538 
 539         try {
 540             final File tmpFile = File.createTempFile("javac", "sources", new File("."));
 541             tmpFile.deleteOnExit();
 542             try (FileWriter sources = new FileWriter(tmpFile)) {
 543                 scanAndCopy(new PackagerResource(new File(srcDirName), "."), sources, compiledDir);
 544             }
 545             String classpath = jfxHome + "/../lib/jfxrt.jar";
 546             if (makeAllParams.classpath != null) {
 547                 classpath += File.pathSeparator + makeAllParams.classpath;
 548             }
 549             if (makeAllParams.verbose) {
 550                 System.out.println("Executing javac:");
 551                 System.out.printf("%s %s %s %s %s %s%n",
 552                         javac.getAbsolutePath(),
 553                         "-d", compiledDirName,
 554                         "-cp", classpath,
 555                         "@" + tmpFile.getAbsolutePath());
 556             }
 557             int ret = execute(
 558                     javac.getAbsolutePath(),
 559                     "-d", compiledDirName,
 560                     "-cp", classpath,
 561                     "@" + tmpFile.getAbsolutePath());
 562             if (ret != 0) {
 563                 throw new PackagerException("ERR_JavacFailed", Integer.toString(ret));
 564             }
 565         } catch (PackagerException e) {
 566             throw e;
 567         } catch (Exception e) {
 568             throw new PackagerException(e, "ERR_MakeAllJavacFailed");
 569         }
 570 
 571         CreateJarParams cjp = new CreateJarParams();
 572         cjp.applicationClass = makeAllParams.appClass;
 573         cjp.preloader = makeAllParams.preloader;
 574         cjp.classpath = makeAllParams.classpath;
 575         cjp.css2bin = false;
 576         cjp.outdir = distDir;
 577         cjp.outfile = jarName;
 578         cjp.addResource(compiledDir, ".");
 579 
 580         packageAsJar(cjp);
 581 
 582         DeployParams dp = new DeployParams();
 583         dp.applicationClass = makeAllParams.appClass;
 584         dp.appName = makeAllParams.appName;
 585         dp.description = "Application description";
 586         dp.height = makeAllParams.height;
 587         dp.width = makeAllParams.width;
 588         dp.vendor = "Application vendor";
 589         dp.outdir = distDir;
 590         dp.outfile = outfileName;
 591         dp.addResource(distDir, jarName);
 592         //noinspection deprecation
 593         dp.setBundleType(BundleType.ALL);
 594 
 595         generateDeploymentPackages(dp);
 596 
 597         deleteDirectory(compiledDir);
 598     }
 599 
 600     @SuppressWarnings("unchecked")
 601     private static int execute(Object ... args) throws IOException, InterruptedException {
 602         final ArrayList<String> argsList = new ArrayList<>();
 603         for (Object a : args) {
 604             if (a instanceof List) {
 605                 argsList.addAll((List)a);
 606             } else if (a instanceof String) {
 607                 argsList.add((String)a);
 608             }
 609         }
 610         final Process p = Runtime.getRuntime().exec(argsList.toArray(new String[argsList.size()]));
 611         final BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream()));
 612         Thread t = new Thread(() -> {
 613             try {
 614                 String line;
 615                 while ((line = in.readLine()) != null) {
 616                     System.out.println(line);
 617                 }
 618             } catch (IOException ioe) {
 619                 com.oracle.tools.packager.Log.verbose(ioe);
 620             }
 621         });
 622         t.setDaemon(true);
 623         t.start();
 624         final BufferedReader err = new BufferedReader(new InputStreamReader(p.getErrorStream()));
 625         t = new Thread(() -> {
 626             try {
 627                 String line;
 628                 while ((line = err.readLine()) != null) {
 629                     System.err.println(line);
 630                 }
 631             } catch (IOException ioe) {
 632                 Log.verbose(ioe);
 633             }
 634         });
 635         t.setDaemon(true);
 636         t.start();
 637         return p.waitFor();
 638     }
 639 
 640     private static void scanAndCopy(PackagerResource dir, Writer out, File outdir) throws PackagerException {
 641         if (!dir.getFile().exists()) {
 642             throw new PackagerException("ERR_MissingDirectory", dir.getFile().getName());
 643         }
 644         File[] dirFilesList = dir.getFile().listFiles();
 645         if ((dirFilesList == null) || (dirFilesList.length == 0)) {
 646             throw new PackagerException("ERR_EmptySourceDirectory", dir.getFile().getName());
 647         }
 648         try {
 649             for (File f : dirFilesList) {
 650                 if (f.isDirectory()) {
 651                     scanAndCopy(new PackagerResource(dir.getBaseDir(), f), out, outdir);
 652                 } else if (f.getName().endsWith(".java")) {
 653                     out.write('\'' + f.getAbsolutePath().replace('\\', '/') + "\'\n");
 654                 } else {
 655                     copyFileToOutDir(new FileInputStream(f),
 656                             new File(outdir.getPath() + File.separator
 657                                     + dir.getRelativePath() + File.separator
 658                                     + f.getName()));
 659                 }
 660             }
 661         } catch (IOException ex) {
 662             throw new PackagerException("ERR_FileCopyFailed", dir.getFile().getName());
 663         }
 664     }
 665 
 666     private String encodeAsBase64(byte inp[]) {
 667         return Base64.getEncoder().encodeToString(inp);
 668     }
 669 
 670     private static void copyFileToOutDir(
 671             InputStream isa, File fout) throws PackagerException {
 672 
 673         final File outDir = fout.getParentFile();
 674         if (!outDir.exists() && !outDir.mkdirs()) {
 675             throw new PackagerException("ERR_CreatingDirFailed", outDir.getPath());
 676         }
 677         try (InputStream is = isa; OutputStream out = new FileOutputStream(fout)) {
 678             byte[] buf = new byte[16384];
 679             int len;
 680             while ((len = is.read(buf)) > 0) {
 681                 out.write(buf, 0, len);
 682             }
 683         } catch (IOException ex) {
 684             throw new PackagerException(ex, "ERR_FileCopyFailed", outDir.getPath());
 685         }
 686     }
 687 
 688     private void jar(
 689             Manifest manifest, List<PackagerResource> files,
 690             File importJarFile, JarOutputStream jar, Filter filter)
 691             throws IOException, PackagerException {
 692         try {
 693             jar.putNextEntry(new ZipEntry("META-INF/"));
 694             jar.closeEntry();
 695             jar.putNextEntry(new ZipEntry(JarFile.MANIFEST_NAME));
 696             manifest.write(jar);
 697             jar.closeEntry();
 698 
 699             alreadyAddedEntries.add("META-INF/");
 700             if (importJarFile != null) { //updating jar file
 701                 copyFromOtherJar(jar, importJarFile);
 702             } else { //normal situation
 703                 for (PackagerResource pr : files) {
 704                     jar(pr.getFile(), jar, filter,
 705                             pr.getBaseDir().getAbsolutePath().length() + 1);
 706                 }
 707             }
 708         } finally {
 709             jar.close();
 710             alreadyAddedEntries.clear();
 711         }
 712     }
 713 
 714     private Set<String> alreadyAddedEntries = new HashSet<>();
 715     private void createParentEntries(String relativePath, JarOutputStream jar) throws IOException {
 716         String[] pathComponents = relativePath.split("/");
 717         StringBuilder pathSB = new StringBuilder();
 718         // iterating over directories only, the last component is the file
 719         // or will be created next time.
 720         for (int i = 0; i < pathComponents.length - 1; i++) {
 721             pathSB.append(pathComponents[i]).append("/");
 722             if (!alreadyAddedEntries.contains(pathSB.toString())) {
 723                 jar.putNextEntry(new ZipEntry(pathSB.toString()));
 724                 jar.closeEntry();
 725             }
 726             alreadyAddedEntries.add(pathSB.toString());
 727         }
 728     }
 729 
 730     //add everything but manifest from given jar file
 731     private void copyFromOtherJar(JarOutputStream jar, File inputFile) throws IOException {
 732         JarFile inJar = new JarFile(inputFile);
 733 
 734         Enumeration<JarEntry> all = inJar.entries();
 735         while (all.hasMoreElements()) {
 736             JarEntry je = all.nextElement();
 737 
 738             //skip manifest or root manifest dir entry (can not add duplicate)
 739             if ("META-INF/MANIFEST.MF".equals(je.getName().toUpperCase())
 740                     || "META-INF/".equals(je.getName().toUpperCase())) {
 741                 continue;
 742             }
 743 
 744             jar.putNextEntry(new JarEntry(je.getName()));
 745 
 746             byte b[] = new byte[65000];
 747             int i;
 748             try (InputStream in = inJar.getInputStream(je)) {
 749                 while ((i = in.read(b)) > 0) {
 750                     jar.write(b, 0, i);
 751                 }
 752             }
 753 
 754             jar.closeEntry();
 755         }
 756     }
 757 
 758     private void jar(File f, JarOutputStream jar, Filter filter, int cut)
 759             throws IOException, PackagerException {
 760         if (!f.exists()) {
 761             throw new FileNotFoundException("Input folder does not exist ["
 762                     +f.getAbsolutePath()+"]");
 763         }
 764 
 765         if (f.isDirectory()) {
 766             File[] children = f.listFiles();
 767             if (children != null) {
 768                 for (File innerFile : children) {
 769                     jar(innerFile, jar, filter, cut);
 770                 }
 771             }
 772         } else if (filter == Filter.ALL
 773                 || (filter == Filter.CLASSES_ONLY && f.getName().endsWith(".class"))
 774                 || (filter == Filter.RESOURCES && isResource(f.getAbsolutePath()))) {
 775             final String absPath = f.getAbsolutePath();
 776             if (absPath.endsWith("META-INF\\MANIFEST.MF")
 777                     || absPath.endsWith("META-INF/MANIFEST.MF")) {
 778                 return;
 779             }
 780             createParentEntries(absPath.substring(cut).replace('\\', '/'), jar);
 781             if (createJarParams.css2bin && f.getName().endsWith(".css")) {
 782                 // generate bss file into temporary directory
 783                 int startOfExt = absPath.lastIndexOf(".") + 1;
 784                 String bssFileName = absPath
 785                         .substring(cut, startOfExt)
 786                         .concat("bss");
 787 
 788                 File bssFile = new File(bssTmpDir, bssFileName);
 789                 bssFile.getParentFile().mkdirs();
 790 
 791                 createBinaryCss(absPath, bssFile.getAbsolutePath());
 792                 jar.putNextEntry(new ZipEntry(bssFileName.replace('\\', '/')));
 793                 f = bssFile;
 794             } else {
 795                 jar.putNextEntry(new ZipEntry(absPath.substring(cut).replace('\\', '/')));
 796             }
 797 
 798             byte b[] = new byte[65000];
 799             int i;
 800 
 801             try (FileInputStream in = new FileInputStream(f)) {
 802                 while ((i = in.read(b)) > 0) {
 803                     jar.write(b, 0, i);
 804                 }
 805             }
 806             jar.closeEntry();
 807         }
 808     }
 809 
 810     private void createBinaryCss(List<PackagerResource> cssResources, File outdir)
 811             throws PackagerException {
 812         for (PackagerResource cssRes: cssResources) {
 813             String relPath = cssRes.getRelativePath();
 814             createBinaryCss(cssRes.getFile(), outdir, relPath);
 815         }
 816     }
 817 
 818     private void createBinaryCss(File f, File outdir, String relPath)
 819             throws PackagerException {
 820         if (f.isDirectory()) {
 821             File[] children = f.listFiles();
 822             if (children != null) {
 823                 for (File innerFile : children) {
 824                     createBinaryCss(innerFile, outdir, relPath + '/' + innerFile.getName());
 825                 }
 826             }
 827         } else if (f.getName().endsWith(".css")) {
 828             String cssFileName = f.getAbsolutePath();
 829             String bssFileName = new File(outdir.getAbsolutePath(),
 830                     replaceExtensionByBSS(relPath))
 831                     .getAbsolutePath();
 832             createBinaryCss(cssFileName, bssFileName);
 833         }
 834     }
 835 
 836     // Returns path to jfxrt.jar relatively to jar containing PackagerLib.class
 837     private String getJfxrtPath() throws PackagerException {
 838         String theClassFile = "PackagerLib.class";
 839         Class theClass = PackagerLib.class;
 840         String classUrl = theClass.getResource(theClassFile).toString();
 841 
 842         if (!classUrl.startsWith("jar:file:") || !classUrl.contains("!")){
 843             throw new PackagerException("ERR_CantFindRuntime");
 844         }
 845 
 846         // Strip everything after and including the "!"
 847         classUrl = classUrl.substring(0, classUrl.lastIndexOf("!"));
 848         // Strip everything after the last "/" or "\" to get rid of the jar filename
 849         int lastIndexOfSlash = Math.max(classUrl.lastIndexOf("/"), classUrl.lastIndexOf("\\"));
 850 
 851         return classUrl.substring(0, lastIndexOfSlash)
 852                 + "/../lib/jfxrt.jar!/";
 853     }
 854 
 855     private Class loadClassFromRuntime(String className) throws PackagerException {
 856         try {
 857             ClassLoader cl = getClassLoader();
 858             return cl.loadClass(className);
 859         } catch (ClassNotFoundException ex) {
 860             throw new PackagerException(ex, "ERR_CantFindRuntime");
 861         }
 862     }
 863 
 864     private void createBinaryCss(String cssFile, String binCssFile) throws PackagerException {
 865         String ofname = (binCssFile != null)
 866                 ? binCssFile
 867                 : replaceExtensionByBSS(cssFile);
 868 
 869         // create parent directories
 870         File of = new File(ofname);
 871         File parentFile = of.getParentFile();
 872         if (parentFile != null) {
 873             parentFile.mkdirs();
 874         }
 875 
 876         // Using reflection because CSS parser is part of runtime
 877         // and we want to avoid dependency on jfxrt during build
 878         Class<?> clazz;
 879         try {
 880             clazz = Class.forName("com.sun.javafx.css.parser.Css2Bin");
 881         } catch (ClassNotFoundException e) {
 882             // class was not found with default class loader, trying to
 883             // locate it by loading from jfxrt.jar
 884             clazz = loadClassFromRuntime("com.sun.javafx.css.parser.Css2Bin");
 885         }
 886 
 887         try {
 888             Method m = clazz.getMethod("convertToBinary", String.class, String.class);
 889             m.invoke(null, cssFile, ofname);
 890         } catch (Exception ex) {
 891             Throwable causeEx = ex.getCause();
 892             String cause = (causeEx != null) ? causeEx.getMessage()
 893                     : bundle.getString("ERR_UnknownReason");
 894 
 895             throw new PackagerException(ex, "ERR_BSSConversionFailed", cssFile, cause);
 896         }
 897     }
 898 
 899     private static String replaceExtensionByBSS(String cssName) {
 900         return cssName.substring(0, cssName.lastIndexOf(".") + 1).concat("bss");
 901     }
 902 
 903 
 904     private boolean isResource(String name) {
 905         if (name.endsWith(".class")) {
 906             return false;
 907         }
 908         if (name.endsWith(".java")) {
 909             return false;
 910         }
 911         if (name.endsWith(".fx")) {
 912             return false;
 913         }
 914         if (name.endsWith(".cvsignore")) {
 915             return false;
 916         }
 917         if (name.endsWith(".hgignore")) {
 918             return false;
 919         }
 920         if (name.endsWith("vssver.scc")) {
 921             return false;
 922         }
 923         if (name.endsWith(".DS_Store")) {
 924             return false;
 925         }
 926         if (name.endsWith("~")) {
 927             return false;
 928         }
 929         name = name.replace('\\', '/');
 930         if (name.contains("/CVS/")) {
 931             return false;
 932         }
 933         if (name.contains("/.svn/")) {
 934             return false;
 935         }
 936         if (name.contains("/.hg/")) {
 937             return false;
 938         }
 939         if (name.contains("/.#")) {
 940             return false;
 941         }
 942         if (name.contains("/._")) {
 943             return false;
 944         }
 945         if (name.endsWith("#") && name.contains("/#")) {
 946             return false;
 947         }
 948         if (name.endsWith("%") && name.contains("/%")) {
 949             return false;
 950         }
 951         if (name.endsWith("MANIFEST.MF")) {
 952             return false;
 953         }
 954         return true;
 955     }
 956 
 957     private static boolean deleteDirectory(File dir) {
 958         if (dir == null || !dir.exists()) {
 959             return false;
 960         }
 961 
 962         if (dir.isDirectory()) {
 963             for (String file : dir.list()) {
 964                 deleteDirectory(new File(dir, file));
 965             }
 966         }
 967         return dir.delete();
 968     }
 969 }
--- EOF ---