1 /*
   2  * Copyright (c) 2012, 2019, 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 jdk.jpackage.internal;
  27 
  28 import java.io.*;
  29 import java.nio.charset.Charset;
  30 import java.nio.file.Files;
  31 import java.text.MessageFormat;
  32 import java.util.*;
  33 import java.util.regex.Matcher;
  34 import java.util.regex.Pattern;
  35 
  36 import static jdk.jpackage.internal.WindowsBundlerParam.*;
  37 
  38 public class WinMsiBundler  extends AbstractBundler {
  39 
  40     private static final ResourceBundle I18N = ResourceBundle.getBundle(
  41             "jdk.jpackage.internal.resources.WinResources");
  42 
  43     public static final BundlerParamInfo<WinAppBundler> APP_BUNDLER =
  44             new WindowsBundlerParam<>(
  45             I18N.getString("param.msi-bundler.name"),
  46             I18N.getString("param.msi-bundler.description"),
  47             "win.app.bundler",
  48             WinAppBundler.class,
  49             params -> new WinAppBundler(),
  50             null);
  51 
  52     public static final BundlerParamInfo<Boolean> CAN_USE_WIX36 =
  53             new WindowsBundlerParam<>(
  54             I18N.getString("param.can-use-wix36.name"),
  55             I18N.getString("param.can-use-wix36.description"),
  56             "win.msi.canUseWix36",
  57             Boolean.class,
  58             params -> false,
  59             (s, p) -> Boolean.valueOf(s));
  60 
  61     public static final BundlerParamInfo<File> MSI_IMAGE_DIR =
  62             new WindowsBundlerParam<>(
  63             I18N.getString("param.image-dir.name"),
  64             I18N.getString("param.image-dir.description"),
  65             "win.msi.imageDir",
  66             File.class,
  67             params -> {
  68                 File imagesRoot = IMAGES_ROOT.fetchFrom(params);
  69                 if (!imagesRoot.exists()) imagesRoot.mkdirs();
  70                 return new File(imagesRoot, "win-msi.image");
  71             },
  72             (s, p) -> null);
  73 
  74     public static final BundlerParamInfo<File> WIN_APP_IMAGE =
  75             new WindowsBundlerParam<>(
  76             I18N.getString("param.app-dir.name"),
  77             I18N.getString("param.app-dir.description"),
  78             "win.app.image",
  79             File.class,
  80             null,
  81             (s, p) -> null);
  82 
  83     public static final StandardBundlerParam<Boolean> MSI_SYSTEM_WIDE  =
  84             new StandardBundlerParam<>(
  85                     I18N.getString("param.system-wide.name"),
  86                     I18N.getString("param.system-wide.description"),
  87                     Arguments.CLIOptions.WIN_PER_USER_INSTALLATION.getId(),
  88                     Boolean.class,
  89                     params -> true, // MSIs default to system wide
  90                     // valueOf(null) is false,
  91                     // and we actually do want null
  92                     (s, p) -> (s == null || "null".equalsIgnoreCase(s))? null
  93                             : Boolean.valueOf(s)
  94             );
  95 
  96 
  97     public static final StandardBundlerParam<String> PRODUCT_VERSION =
  98             new StandardBundlerParam<>(
  99                     I18N.getString("param.product-version.name"),
 100                     I18N.getString("param.product-version.description"),
 101                     "win.msi.productVersion",
 102                     String.class,
 103                     VERSION::fetchFrom,
 104                     (s, p) -> s
 105             );
 106 
 107     public static final BundlerParamInfo<UUID> UPGRADE_UUID =
 108             new WindowsBundlerParam<>(
 109             I18N.getString("param.upgrade-uuid.name"),
 110             I18N.getString("param.upgrade-uuid.description"),
 111             Arguments.CLIOptions.WIN_UPGRADE_UUID.getId(),
 112             UUID.class,
 113             params -> UUID.randomUUID(),
 114             (s, p) -> UUID.fromString(s));
 115 
 116     private static final String TOOL_CANDLE = "candle.exe";
 117     private static final String TOOL_LIGHT = "light.exe";
 118     // autodetect just v3.7, v3.8, 3.9, 3.10 and 3.11
 119     private static final String AUTODETECT_DIRS =
 120             ";C:\\Program Files (x86)\\WiX Toolset v3.11\\bin;"
 121             + "C:\\Program Files\\WiX Toolset v3.11\\bin;"
 122             + "C:\\Program Files (x86)\\WiX Toolset v3.10\\bin;"
 123             + "C:\\Program Files\\WiX Toolset v3.10\\bin;"
 124             + "C:\\Program Files (x86)\\WiX Toolset v3.9\\bin;"
 125             + "C:\\Program Files\\WiX Toolset v3.9\\bin;"
 126             + "C:\\Program Files (x86)\\WiX Toolset v3.8\\bin;"
 127             + "C:\\Program Files\\WiX Toolset v3.8\\bin;"
 128             + "C:\\Program Files (x86)\\WiX Toolset v3.7\\bin;"
 129             + "C:\\Program Files\\WiX Toolset v3.7\\bin";
 130 
 131     public static final BundlerParamInfo<String> TOOL_CANDLE_EXECUTABLE =
 132             new WindowsBundlerParam<>(
 133             I18N.getString("param.candle-path.name"),
 134             I18N.getString("param.candle-path.description"),
 135             "win.msi.candle.exe",
 136             String.class,
 137             params -> {
 138                 for (String dirString : (System.getenv("PATH") +
 139                         AUTODETECT_DIRS).split(";")) {
 140                     File f = new File(dirString.replace("\"", ""), TOOL_CANDLE);
 141                     if (f.isFile()) {
 142                         return f.toString();
 143                     }
 144                 }
 145                 return null;
 146             },
 147             null);
 148 
 149     public static final BundlerParamInfo<String> TOOL_LIGHT_EXECUTABLE =
 150             new WindowsBundlerParam<>(
 151             I18N.getString("param.light-path.name"),
 152             I18N.getString("param.light-path.description"),
 153             "win.msi.light.exe",
 154             String.class,
 155             params -> {
 156                 for (String dirString : (System.getenv("PATH") +
 157                         AUTODETECT_DIRS).split(";")) {
 158                     File f = new File(dirString.replace("\"", ""), TOOL_LIGHT);
 159                     if (f.isFile()) {
 160                         return f.toString();
 161                     }
 162                 }
 163                 return null;
 164             },
 165             null);
 166 
 167     public static final StandardBundlerParam<Boolean> MENU_HINT =
 168         new WindowsBundlerParam<>(
 169                 I18N.getString("param.menu-shortcut-hint.name"),
 170                 I18N.getString("param.menu-shortcut-hint.description"),
 171                 Arguments.CLIOptions.WIN_MENU_HINT.getId(),
 172                 Boolean.class,
 173                 params -> false,
 174                 // valueOf(null) is false,
 175                 // and we actually do want null in some cases
 176                 (s, p) -> (s == null ||
 177                         "null".equalsIgnoreCase(s))? true : Boolean.valueOf(s)
 178         );
 179 
 180     public static final StandardBundlerParam<Boolean> SHORTCUT_HINT =
 181         new WindowsBundlerParam<>(
 182                 I18N.getString("param.desktop-shortcut-hint.name"),
 183                 I18N.getString("param.desktop-shortcut-hint.description"),
 184                 Arguments.CLIOptions.WIN_SHORTCUT_HINT.getId(),
 185                 Boolean.class,
 186                 params -> false,
 187                 // valueOf(null) is false,
 188                 // and we actually do want null in some cases
 189                 (s, p) -> (s == null ||
 190                        "null".equalsIgnoreCase(s))? false : Boolean.valueOf(s)
 191         );
 192 
 193     @Override
 194     public String getName() {
 195         return I18N.getString("msi.bundler.name");
 196     }
 197 
 198     @Override
 199     public String getDescription() {
 200         return I18N.getString("msi.bundler.description");
 201     }
 202 
 203     @Override
 204     public String getID() {
 205         return "msi";
 206     }
 207 
 208     @Override
 209     public String getBundleType() {
 210         return "INSTALLER";
 211     }
 212 
 213     @Override
 214     public Collection<BundlerParamInfo<?>> getBundleParameters() {
 215         Collection<BundlerParamInfo<?>> results = new LinkedHashSet<>();
 216         results.addAll(WinAppBundler.getAppBundleParameters());
 217         results.addAll(getMsiBundleParameters());
 218         return results;
 219     }
 220 
 221     public static Collection<BundlerParamInfo<?>> getMsiBundleParameters() {
 222         return Arrays.asList(
 223                 DESCRIPTION,
 224                 MENU_GROUP,
 225                 MENU_HINT,
 226                 PRODUCT_VERSION,
 227                 SHORTCUT_HINT,
 228                 MSI_SYSTEM_WIDE,
 229                 VENDOR,
 230                 LICENSE_FILE,
 231                 INSTALLDIR_CHOOSER
 232         );
 233     }
 234 
 235     @Override
 236     public File execute(Map<String, ? super Object> params,
 237             File outputParentDir) throws PackagerException {
 238         return bundle(params, outputParentDir);
 239     }
 240 
 241     @Override
 242     public boolean supported(boolean platformInstaller) {
 243         return (Platform.getPlatform() == Platform.WINDOWS);
 244     }
 245 
 246     private static String findToolVersion(String toolName) {
 247         try {
 248             if (toolName == null || "".equals(toolName)) return null;
 249 
 250             ProcessBuilder pb = new ProcessBuilder(
 251                     toolName,
 252                     "/?");
 253             VersionExtractor ve = new VersionExtractor("version (\\d+.\\d+)");
 254             // not interested in the output
 255             IOUtils.exec(pb, Log.isDebug(), true, ve);
 256             String version = ve.getVersion();
 257             Log.verbose(MessageFormat.format(
 258                     I18N.getString("message.tool-version"),
 259                     toolName, version));
 260             return version;
 261         } catch (Exception e) {
 262             if (Log.isDebug()) {
 263                 Log.verbose(e);
 264             }
 265             return null;
 266         }
 267     }
 268 
 269     @Override
 270     public boolean validate(Map<String, ? super Object> p)
 271             throws UnsupportedPlatformException, ConfigException {
 272         try {
 273             if (p == null) throw new ConfigException(
 274                     I18N.getString("error.parameters-null"),
 275                     I18N.getString("error.parameters-null.advice"));
 276 
 277             // run basic validation to ensure requirements are met
 278             // we are not interested in return code, only possible exception
 279             APP_BUNDLER.fetchFrom(p).validate(p);
 280 
 281             String candleVersion =
 282                     findToolVersion(TOOL_CANDLE_EXECUTABLE.fetchFrom(p));
 283             String lightVersion =
 284                     findToolVersion(TOOL_LIGHT_EXECUTABLE.fetchFrom(p));
 285 
 286             // WiX 3.0+ is required
 287             String minVersion = "3.0";
 288             boolean bad = false;
 289 
 290             if (VersionExtractor.isLessThan(candleVersion, minVersion)) {
 291                 Log.verbose(MessageFormat.format(
 292                         I18N.getString("message.wrong-tool-version"),
 293                         TOOL_CANDLE, candleVersion, minVersion));
 294                 bad = true;
 295             }
 296             if (VersionExtractor.isLessThan(lightVersion, minVersion)) {
 297                 Log.verbose(MessageFormat.format(
 298                         I18N.getString("message.wrong-tool-version"),
 299                         TOOL_LIGHT, lightVersion, minVersion));
 300                 bad = true;
 301             }
 302 
 303             if (bad){
 304                 throw new ConfigException(
 305                         I18N.getString("error.no-wix-tools"),
 306                         I18N.getString("error.no-wix-tools.advice"));
 307             }
 308 
 309             if (!VersionExtractor.isLessThan(lightVersion, "3.6")) {
 310                 Log.verbose(I18N.getString("message.use-wix36-features"));
 311                 p.put(CAN_USE_WIX36.getID(), Boolean.TRUE);
 312             }
 313 
 314             /********* validate bundle parameters *************/
 315 
 316             String version = PRODUCT_VERSION.fetchFrom(p);
 317             if (!isVersionStringValid(version)) {
 318                 throw new ConfigException(
 319                         MessageFormat.format(I18N.getString(
 320                                 "error.version-string-wrong-format"), version),
 321                         MessageFormat.format(I18N.getString(
 322                                 "error.version-string-wrong-format.advice"),
 323                                 PRODUCT_VERSION.getID()));
 324             }
 325 
 326             // only one mime type per association, at least one file extension
 327             List<Map<String, ? super Object>> associations =
 328                     FILE_ASSOCIATIONS.fetchFrom(p);
 329             if (associations != null) {
 330                 for (int i = 0; i < associations.size(); i++) {
 331                     Map<String, ? super Object> assoc = associations.get(i);
 332                     List<String> mimes = FA_CONTENT_TYPE.fetchFrom(assoc);
 333                     if (mimes.size() > 1) {
 334                         throw new ConfigException(MessageFormat.format(
 335                                 I18N.getString("error.too-many-content-"
 336                                 + "types-for-file-association"), i),
 337                                 I18N.getString("error.too-many-content-"
 338                                 + "types-for-file-association.advice"));
 339                     }
 340                 }
 341             }
 342 
 343             return true;
 344         } catch (RuntimeException re) {
 345             if (re.getCause() instanceof ConfigException) {
 346                 throw (ConfigException) re.getCause();
 347             } else {
 348                 throw new ConfigException(re);
 349             }
 350         }
 351     }
 352 
 353     // http://msdn.microsoft.com/en-us/library/aa370859%28v=VS.85%29.aspx
 354     // The format of the string is as follows:
 355     //     major.minor.build
 356     // The first field is the major version and has a maximum value of 255.
 357     // The second field is the minor version and has a maximum value of 255.
 358     // The third field is called the build version or the update version and
 359     // has a maximum value of 65,535.
 360     static boolean isVersionStringValid(String v) {
 361         if (v == null) {
 362             return true;
 363         }
 364 
 365         String p[] = v.split("\\.");
 366         if (p.length > 3) {
 367             Log.verbose(I18N.getString(
 368                     "message.version-string-too-many-components"));
 369             return false;
 370         }
 371 
 372         try {
 373             int val = Integer.parseInt(p[0]);
 374             if (val < 0 || val > 255) {
 375                 Log.verbose(I18N.getString(
 376                         "error.version-string-major-out-of-range"));
 377                 return false;
 378             }
 379             if (p.length > 1) {
 380                 val = Integer.parseInt(p[1]);
 381                 if (val < 0 || val > 255) {
 382                     Log.verbose(I18N.getString(
 383                             "error.version-string-minor-out-of-range"));
 384                     return false;
 385                 }
 386             }
 387             if (p.length > 2) {
 388                 val = Integer.parseInt(p[2]);
 389                 if (val < 0 || val > 65535) {
 390                     Log.verbose(I18N.getString(
 391                             "error.version-string-build-out-of-range"));
 392                     return false;
 393                 }
 394             }
 395         } catch (NumberFormatException ne) {
 396             Log.verbose(I18N.getString("error.version-string-part-not-number"));
 397             Log.verbose(ne);
 398             return false;
 399         }
 400 
 401         return true;
 402     }
 403 
 404     private boolean prepareProto(Map<String, ? super Object> p)
 405                 throws PackagerException, IOException {
 406         File appImage = StandardBundlerParam.getPredefinedAppImage(p);
 407         File appDir = null;
 408 
 409         // we either have an application image or need to build one
 410         if (appImage != null) {
 411             appDir = new File(
 412                     MSI_IMAGE_DIR.fetchFrom(p), APP_NAME.fetchFrom(p));
 413             // copy everything from appImage dir into appDir/name
 414             IOUtils.copyRecursive(appImage.toPath(), appDir.toPath());
 415         } else {
 416             appDir = APP_BUNDLER.fetchFrom(p).doBundle(p,
 417                     MSI_IMAGE_DIR.fetchFrom(p), true);
 418         }
 419 
 420         p.put(WIN_APP_IMAGE.getID(), appDir);
 421 
 422         String licenseFile = LICENSE_FILE.fetchFrom(p);
 423         if (licenseFile != null) {
 424             // need to copy license file to the working directory and convert to rtf if needed
 425             File lfile = new File(licenseFile);
 426             File destFile = new File(CONFIG_ROOT.fetchFrom(p), lfile.getName());
 427             IOUtils.copyFile(lfile, destFile);
 428             ensureByMutationFileIsRTF(destFile);
 429         }
 430 
 431         // copy file association icons
 432         List<Map<String, ? super Object>> fileAssociations =
 433                 FILE_ASSOCIATIONS.fetchFrom(p);
 434         for (Map<String, ? super Object> fa : fileAssociations) {
 435             File icon = FA_ICON.fetchFrom(fa); // TODO FA_ICON_ICO
 436             if (icon == null) {
 437                 continue;
 438             }
 439 
 440             File faIconFile = new File(appDir, icon.getName());
 441 
 442             if (icon.exists()) {
 443                 try {
 444                     IOUtils.copyFile(icon, faIconFile);
 445                 } catch (IOException e) {
 446                     Log.verbose(e);
 447                 }
 448             }
 449         }
 450 
 451         return appDir != null;
 452     }
 453 
 454     public File bundle(Map<String, ? super Object> p, File outdir)
 455             throws PackagerException {
 456         if (!outdir.isDirectory() && !outdir.mkdirs()) {
 457             throw new PackagerException("error.cannot-create-output-dir",
 458                     outdir.getAbsolutePath());
 459         }
 460         if (!outdir.canWrite()) {
 461             throw new PackagerException("error.cannot-write-to-output-dir",
 462                     outdir.getAbsolutePath());
 463         }
 464 
 465         // validate we have valid tools before continuing
 466         String light = TOOL_LIGHT_EXECUTABLE.fetchFrom(p);
 467         String candle = TOOL_CANDLE_EXECUTABLE.fetchFrom(p);
 468         if (light == null || !new File(light).isFile() ||
 469             candle == null || !new File(candle).isFile()) {
 470             Log.verbose(MessageFormat.format(
 471                    I18N.getString("message.light-file-string"), light));
 472             Log.verbose(MessageFormat.format(
 473                    I18N.getString("message.candle-file-string"), candle));
 474             throw new PackagerException("error.no-wix-tools");
 475         }
 476 
 477         File imageDir = MSI_IMAGE_DIR.fetchFrom(p);
 478         try {
 479             imageDir.mkdirs();
 480 
 481             boolean menuShortcut = MENU_HINT.fetchFrom(p);
 482             boolean desktopShortcut = SHORTCUT_HINT.fetchFrom(p);
 483             if (!menuShortcut && !desktopShortcut) {
 484                 // both can not be false - user will not find the app
 485                 Log.verbose(I18N.getString("message.one-shortcut-required"));
 486                 p.put(MENU_HINT.getID(), true);
 487             }
 488 
 489             if (prepareProto(p) && prepareWiXConfig(p)
 490                     && prepareBasicProjectConfig(p)) {
 491                 File configScriptSrc = getConfig_Script(p);
 492                 if (configScriptSrc.exists()) {
 493                     // we need to be running post script in the image folder
 494 
 495                     // NOTE: Would it be better to generate it to the image
 496                     // folder and save only if "verbose" is requested?
 497 
 498                     // for now we replicate it
 499                     File configScript =
 500                         new File(imageDir, configScriptSrc.getName());
 501                     IOUtils.copyFile(configScriptSrc, configScript);
 502                     Log.verbose(MessageFormat.format(
 503                             I18N.getString("message.running-wsh-script"),
 504                             configScript.getAbsolutePath()));
 505                     IOUtils.run("wscript",
 506                              configScript, false);
 507                 }
 508                 return buildMSI(p, outdir);
 509             }
 510             return null;
 511         } catch (IOException ex) {
 512             Log.verbose(ex);
 513             throw new PackagerException(ex);
 514         }
 515     }
 516 
 517     // name of post-image script
 518     private File getConfig_Script(Map<String, ? super Object> params) {
 519         return new File(CONFIG_ROOT.fetchFrom(params),
 520                 APP_NAME.fetchFrom(params) + "-post-image.wsf");
 521     }
 522 
 523     private boolean prepareBasicProjectConfig(
 524         Map<String, ? super Object> params) throws IOException {
 525         fetchResource(getConfig_Script(params).getName(),
 526                 I18N.getString("resource.post-install-script"),
 527                 (String) null,
 528                 getConfig_Script(params),
 529                 VERBOSE.fetchFrom(params),
 530                 RESOURCE_DIR.fetchFrom(params));
 531         return true;
 532     }
 533 
 534     private String relativePath(File basedir, File file) {
 535         return file.getAbsolutePath().substring(
 536                 basedir.getAbsolutePath().length() + 1);
 537     }
 538 
 539     boolean prepareMainProjectFile(
 540             Map<String, ? super Object> params) throws IOException {
 541         Map<String, String> data = new HashMap<>();
 542 
 543         UUID productGUID = UUID.randomUUID();
 544 
 545         Log.verbose(MessageFormat.format(
 546                 I18N.getString("message.generated-product-guid"),
 547                 productGUID.toString()));
 548 
 549         // we use random GUID for product itself but
 550         // user provided for upgrade guid
 551         // Upgrade guid is important to decide whether it is an upgrade of
 552         // installed app.  I.e. we need it to be the same for
 553         // 2 different versions of app if possible
 554         data.put("PRODUCT_GUID", productGUID.toString());
 555         data.put("PRODUCT_UPGRADE_GUID",
 556                 UPGRADE_UUID.fetchFrom(params).toString());
 557         data.put("UPGRADE_BLOCK", getUpgradeBlock(params));
 558 
 559         data.put("APPLICATION_NAME", APP_NAME.fetchFrom(params));
 560         data.put("APPLICATION_DESCRIPTION", DESCRIPTION.fetchFrom(params));
 561         data.put("APPLICATION_VENDOR", VENDOR.fetchFrom(params));
 562         data.put("APPLICATION_VERSION", PRODUCT_VERSION.fetchFrom(params));
 563 
 564         // WinAppBundler will add application folder again => step out
 565         File imageRootDir = WIN_APP_IMAGE.fetchFrom(params);
 566         File launcher = new File(imageRootDir,
 567                 WinAppBundler.getLauncherName(params));
 568 
 569         String launcherPath = relativePath(imageRootDir, launcher);
 570         data.put("APPLICATION_LAUNCHER", launcherPath);
 571 
 572         String iconPath = launcherPath.replace(".exe", ".ico");
 573 
 574         data.put("APPLICATION_ICON", iconPath);
 575 
 576         data.put("REGISTRY_ROOT", getRegistryRoot(params));
 577 
 578         boolean canUseWix36Features = CAN_USE_WIX36.fetchFrom(params);
 579         data.put("WIX36_ONLY_START",
 580                 canUseWix36Features ? "" : "<!--");
 581         data.put("WIX36_ONLY_END",
 582                 canUseWix36Features ? "" : "-->");
 583 
 584         if (MSI_SYSTEM_WIDE.fetchFrom(params)) {
 585             data.put("INSTALL_SCOPE", "perMachine");
 586         } else {
 587             data.put("INSTALL_SCOPE", "perUser");
 588         }
 589 
 590         data.put("PLATFORM", "x64");
 591         data.put("WIN64", "yes");
 592 
 593         data.put("UI_BLOCK", getUIBlock(params));
 594 









 595         List<Map<String, ? super Object>> secondaryLaunchers =
 596                 SECONDARY_LAUNCHERS.fetchFrom(params);
 597 
 598         StringBuilder secondaryLauncherIcons = new StringBuilder();
 599         for (int i = 0; i < secondaryLaunchers.size(); i++) {
 600             Map<String, ? super Object> sl = secondaryLaunchers.get(i);
 601             // <Icon Id="DesktopIcon.exe" SourceFile="APPLICATION_ICON" />
 602             if (SHORTCUT_HINT.fetchFrom(sl) || MENU_HINT.fetchFrom(sl)) {
 603                 File secondaryLauncher = new File(imageRootDir,
 604                         WinAppBundler.getLauncherName(sl));
 605                 String secondaryLauncherPath =
 606                         relativePath(imageRootDir, secondaryLauncher);
 607                 String secondaryLauncherIconPath =
 608                         secondaryLauncherPath.replace(".exe", ".ico");
 609 
 610                 secondaryLauncherIcons.append("        <Icon Id=\"Launcher");
 611                 secondaryLauncherIcons.append(i);
 612                 secondaryLauncherIcons.append(".exe\" SourceFile=\"");
 613                 secondaryLauncherIcons.append(secondaryLauncherIconPath);
 614                 secondaryLauncherIcons.append("\" />\r\n");
 615             }
 616         }
 617         data.put("SECONDARY_LAUNCHER_ICONS", secondaryLauncherIcons.toString());
 618 
 619         String wxs = RUNTIME_INSTALLER.fetchFrom(params) ?
 620                 MSI_PROJECT_TEMPLATE_SERVER_JRE : MSI_PROJECT_TEMPLATE;
 621 
 622         Writer w = new BufferedWriter(
 623                 new FileWriter(getConfig_ProjectFile(params)));
 624 
 625         String content = preprocessTextResource(
 626                 getConfig_ProjectFile(params).getName(),
 627                 I18N.getString("resource.wix-config-file"),
 628                 wxs, data, VERBOSE.fetchFrom(params),
 629                 RESOURCE_DIR.fetchFrom(params));
 630         w.write(content);
 631         w.close();
 632         return true;
 633     }
 634     private int id;
 635     private int compId;
 636     private final static String LAUNCHER_ID = "LauncherId";
 637 






















 638     /**
 639      * Overrides the dialog sequence in built-in dialog set "WixUI_InstallDir"
 640      * to exclude license dialog
 641      */
 642     private static final String TWEAK_FOR_EXCLUDING_LICENSE =
 643               "     <Publish Dialog=\"WelcomeDlg\" Control=\"Next\""
 644             + "              Event=\"NewDialog\" Value=\"InstallDirDlg\""
 645             + " Order=\"2\"> 1"
 646             + "     </Publish>\n"
 647             + "     <Publish Dialog=\"InstallDirDlg\" Control=\"Back\""
 648             + "              Event=\"NewDialog\" Value=\"WelcomeDlg\""
 649             + " Order=\"2\"> 1"
 650             + "     </Publish>\n";










 651 
 652     // Required upgrade element for installers which support major upgrade (when user
 653     // specifies --win-upgrade-uuid). We will allow downgrades.
 654     private static final String UPGRADE_BLOCK =
 655             "<MajorUpgrade AllowDowngrades=\"yes\"/>";
 656 
 657     private String getUpgradeBlock(Map<String, ? super Object> params) {
 658         if (UPGRADE_UUID.getIsDefaultValue()) {
 659             return "";
 660         } else {
 661             return UPGRADE_BLOCK;
 662         }
 663     }
 664 
 665     /**
 666      * Creates UI element using WiX built-in dialog sets
 667      *     - WixUI_InstallDir/WixUI_Minimal.
 668      * The dialog sets are the closest to what we want to implement.
 669      *
 670      * WixUI_Minimal for license dialog only
 671      * WixUI_InstallDir for installdir dialog only or for both
 672      * installdir/license dialogs
 673      */
 674     private String getUIBlock(Map<String, ? super Object> params) {
 675         String uiBlock = "     <UI/>\n"; // UI-less element








 676 
 677         if (INSTALLDIR_CHOOSER.fetchFrom(params)) {
 678             boolean enableTweakForExcludingLicense =
 679                     (getLicenseFile(params) == null);
 680             uiBlock = "     <UI>\n"
 681                     + "     <Property Id=\"WIXUI_INSTALLDIR\""
 682                     + " Value=\"APPLICATIONFOLDER\" />\n"
 683                     + "     <UIRef Id=\"WixUI_InstallDir\" />\n"
 684                     + (enableTweakForExcludingLicense ?
 685                             TWEAK_FOR_EXCLUDING_LICENSE : "")
 686                     +"     </UI>\n";
 687         } else if (getLicenseFile(params) != null) {
 688             uiBlock = "     <UI>\n"
 689                     + "     <UIRef Id=\"WixUI_Minimal\" />\n"
 690                     + "     </UI>\n";
 691         }
 692 
 693         return uiBlock;
 694     }
 695 
 696     private void walkFileTree(Map<String, ? super Object> params,
 697             File root, PrintStream out, String prefix) {
 698         List<File> dirs = new ArrayList<>();
 699         List<File> files = new ArrayList<>();
 700 
 701         if (!root.isDirectory()) {
 702             throw new RuntimeException(
 703                     MessageFormat.format(
 704                             I18N.getString("error.cannot-walk-directory"),
 705                             root.getAbsolutePath()));
 706         }
 707 
 708         // sort to files and dirs
 709         File[] children = root.listFiles();
 710         if (children != null) {
 711             for (File f : children) {
 712                 if (f.isDirectory()) {
 713                     dirs.add(f);
 714                 } else {
 715                     files.add(f);
 716                 }
 717             }
 718         }
 719 
 720         // have files => need to output component
 721         out.println(prefix + " <Component Id=\"comp" + (compId++)
 722                 + "\" DiskId=\"1\""
 723                 + " Guid=\"" + UUID.randomUUID().toString() + "\""
 724                 + " Win64=\"yes\""
 725                 + ">");
 726         out.println(prefix + "  <CreateFolder/>");
 727         out.println(prefix + "  <RemoveFolder Id=\"RemoveDir"
 728                 + (id++) + "\" On=\"uninstall\" />");
 729 
 730         boolean needRegistryKey = !MSI_SYSTEM_WIDE.fetchFrom(params);
 731         File imageRootDir = WIN_APP_IMAGE.fetchFrom(params);
 732         File launcherFile =
 733                 new File(imageRootDir, WinAppBundler.getLauncherName(params));
 734 
 735         // Find out if we need to use registry. We need it if
 736         //  - we doing user level install as file can not serve as KeyPath
 737         //  - if we adding shortcut in this component
 738 
 739         for (File f: files) {
 740             boolean isLauncher = f.equals(launcherFile);
 741             if (isLauncher) {
 742                 needRegistryKey = true;
 743             }
 744         }
 745 
 746         if (needRegistryKey) {
 747             // has to be under HKCU to make WiX happy
 748             out.println(prefix + "    <RegistryKey Root=\"HKCU\" "
 749                     + " Key=\"Software\\" + VENDOR.fetchFrom(params) + "\\"
 750                     + APP_NAME.fetchFrom(params) + "\""
 751                     + (CAN_USE_WIX36.fetchFrom(params) ?
 752                     ">" : " Action=\"createAndRemoveOnUninstall\">"));
 753             out.println(prefix
 754                     + "     <RegistryValue Name=\"Version\" Value=\""
 755                     + VERSION.fetchFrom(params)
 756                     + "\" Type=\"string\" KeyPath=\"yes\"/>");
 757             out.println(prefix + "   </RegistryKey>");
 758         }
 759 
 760         boolean menuShortcut = MENU_HINT.fetchFrom(params);
 761         boolean desktopShortcut = SHORTCUT_HINT.fetchFrom(params);
 762 
 763         Map<String, String> idToFileMap = new TreeMap<>();
 764         boolean launcherSet = false;
 765 
 766         for (File f : files) {
 767             boolean isLauncher = f.equals(launcherFile);
 768 
 769             launcherSet = launcherSet || isLauncher;
 770 
 771             boolean doShortcuts =
 772                 isLauncher && (menuShortcut || desktopShortcut);
 773 
 774             String thisFileId = isLauncher ? LAUNCHER_ID : ("FileId" + (id++));
 775             idToFileMap.put(f.getName(), thisFileId);
 776 
 777             out.println(prefix + "   <File Id=\"" +
 778                     thisFileId + "\""
 779                     + " Name=\"" + f.getName() + "\" "
 780                     + " Source=\"" + relativePath(imageRootDir, f) + "\""
 781                     + " ProcessorArchitecture=\"x64\"" + ">");
 782             if (doShortcuts && desktopShortcut) {
 783                 out.println(prefix
 784                         + "  <Shortcut Id=\"desktopShortcut\" Directory="
 785                         + "\"DesktopFolder\""
 786                         + " Name=\"" + APP_NAME.fetchFrom(params)
 787                         + "\" WorkingDirectory=\"INSTALLDIR\""
 788                         + " Advertise=\"no\" Icon=\"DesktopIcon.exe\""
 789                         + " IconIndex=\"0\" />");
 790             }
 791             if (doShortcuts && menuShortcut) {
 792                 out.println(prefix
 793                         + "     <Shortcut Id=\"ExeShortcut\" Directory="
 794                         + "\"ProgramMenuDir\""
 795                         + " Name=\"" + APP_NAME.fetchFrom(params)
 796                         + "\" Advertise=\"no\" Icon=\"StartMenuIcon.exe\""
 797                         + " IconIndex=\"0\" />");
 798             }
 799 
 800             List<Map<String, ? super Object>> secondaryLaunchers =
 801                     SECONDARY_LAUNCHERS.fetchFrom(params);
 802             for (int i = 0; i < secondaryLaunchers.size(); i++) {
 803                 Map<String, ? super Object> sl = secondaryLaunchers.get(i);
 804                 File secondaryLauncherFile = new File(imageRootDir,
 805                         WinAppBundler.getLauncherName(sl));
 806                 if (f.equals(secondaryLauncherFile)) {
 807                     if (SHORTCUT_HINT.fetchFrom(sl)) {
 808                         out.println(prefix
 809                                 + "  <Shortcut Id=\"desktopShortcut"
 810                                 + i + "\" Directory=\"DesktopFolder\""
 811                                 + " Name=\"" + APP_NAME.fetchFrom(sl)
 812                                 + "\" WorkingDirectory=\"INSTALLDIR\""
 813                                 + " Advertise=\"no\" Icon=\"Launcher"
 814                                 + i + ".exe\" IconIndex=\"0\" />");
 815                     }
 816                     if (MENU_HINT.fetchFrom(sl)) {
 817                         out.println(prefix
 818                                 + "     <Shortcut Id=\"ExeShortcut"
 819                                 + i + "\" Directory=\"ProgramMenuDir\""
 820                                 + " Name=\"" + APP_NAME.fetchFrom(sl)
 821                                 + "\" Advertise=\"no\" Icon=\"Launcher"
 822                                 + i + ".exe\" IconIndex=\"0\" />");
 823                         // Should we allow different menu groups?  Not for now.
 824                     }
 825                 }
 826             }
 827             out.println(prefix + "   </File>");
 828         }
 829 
 830         if (launcherSet) {
 831             List<Map<String, ? super Object>> fileAssociations =
 832                 FILE_ASSOCIATIONS.fetchFrom(params);
 833             String regName = APP_REGISTRY_NAME.fetchFrom(params);
 834             Set<String> defaultedMimes = new TreeSet<>();
 835             int count = 0;
 836             for (Map<String, ? super Object> fa : fileAssociations) {
 837                 String description = FA_DESCRIPTION.fetchFrom(fa);
 838                 List<String> extensions = FA_EXTENSIONS.fetchFrom(fa);
 839                 List<String> mimeTypes = FA_CONTENT_TYPE.fetchFrom(fa);
 840                 File icon = FA_ICON.fetchFrom(fa); // TODO FA_ICON_ICO
 841 
 842                 String mime = (mimeTypes == null ||
 843                     mimeTypes.isEmpty()) ? null : mimeTypes.get(0);
 844 
 845                 if (extensions == null) {
 846                     Log.verbose(I18N.getString(
 847                           "message.creating-association-with-null-extension"));
 848 
 849                     String entryName = regName + "File";
 850                     if (count > 0) {
 851                         entryName += "." + count;
 852                     }
 853                     count++;
 854                     out.print(prefix + "   <ProgId Id='" + entryName
 855                             + "' Description='" + description + "'");
 856                     if (icon != null && icon.exists()) {
 857                         out.print(" Icon='" + idToFileMap.get(icon.getName())
 858                                 + "' IconIndex='0'");
 859                     }
 860                     out.println(" />");
 861                 } else {
 862                     for (String ext : extensions) {
 863                         String entryName = regName + "File";
 864                         if (count > 0) {
 865                             entryName += "." + count;
 866                         }
 867                         count++;
 868 
 869                         out.print(prefix + "   <ProgId Id='" + entryName
 870                                 + "' Description='" + description + "'");
 871                         if (icon != null && icon.exists()) {
 872                             out.print(" Icon='"
 873                                     + idToFileMap.get(icon.getName())
 874                                     + "' IconIndex='0'");
 875                         }
 876                         out.println(">");
 877 
 878                         if (extensions == null) {
 879                             Log.verbose(I18N.getString(
 880                             "message.creating-association-with-null-extension"));
 881                         } else {
 882                             out.print(prefix + "    <Extension Id='"
 883                                     + ext + "' Advertise='no'");
 884                             if (mime == null) {
 885                                 out.println(">");
 886                             } else {
 887                                 out.println(" ContentType='" + mime + "'>");
 888                                 if (!defaultedMimes.contains(mime)) {
 889                                     out.println(prefix
 890                                             + "      <MIME ContentType='"
 891                                             + mime + "' Default='yes' />");
 892                                     defaultedMimes.add(mime);
 893                                 }
 894                             }
 895                             out.println(prefix
 896                                     + "      <Verb Id='open' Command='Open' "
 897                                     + "TargetFile='" + LAUNCHER_ID
 898                                     + "' Argument='\"%1\"' />");
 899                             out.println(prefix + "    </Extension>");
 900                         }
 901                         out.println(prefix + "   </ProgId>");
 902                     }
 903                 }
 904             }
 905         }
 906 
 907         out.println(prefix + " </Component>");
 908 
 909         for (File d : dirs) {
 910             out.println(prefix + " <Directory Id=\"dirid" + (id++)
 911                     + "\" Name=\"" + d.getName() + "\">");
 912             walkFileTree(params, d, out, prefix + " ");
 913             out.println(prefix + " </Directory>");
 914         }
 915     }
 916 
 917     String getRegistryRoot(Map<String, ? super Object> params) {
 918         if (MSI_SYSTEM_WIDE.fetchFrom(params)) {
 919             return "HKLM";
 920         } else {
 921             return "HKCU";
 922         }
 923     }
 924 
 925     boolean prepareContentList(Map<String, ? super Object> params)
 926             throws FileNotFoundException {
 927         File f = new File(
 928                 CONFIG_ROOT.fetchFrom(params), MSI_PROJECT_CONTENT_FILE);
 929         PrintStream out = new PrintStream(f);
 930 
 931         // opening
 932         out.println("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
 933         out.println("<Include>");
 934 
 935         out.println(" <Directory Id=\"TARGETDIR\" Name=\"SourceDir\">");
 936         if (MSI_SYSTEM_WIDE.fetchFrom(params)) {
 937             // install to programfiles
 938             out.println("  <Directory Id=\"ProgramFiles64Folder\" "
 939                         + "Name=\"PFiles\">");
 940         } else {
 941             // install to user folder
 942             out.println(
 943                     "  <Directory Name=\"AppData\" Id=\"LocalAppDataFolder\">");
 944         }
 945         out.println("   <Directory Id=\"APPLICATIONFOLDER\" Name=\""
 946                 + APP_NAME.fetchFrom(params) + "\">");
 947 
 948         // dynamic part
 949         id = 0;
 950         compId = 0; // reset counters
 951         walkFileTree(params, WIN_APP_IMAGE.fetchFrom(params), out, "    ");
 952 
 953         // closing
 954         out.println("   </Directory>");
 955         out.println("  </Directory>");
 956 
 957         // for shortcuts
 958         if (SHORTCUT_HINT.fetchFrom(params)) {
 959             out.println("  <Directory Id=\"DesktopFolder\" />");
 960         }
 961         if (MENU_HINT.fetchFrom(params)) {
 962             out.println("  <Directory Id=\"ProgramMenuFolder\">");
 963             out.println("    <Directory Id=\"ProgramMenuDir\" Name=\""
 964                     + MENU_GROUP.fetchFrom(params) + "\">");
 965             out.println("      <Component Id=\"comp" + (compId++) + "\""
 966                     + " Guid=\"" + UUID.randomUUID().toString() + "\""
 967                     + " Win64=\"yes\""
 968                     + ">");
 969             out.println("        <RemoveFolder Id=\"ProgramMenuDir\" "
 970                     + "On=\"uninstall\" />");
 971             // This has to be under HKCU to make WiX happy.
 972             // There are numberous discussions on this amoung WiX users
 973             // (if user A installs and user B uninstalls key is left behind)
 974             // there are suggested workarounds but none of them are appealing.
 975             // Leave it for now
 976             out.println(
 977                     "         <RegistryValue Root=\"HKCU\" Key=\"Software\\"
 978                     + VENDOR.fetchFrom(params) + "\\"
 979                     + APP_NAME.fetchFrom(params)
 980                     + "\" Type=\"string\" Value=\"\" />");
 981             out.println("      </Component>");
 982             out.println("    </Directory>");
 983             out.println(" </Directory>");
 984         }
 985 
 986         out.println(" </Directory>");
 987 
 988         out.println(" <Feature Id=\"DefaultFeature\" "
 989                 + "Title=\"Main Feature\" Level=\"1\">");
 990         for (int j = 0; j < compId; j++) {
 991             out.println("    <ComponentRef Id=\"comp" + j + "\" />");
 992         }
 993         // component is defined in the template.wsx
 994         out.println("    <ComponentRef Id=\"CleanupMainApplicationFolder\" />");
 995         out.println(" </Feature>");
 996         out.println("</Include>");
 997 
 998         out.close();
 999         return true;
1000     }
1001 
1002     private File getConfig_ProjectFile(Map<String, ? super Object> params) {
1003         return new File(CONFIG_ROOT.fetchFrom(params),
1004                 APP_NAME.fetchFrom(params) + ".wxs");
1005     }
1006 
1007     private String getLicenseFile(Map<String, ? super Object> p) {
1008         String licenseFile = LICENSE_FILE.fetchFrom(p);
1009         if (licenseFile != null) {
1010             File lfile = new File(licenseFile);
1011             File destFile = new File(CONFIG_ROOT.fetchFrom(p), lfile.getName());
1012             String filePath = destFile.getAbsolutePath();
1013             if (filePath.contains(" ")) {
1014                 return "\"" + filePath + "\"";
1015             } else {
1016                 return filePath;
1017             }
1018         }
1019 
1020         return null;
1021     }
1022 
1023     private boolean prepareWiXConfig(
1024             Map<String, ? super Object> params) throws IOException {
1025         return prepareMainProjectFile(params) && prepareContentList(params);
1026 
1027     }
1028     private final static String MSI_PROJECT_TEMPLATE = "template.wxs";
1029     private final static String MSI_PROJECT_TEMPLATE_SERVER_JRE =
1030             "template.jre.wxs";
1031     private final static String MSI_PROJECT_CONTENT_FILE = "bundle.wxi";
1032 
1033     private File buildMSI(Map<String, ? super Object> params, File outdir)
1034             throws IOException {
1035         File tmpDir = new File(BUILD_ROOT.fetchFrom(params), "tmp");
1036         File candleOut = new File(
1037                 tmpDir, APP_NAME.fetchFrom(params) +".wixobj");
1038         File msiOut = new File(
1039                 outdir, INSTALLER_FILE_NAME.fetchFrom(params) + ".msi");
1040 
1041         Log.verbose(MessageFormat.format(I18N.getString(
1042                 "message.preparing-msi-config"), msiOut.getAbsolutePath()));
1043 
1044         msiOut.getParentFile().mkdirs();
1045 
1046         // run candle
1047         ProcessBuilder pb = new ProcessBuilder(
1048                 TOOL_CANDLE_EXECUTABLE.fetchFrom(params),
1049                 "-nologo",
1050                 getConfig_ProjectFile(params).getAbsolutePath(),
1051                 "-ext", "WixUtilExtension",
1052                 "-out", candleOut.getAbsolutePath());
1053         pb = pb.directory(WIN_APP_IMAGE.fetchFrom(params));
1054         IOUtils.exec(pb, false);
1055 
1056         Log.verbose(MessageFormat.format(I18N.getString(
1057                 "message.generating-msi"), msiOut.getAbsolutePath()));
1058 
1059         boolean enableLicenseUI = (getLicenseFile(params) != null);
1060         boolean enableInstalldirUI = INSTALLDIR_CHOOSER.fetchFrom(params);
1061 
1062         List<String> commandLine = new ArrayList<>();
1063 
1064         commandLine.add(TOOL_LIGHT_EXECUTABLE.fetchFrom(params));
1065         if (enableLicenseUI) {
1066             commandLine.add("-dWixUILicenseRtf="+getLicenseFile(params));
1067         }
1068         commandLine.add("-nologo");
1069         commandLine.add("-spdb");
1070         commandLine.add("-sice:60");
1071                 // ignore warnings due to "missing launcguage info" (ICE60)
1072         commandLine.add(candleOut.getAbsolutePath());
1073         commandLine.add("-ext");
1074         commandLine.add("WixUtilExtension");
1075         if (enableLicenseUI || enableInstalldirUI) {
1076             commandLine.add("-ext");
1077             commandLine.add("WixUIExtension.dll");
1078         }







1079         commandLine.add("-out");
1080         commandLine.add(msiOut.getAbsolutePath());
1081 
1082         // create .msi
1083         pb = new ProcessBuilder(commandLine);
1084 
1085         pb = pb.directory(WIN_APP_IMAGE.fetchFrom(params));
1086         IOUtils.exec(pb, false);
1087 
1088         candleOut.delete();
1089         IOUtils.deleteRecursive(tmpDir);
1090 
1091         return msiOut;
1092     }
1093 
1094     public static void ensureByMutationFileIsRTF(File f) {
1095         if (f == null || !f.isFile()) return;
1096 
1097         try {
1098             boolean existingLicenseIsRTF = false;
1099 
1100             try (FileInputStream fin = new FileInputStream(f)) {
1101                 byte[] firstBits = new byte[7];
1102 
1103                 if (fin.read(firstBits) == firstBits.length) {
1104                     String header = new String(firstBits);
1105                     existingLicenseIsRTF = "{\\rtf1\\".equals(header);
1106                 }
1107             }
1108 
1109             if (!existingLicenseIsRTF) {
1110                 List<String> oldLicense = Files.readAllLines(f.toPath());
1111                 try (Writer w = Files.newBufferedWriter(
1112                         f.toPath(), Charset.forName("Windows-1252"))) {
1113                     w.write("{\\rtf1\\ansi\\ansicpg1252\\deff0\\deflang1033"
1114                             + "{\\fonttbl{\\f0\\fnil\\fcharset0 Arial;}}\n"
1115                             + "\\viewkind4\\uc1\\pard\\sa200\\sl276"
1116                             + "\\slmult1\\lang9\\fs20 ");
1117                     oldLicense.forEach(l -> {
1118                         try {
1119                             for (char c : l.toCharArray()) {
1120                                 // 0x00 <= ch < 0x20 Escaped (\'hh)
1121                                 // 0x20 <= ch < 0x80 Raw(non - escaped) char
1122                                 // 0x80 <= ch <= 0xFF Escaped(\ 'hh)
1123                                 // 0x5C, 0x7B, 0x7D (special RTF characters
1124                                 // \,{,})Escaped(\'hh)
1125                                 // ch > 0xff Escaped (\\ud###?)
1126                                 if (c < 0x10) {
1127                                     w.write("\\'0");
1128                                     w.write(Integer.toHexString(c));
1129                                 } else if (c > 0xff) {
1130                                     w.write("\\ud");
1131                                     w.write(Integer.toString(c));
1132                                     // \\uc1 is in the header and in effect
1133                                     // so we trail with a replacement char if
1134                                     // the font lacks that character - '?'
1135                                     w.write("?");
1136                                 } else if ((c < 0x20) || (c >= 0x80) ||
1137                                         (c == 0x5C) || (c == 0x7B) ||
1138                                         (c == 0x7D)) {
1139                                     w.write("\\'");
1140                                     w.write(Integer.toHexString(c));
1141                                 } else {
1142                                     w.write(c);
1143                                 }
1144                             }
1145                             // blank lines are interpreted as paragraph breaks
1146                             if (l.length() < 1) {
1147                                 w.write("\\par");
1148                             } else {
1149                                 w.write(" ");
1150                             }
1151                             w.write("\r\n");
1152                         } catch (IOException e) {
1153                             Log.verbose(e);
1154                         }
1155                     });
1156                     w.write("}\r\n");
1157                 }
1158             }
1159         } catch (IOException e) {
1160             Log.verbose(e);
1161         }
1162 
1163     }
1164 }
--- EOF ---