Ignore:
Timestamp:
2018-04-19T20:37:16+02:00 (18 months ago)
Author:
Don-vip
Message:

see #16204 - Allow to start and close JOSM in WebStart sandbox mode (where every external access is denied). This was very useful to reproduce some very tricky bugs that occured in real life but were almost impossible to diagnose.

Location:
trunk/src/org/openstreetmap/josm/tools
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/tools/HttpClient.java

    r13358 r13647  
    7070
    7171    static {
    72         CookieHandler.setDefault(new CookieManager());
     72        try {
     73            CookieHandler.setDefault(new CookieManager());
     74        } catch (SecurityException e) {
     75            Logging.log(Logging.LEVEL_ERROR, "Unable to set default cookie handler", e);
     76        }
    7377    }
    7478
  • trunk/src/org/openstreetmap/josm/tools/I18n.java

    r13544 r13647  
    351351        // FIXME: This must be updated after we switch to Java 9.
    352352        // See https://docs.oracle.com/javase/9/docs/api/java/util/spi/LocaleServiceProvider.html
    353         System.setProperty("java.locale.providers", "SPI,JRE,CLDR"); // Don't call Utils.updateSystemProperty to avoid spurious log at startup
     353        try {
     354            // Don't call Utils.updateSystemProperty to avoid spurious log at startup
     355            System.setProperty("java.locale.providers", "SPI,JRE,CLDR");
     356        } catch (SecurityException e) {
     357            // Don't call Logging class, it may not be fully initialized yet
     358            System.err.println("Unable to set locale providers: " + e.getMessage());
     359        }
    354360    }
    355361
  • trunk/src/org/openstreetmap/josm/tools/ImageProvider.java

    r13493 r13647  
    256256
    257257    /** set of class loaders to take images from */
    258     protected static final Set<ClassLoader> classLoaders = new HashSet<>(Arrays.asList(
    259             ClassLoader.getSystemClassLoader(), ImageProvider.class.getClassLoader()));
     258    protected static final Set<ClassLoader> classLoaders = new HashSet<>();
     259    static {
     260        try {
     261            classLoaders.add(ClassLoader.getSystemClassLoader());
     262        } catch (SecurityException e) {
     263            Logging.log(Logging.LEVEL_ERROR, "Unable to get system classloader", e);
     264        }
     265        try {
     266            classLoaders.add(ImageProvider.class.getClassLoader());
     267        } catch (SecurityException e) {
     268            Logging.log(Logging.LEVEL_ERROR, "Unable to get application classloader", e);
     269        }
     270    }
    260271
    261272    /** directories in which images are searched */
     
    11321143        switch (type) {
    11331144        case SVG:
    1134             SVGDiagram svg;
     1145            SVGDiagram svg = null;
    11351146            synchronized (getSvgUniverse()) {
    1136                 URI uri = getSvgUniverse().loadSVG(path);
    1137                 svg = getSvgUniverse().getDiagram(uri);
     1147                try {
     1148                    URI uri = getSvgUniverse().loadSVG(path);
     1149                    svg = getSvgUniverse().getDiagram(uri);
     1150                } catch (SecurityException e) {
     1151                    Logging.log(Logging.LEVEL_WARN, "Unable to read SVG", e);
     1152                }
    11381153            }
    11391154            return svg == null ? null : new ImageResource(svg);
     
    11491164                }
    11501165            } catch (IOException e) {
    1151                 Logging.warn(e);
     1166                Logging.log(Logging.LEVEL_WARN, "Unable to read image", e);
     1167                Logging.debug(e);
    11521168            }
    11531169            return img == null ? null : new ImageResource(img);
     
    11671183        } else {
    11681184            File f = new File(path, name);
    1169             if ((path != null || f.isAbsolute()) && f.exists())
    1170                 return Utils.fileToURL(f);
     1185            try {
     1186                if ((path != null || f.isAbsolute()) && f.exists())
     1187                    return Utils.fileToURL(f);
     1188            } catch (SecurityException e) {
     1189                Logging.log(Logging.LEVEL_ERROR, "Unable to access image", e);
     1190            }
    11711191        }
    11721192        return null;
     
    11931213        // Try user-data directory
    11941214        if (Config.getDirs() != null) {
    1195             String dir = new File(Config.getDirs().getUserDataDirectory(false), "images").getAbsolutePath();
     1215            File file = new File(Config.getDirs().getUserDataDirectory(false), "images");
     1216            String dir = file.getPath();
     1217            try {
     1218                dir = file.getAbsolutePath();
     1219            } catch (SecurityException e) {
     1220                Logging.debug(e);
     1221            }
    11961222            try {
    11971223                u = getImageUrl(dir, imageName);
     
    17301756            }
    17311757            return bi;
    1732         } catch (IOException e) {
    1733             throw new IIOException("Can't get input stream from URL!", e);
     1758        } catch (SecurityException e) {
     1759            throw new IOException(e);
    17341760        }
    17351761    }
     
    19421968     */
    19431969    public static void shutdown(boolean now) {
    1944         if (now) {
    1945             IMAGE_FETCHER.shutdownNow();
    1946         } else {
    1947             IMAGE_FETCHER.shutdown();
     1970        try {
     1971            if (now) {
     1972                IMAGE_FETCHER.shutdownNow();
     1973            } else {
     1974                IMAGE_FETCHER.shutdown();
     1975            }
     1976        } catch (SecurityException ex) {
     1977            Logging.log(Logging.LEVEL_ERROR, "Failed to shutdown background image fetcher.", ex);
    19481978        }
    19491979    }
  • trunk/src/org/openstreetmap/josm/tools/Logging.java

    r13263 r13647  
    6464        ConsoleHandler stderr = new ConsoleHandler();
    6565        LOGGER.addHandler(stderr);
    66         stderr.setLevel(LEVEL_WARN);
     66        try {
     67            stderr.setLevel(LEVEL_WARN);
     68        } catch (SecurityException e) {
     69            System.err.println("Unable to set logging level: " + e.getMessage());
     70        }
    6771
    6872        ConsoleHandler stdout = new ConsoleHandler() {
     
    8185        };
    8286        LOGGER.addHandler(stdout);
    83         stdout.setLevel(Level.ALL);
     87        try {
     88            stdout.setLevel(Level.ALL);
     89        } catch (SecurityException e) {
     90            System.err.println("Unable to set logging level: " + e.getMessage());
     91        }
    8492
    8593        LOGGER.addHandler(WARNINGS);
     
    404412        private int messagesLogged;
    405413
    406         RememberWarningHandler() {
    407             setLevel(LEVEL_WARN);
    408         }
    409 
    410414        synchronized void clear() {
    411415            messagesLogged = 0;
     
    415419        @Override
    416420        public synchronized void publish(LogRecord record) {
    417             if (!isLoggable(record)) {
     421            // We don't use setLevel + isLoggable to work in WebStart Sandbox mode
     422            if (record.getLevel().intValue() < LEVEL_WARN.intValue()) {
    418423                return;
    419424            }
  • trunk/src/org/openstreetmap/josm/tools/Platform.java

    r12784 r13647  
    5454    public static Platform determinePlatform() {
    5555        if (platform == null) {
    56             String os = System.getProperty("os.name");
     56            String os = Utils.getSystemProperty("os.name");
    5757            if (os == null) {
    5858                Logging.warn("Your operating system has no name, so I'm guessing its some kind of *nix.");
  • trunk/src/org/openstreetmap/josm/tools/PlatformHook.java

    r13504 r13647  
    268268     */
    269269    default boolean isOpenJDK() {
    270         String javaHome = System.getProperty("java.home");
     270        String javaHome = Utils.getSystemProperty("java.home");
    271271        return javaHome != null && javaHome.contains("openjdk");
    272272    }
  • trunk/src/org/openstreetmap/josm/tools/PlatformHookOsx.java

    r13450 r13647  
    33
    44import static org.openstreetmap.josm.tools.I18n.tr;
     5import static org.openstreetmap.josm.tools.Utils.getSystemProperty;
    56
    67import java.awt.Desktop;
     
    393394    @Override
    394395    public String getOSDescription() {
    395         return System.getProperty("os.name") + ' ' + System.getProperty("os.version");
     396        return getSystemProperty("os.name") + ' ' + getSystemProperty("os.version");
    396397    }
    397398
     
    421422    @Override
    422423    public File getDefaultCacheDirectory() {
    423         return new File(System.getProperty("user.home")+"/Library/Caches",
     424        return new File(getSystemProperty("user.home")+"/Library/Caches",
    424425                Main.pref.getJOSMDirectoryBaseName());
    425426    }
     
    427428    @Override
    428429    public File getDefaultPrefDirectory() {
    429         return new File(System.getProperty("user.home")+"/Library/Preferences",
     430        return new File(getSystemProperty("user.home")+"/Library/Preferences",
    430431                Main.pref.getJOSMDirectoryBaseName());
    431432    }
     
    433434    @Override
    434435    public File getDefaultUserDataDirectory() {
    435         return new File(System.getProperty("user.home")+"/Library",
     436        return new File(getSystemProperty("user.home")+"/Library",
    436437                Main.pref.getJOSMDirectoryBaseName());
    437438    }
  • trunk/src/org/openstreetmap/josm/tools/PlatformHookUnixoid.java

    r13450 r13647  
    33
    44import static org.openstreetmap.josm.tools.I18n.tr;
     5import static org.openstreetmap.josm.tools.Utils.getSystemEnv;
     6import static org.openstreetmap.josm.tools.Utils.getSystemProperty;
    57
    68import java.awt.Desktop;
     
    4547    public void preStartupHook() {
    4648        // See #12022 - Disable GNOME ATK Java wrapper as it causes a lot of serious trouble
    47         if ("org.GNOME.Accessibility.AtkWrapper".equals(System.getProperty("assistive_technologies"))) {
     49        if ("org.GNOME.Accessibility.AtkWrapper".equals(getSystemProperty("assistive_technologies"))) {
    4850            System.clearProperty("assistive_technologies");
    4951        }
     
    154156     */
    155157    public String getJavaPackageDetails() {
    156         String home = System.getProperty("java.home");
     158        String home = getSystemProperty("java.home");
    157159        if (home.contains("java-8-openjdk") || home.contains("java-1.8.0-openjdk")) {
    158160            return getPackageDetails("openjdk-8-jre", "java-1_8_0-openjdk", "java-1.8.0-openjdk");
     
    202204
    203205    private String buildOSDescription() {
    204         String osName = System.getProperty("os.name");
     206        String osName = getSystemProperty("os.name");
    205207        if ("Linux".equalsIgnoreCase(osName)) {
    206208            try {
     
    339341    private static File getDotDirectory() {
    340342        String dirName = "." + Main.pref.getJOSMDirectoryBaseName().toLowerCase(Locale.ENGLISH);
    341         return new File(System.getProperty("user.home"), dirName);
     343        return new File(getSystemProperty("user.home"), dirName);
    342344    }
    343345
     
    357359            return new File(getDotDirectory(), "cache");
    358360        } else {
    359             String xdgCacheDir = System.getenv("XDG_CACHE_HOME");
     361            String xdgCacheDir = getSystemEnv("XDG_CACHE_HOME");
    360362            if (xdgCacheDir != null && !xdgCacheDir.isEmpty()) {
    361363                return new File(xdgCacheDir, Main.pref.getJOSMDirectoryBaseName());
    362364            } else {
    363                 return new File(System.getProperty("user.home") + File.separator +
     365                return new File(getSystemProperty("user.home") + File.separator +
    364366                        ".cache" + File.separator + Main.pref.getJOSMDirectoryBaseName());
    365367            }
     
    372374            return getDotDirectory();
    373375        } else {
    374             String xdgConfigDir = System.getenv("XDG_CONFIG_HOME");
     376            String xdgConfigDir = getSystemEnv("XDG_CONFIG_HOME");
    375377            if (xdgConfigDir != null && !xdgConfigDir.isEmpty()) {
    376378                return new File(xdgConfigDir, Main.pref.getJOSMDirectoryBaseName());
    377379            } else {
    378                 return new File(System.getProperty("user.home") + File.separator +
     380                return new File(getSystemProperty("user.home") + File.separator +
    379381                        ".config" + File.separator + Main.pref.getJOSMDirectoryBaseName());
    380382            }
     
    387389            return getDotDirectory();
    388390        } else {
    389             String xdgDataDir = System.getenv("XDG_DATA_HOME");
     391            String xdgDataDir = getSystemEnv("XDG_DATA_HOME");
    390392            if (xdgDataDir != null && !xdgDataDir.isEmpty()) {
    391393                return new File(xdgDataDir, Main.pref.getJOSMDirectoryBaseName());
    392394            } else {
    393                 return new File(System.getProperty("user.home") + File.separator +
     395                return new File(getSystemProperty("user.home") + File.separator +
    394396                        ".local" + File.separator + "share" + File.separator + Main.pref.getJOSMDirectoryBaseName());
    395397            }
  • trunk/src/org/openstreetmap/josm/tools/PlatformHookWindows.java

    r13487 r13647  
    2727import static java.awt.event.KeyEvent.VK_Z;
    2828import static org.openstreetmap.josm.tools.I18n.tr;
     29import static org.openstreetmap.josm.tools.Utils.getSystemEnv;
     30import static org.openstreetmap.josm.tools.Utils.getSystemProperty;
    2931import static org.openstreetmap.josm.tools.WinRegistry.HKEY_LOCAL_MACHINE;
    3032
     
    270272    @Override
    271273    public String getOSDescription() {
    272         return Utils.strip(System.getProperty("os.name")) + ' ' +
    273                 ((System.getenv("ProgramFiles(x86)") == null) ? "32" : "64") + "-Bit";
     274        return Utils.strip(getSystemProperty("os.name")) + ' ' +
     275                ((getSystemEnv("ProgramFiles(x86)") == null) ? "32" : "64") + "-Bit";
    274276    }
    275277
     
    316318            }
    317319            sb.append(" (").append(getCurrentBuild()).append(')');
    318         } catch (ReflectiveOperationException | JosmRuntimeException e) {
    319             Logging.error(e);
     320        } catch (ReflectiveOperationException | JosmRuntimeException | NoClassDefFoundError e) {
     321            Logging.log(Logging.LEVEL_ERROR, "Unable to get Windows build number", e);
     322            Logging.debug(e);
    320323        }
    321324        return sb.toString();
     
    473476    @Override
    474477    public File getDefaultCacheDirectory() {
    475         String p = System.getenv("LOCALAPPDATA");
     478        String p = getSystemEnv("LOCALAPPDATA");
    476479        if (p == null || p.isEmpty()) {
    477480            // Fallback for Windows OS earlier than Windows Vista, where the variable is not defined
    478             p = System.getenv("APPDATA");
     481            p = getSystemEnv("APPDATA");
    479482        }
    480483        return new File(new File(p, Main.pref.getJOSMDirectoryBaseName()), "cache");
     
    483486    @Override
    484487    public File getDefaultPrefDirectory() {
    485         return new File(System.getenv("APPDATA"), Main.pref.getJOSMDirectoryBaseName());
     488        return new File(getSystemEnv("APPDATA"), Main.pref.getJOSMDirectoryBaseName());
    486489    }
    487490
     
    524527            return;
    525528
    526         String javaLibPath = System.getProperty("java.home") + File.separator + "lib";
     529        String javaLibPath = getSystemProperty("java.home") + File.separator + "lib";
    527530        Path templateFile = FileSystems.getDefault().getPath(javaLibPath, templateFileName);
    528         if (!Files.isReadable(templateFile)) {
    529             Logging.warn("extended font config - unable to find font config template file {0}", templateFile.toString());
     531        String templatePath = templateFile.toString();
     532        if (templatePath.startsWith("null") || !Files.isReadable(templateFile)) {
     533            Logging.warn("extended font config - unable to find font config template file {0}", templatePath);
    530534            return;
    531535        }
     
    612616        // Use more low-level method to find the installed fonts.
    613617        List<String> fontsAvail = new ArrayList<>();
    614         Path fontPath = FileSystems.getDefault().getPath(System.getenv("SYSTEMROOT"), "Fonts");
     618        Path fontPath = FileSystems.getDefault().getPath(getSystemEnv("SYSTEMROOT"), "Fonts");
    615619        try (DirectoryStream<Path> ds = Files.newDirectoryStream(fontPath)) {
    616620            for (Path p : ds) {
  • trunk/src/org/openstreetmap/josm/tools/RightAndLefthandTraffic.java

    r13559 r13647  
    2525import org.openstreetmap.josm.data.osm.DataSet;
    2626import org.openstreetmap.josm.data.osm.DownloadPolicy;
    27 import org.openstreetmap.josm.data.osm.UploadPolicy;
    2827import org.openstreetmap.josm.data.osm.OsmPrimitive;
    2928import org.openstreetmap.josm.data.osm.Relation;
    3029import org.openstreetmap.josm.data.osm.RelationMember;
     30import org.openstreetmap.josm.data.osm.UploadPolicy;
    3131import org.openstreetmap.josm.data.osm.Way;
    3232import org.openstreetmap.josm.io.IllegalDataException;
     
    6969        if (optimizedWays.isEmpty()) {
    7070            optimizedWays = computeOptimizedBoundaries();
    71             saveOptimizedBoundaries(optimizedWays);
     71            try {
     72                saveOptimizedBoundaries(optimizedWays);
     73            } catch (IOException | SecurityException e) {
     74                Logging.log(Logging.LEVEL_ERROR, "Unable to save optimized boundaries", e);
     75            }
    7276        }
    7377        rlCache = new GeoPropertyIndex<>(new DefaultGeoProperty(optimizedWays), 24);
     
    154158    }
    155159
    156     private static void saveOptimizedBoundaries(Collection<Way> optimizedWays) {
     160    private static void saveOptimizedBoundaries(Collection<Way> optimizedWays) throws IOException {
    157161        DataSet ds = optimizedWays.iterator().next().getDataSet();
    158162        File file = new File(Config.getDirs().getCacheDirectory(true), "left-right-hand-traffic.osm");
     
    163167            w.writeContent(ds);
    164168            w.footer();
    165         } catch (IOException ex) {
    166             throw new JosmRuntimeException(ex);
    167169        }
    168170    }
     
    172174                Config.getDirs().getCacheDirectory(false).getPath(), "left-right-hand-traffic.osm"))) {
    173175           return OsmReader.parseDataSet(is, null).getWays();
    174         } catch (IllegalDataException | IOException | InvalidPathException ex) {
     176        } catch (IllegalDataException | IOException | InvalidPathException | SecurityException ex) {
    175177            Logging.trace(ex);
    176178            return Collections.emptyList();
  • trunk/src/org/openstreetmap/josm/tools/Utils.java

    r13597 r13647  
    887887     */
    888888    public static File getJosmTempDir() {
    889         String tmpDir = System.getProperty("java.io.tmpdir");
     889        String tmpDir = getSystemProperty("java.io.tmpdir");
    890890        if (tmpDir == null) {
    891891            return null;
     
    12681268
    12691269    /**
     1270     * Gets the value of the specified environment variable.
     1271     * An environment variable is a system-dependent external named value.
     1272     * @param name name the name of the environment variable
     1273     * @return the string value of the variable;
     1274     *         {@code null} if the variable is not defined in the system environment or if a security exception occurs.
     1275     * @see System#getenv(String)
     1276     * @since 13647
     1277     */
     1278    public static String getSystemEnv(String name) {
     1279        try {
     1280            return System.getenv(name);
     1281        } catch (SecurityException e) {
     1282            Logging.log(Logging.LEVEL_ERROR, "Unable to get system env", e);
     1283            return null;
     1284        }
     1285    }
     1286
     1287    /**
     1288     * Gets the system property indicated by the specified key.
     1289     * @param key the name of the system property.
     1290     * @return the string value of the system property;
     1291     *         {@code null} if there is no property with that key or if a security exception occurs.
     1292     * @see System#getProperty(String)
     1293     * @since 13647
     1294     */
     1295    public static String getSystemProperty(String key) {
     1296        try {
     1297            return System.getProperty(key);
     1298        } catch (SecurityException e) {
     1299            Logging.log(Logging.LEVEL_ERROR, "Unable to get system property", e);
     1300            return null;
     1301        }
     1302    }
     1303
     1304    /**
    12701305     * Updates a given system property.
    12711306     * @param key The property key
     
    12761311    public static String updateSystemProperty(String key, String value) {
    12771312        if (value != null) {
    1278             String old = System.setProperty(key, value);
    1279             if (Logging.isDebugEnabled() && !value.equals(old)) {
    1280                 if (!key.toLowerCase(Locale.ENGLISH).contains("password")) {
    1281                     Logging.debug("System property '" + key + "' set to '" + value + "'. Old value was '" + old + '\'');
    1282                 } else {
    1283                     Logging.debug("System property '" + key + "' changed.");
     1313            try {
     1314                String old = System.setProperty(key, value);
     1315                if (Logging.isDebugEnabled() && !value.equals(old)) {
     1316                    if (!key.toLowerCase(Locale.ENGLISH).contains("password")) {
     1317                        Logging.debug("System property '" + key + "' set to '" + value + "'. Old value was '" + old + '\'');
     1318                    } else {
     1319                        Logging.debug("System property '" + key + "' changed.");
     1320                    }
    12841321                }
    1285             }
    1286             return old;
     1322                return old;
     1323            } catch (SecurityException e) {
     1324                // Don't call Logging class, it may not be fully initialized yet
     1325                System.err.println("Unable to update system property: " + e.getMessage());
     1326            }
    12871327        }
    12881328        return null;
     
    15921632     */
    15931633    public static int getJavaVersion() {
    1594         String version = System.getProperty("java.version");
     1634        String version = getSystemProperty("java.version");
    15951635        if (version.startsWith("1.")) {
    15961636            version = version.substring(2);
     
    16131653     */
    16141654    public static int getJavaUpdate() {
    1615         String version = System.getProperty("java.version");
     1655        String version = getSystemProperty("java.version");
    16161656        if (version.startsWith("1.")) {
    16171657            version = version.substring(2);
     
    16431683     */
    16441684    public static int getJavaBuild() {
    1645         String version = System.getProperty("java.runtime.version");
     1685        String version = getSystemProperty("java.runtime.version");
    16461686        int bPos = version.indexOf('b');
    16471687        int pPos = version.indexOf('+');
     
    17571797        try {
    17581798            return new ScriptEngineManager(null).getEngineByName("JavaScript");
    1759         } catch (SecurityException e) {
    1760             Logging.error(e);
     1799        } catch (SecurityException | ExceptionInInitializerError e) {
     1800            Logging.log(Logging.LEVEL_ERROR, "Unable to get JavaScript engine", e);
    17611801            return null;
    17621802        }
     
    17891829                            FileTime jarTime = Files.readAttributes(jarFile, BasicFileAttributes.class).lastModifiedTime();
    17901830                            // Copy it to temp directory (hopefully free of exclamation mark) if needed (missing or older jar)
    1791                             Path jarCopy = Paths.get(System.getProperty("java.io.tmpdir")).resolve(filename);
     1831                            Path jarCopy = Paths.get(getSystemProperty("java.io.tmpdir")).resolve(filename);
    17921832                            if (!jarCopy.toFile().exists() ||
    17931833                                    Files.readAttributes(jarCopy, BasicFileAttributes.class).lastModifiedTime().compareTo(jarTime) < 0) {
  • trunk/src/org/openstreetmap/josm/tools/bugreport/ReportedException.java

    r12620 r13647  
    1010import java.util.Collections;
    1111import java.util.ConcurrentModificationException;
     12import java.util.HashMap;
    1213import java.util.IdentityHashMap;
    1314import java.util.Iterator;
     
    4041
    4142    /**
    42      * We capture all stack traces on exception creation. This allows us to trace synchonization problems better. We cannot be really sure what
    43      * happened but we at least see which threads
    44      */
    45     private final transient Map<Thread, StackTraceElement[]> allStackTraces;
     43     * We capture all stack traces on exception creation. This allows us to trace synchonization problems better.
     44     * We cannot be really sure what happened but we at least see which threads
     45     */
     46    private final transient Map<Thread, StackTraceElement[]> allStackTraces = new HashMap<>();
    4647    private final LinkedList<Section> sections = new LinkedList<>();
    4748    private final transient Thread caughtOnThread;
     
    5556        super(exception);
    5657
    57         allStackTraces = Thread.getAllStackTraces();
     58        try {
     59            allStackTraces.putAll(Thread.getAllStackTraces());
     60        } catch (SecurityException e) {
     61            Logging.log(Logging.LEVEL_ERROR, "Unable to get thread stack traces", e);
     62        }
    5863        this.caughtOnThread = caughtOnThread;
    5964    }
Note: See TracChangeset for help on using the changeset viewer.