001// License: GPL. For details, see LICENSE file.
002package org.openstreetmap.josm.plugins;
003
004import static org.openstreetmap.josm.tools.I18n.tr;
005
006import java.io.File;
007import java.io.IOException;
008import java.io.InputStream;
009import java.lang.reflect.Constructor;
010import java.net.URL;
011import java.nio.file.Files;
012import java.nio.file.InvalidPathException;
013import java.text.MessageFormat;
014import java.util.ArrayList;
015import java.util.Collection;
016import java.util.LinkedList;
017import java.util.List;
018import java.util.Locale;
019import java.util.Map;
020import java.util.Optional;
021import java.util.TreeMap;
022import java.util.jar.Attributes;
023import java.util.jar.JarInputStream;
024import java.util.jar.Manifest;
025
026import javax.swing.ImageIcon;
027
028import org.openstreetmap.josm.Main;
029import org.openstreetmap.josm.data.Version;
030import org.openstreetmap.josm.tools.ImageProvider;
031import org.openstreetmap.josm.tools.LanguageInfo;
032import org.openstreetmap.josm.tools.Logging;
033import org.openstreetmap.josm.tools.Utils;
034
035/**
036 * Encapsulate general information about a plugin. This information is available
037 * without the need of loading any class from the plugin jar file.
038 *
039 * @author imi
040 * @since 153
041 */
042public class PluginInformation {
043
044    /** The plugin jar file. */
045    public File file;
046    /** The plugin name. */
047    public String name;
048    /** The lowest JOSM version required by this plugin (from plugin list). **/
049    public int mainversion;
050    /** The lowest JOSM version required by this plugin (from locally available jar). **/
051    public int localmainversion;
052    /** The plugin class name. */
053    public String className;
054    /** Determines if the plugin is an old version loaded for incompatibility with latest JOSM (from plugin list) */
055    public boolean oldmode;
056    /** The list of required plugins, separated by ';' (from plugin list). */
057    public String requires;
058    /** The list of required plugins, separated by ';' (from locally available jar). */
059    public String localrequires;
060    /** The plugin link (for documentation). */
061    public String link;
062    /** The plugin description. */
063    public String description;
064    /** Determines if the plugin must be loaded early or not. */
065    public boolean early;
066    /** The plugin author. */
067    public String author;
068    /** The plugin stage, determining the loading sequence order of plugins. */
069    public int stage = 50;
070    /** The plugin version (from plugin list). **/
071    public String version;
072    /** The plugin version (from locally available jar). **/
073    public String localversion;
074    /** The plugin download link. */
075    public String downloadlink;
076    /** The plugin icon path inside jar. */
077    public String iconPath;
078    /** The plugin icon. */
079    private ImageProvider icon;
080    /** Plugin can be loaded at any time and not just at start. */
081    public boolean canloadatruntime;
082    /** The libraries referenced in Class-Path manifest attribute. */
083    public List<URL> libraries = new LinkedList<>();
084    /** All manifest attributes. */
085    public final Map<String, String> attr = new TreeMap<>();
086    /** Empty icon for these plugins which have none */
087    private static final ImageIcon emptyIcon = ImageProvider.getEmpty(ImageProvider.ImageSizes.LARGEICON);
088
089    /**
090     * Creates a plugin information object by reading the plugin information from
091     * the manifest in the plugin jar.
092     *
093     * The plugin name is derived from the file name.
094     *
095     * @param file the plugin jar file
096     * @throws PluginException if reading the manifest fails
097     */
098    public PluginInformation(File file) throws PluginException {
099        this(file, file.getName().substring(0, file.getName().length()-4));
100    }
101
102    /**
103     * Creates a plugin information object for the plugin with name {@code name}.
104     * Information about the plugin is extracted from the manifest file in the plugin jar
105     * {@code file}.
106     * @param file the plugin jar
107     * @param name the plugin name
108     * @throws PluginException if reading the manifest file fails
109     */
110    public PluginInformation(File file, String name) throws PluginException {
111        if (!PluginHandler.isValidJar(file)) {
112            throw new PluginException(tr("Invalid jar file ''{0}''", file));
113        }
114        this.name = name;
115        this.file = file;
116        try (
117            InputStream fis = Files.newInputStream(file.toPath());
118            JarInputStream jar = new JarInputStream(fis)
119        ) {
120            Manifest manifest = jar.getManifest();
121            if (manifest == null)
122                throw new PluginException(tr("The plugin file ''{0}'' does not include a Manifest.", file.toString()));
123            scanManifest(manifest, false);
124            libraries.add(0, Utils.fileToURL(file));
125        } catch (IOException | InvalidPathException e) {
126            throw new PluginException(name, e);
127        }
128    }
129
130    /**
131     * Creates a plugin information object by reading plugin information in Manifest format
132     * from the input stream {@code manifestStream}.
133     *
134     * @param manifestStream the stream to read the manifest from
135     * @param name the plugin name
136     * @param url the download URL for the plugin
137     * @throws PluginException if the plugin information can't be read from the input stream
138     */
139    public PluginInformation(InputStream manifestStream, String name, String url) throws PluginException {
140        this.name = name;
141        try {
142            Manifest manifest = new Manifest();
143            manifest.read(manifestStream);
144            if (url != null) {
145                downloadlink = url;
146            }
147            scanManifest(manifest, url != null);
148        } catch (IOException e) {
149            throw new PluginException(name, e);
150        }
151    }
152
153    /**
154     * Updates the plugin information of this plugin information object with the
155     * plugin information in a plugin information object retrieved from a plugin
156     * update site.
157     *
158     * @param other the plugin information object retrieved from the update site
159     */
160    public void updateFromPluginSite(PluginInformation other) {
161        this.mainversion = other.mainversion;
162        this.className = other.className;
163        this.requires = other.requires;
164        this.link = other.link;
165        this.description = other.description;
166        this.early = other.early;
167        this.author = other.author;
168        this.stage = other.stage;
169        this.version = other.version;
170        this.downloadlink = other.downloadlink;
171        this.icon = other.icon;
172        this.iconPath = other.iconPath;
173        this.canloadatruntime = other.canloadatruntime;
174        this.libraries = other.libraries;
175        this.attr.clear();
176        this.attr.putAll(other.attr);
177    }
178
179    /**
180     * Updates the plugin information of this plugin information object with the
181     * plugin information in a plugin information object retrieved from a plugin jar.
182     *
183     * @param other the plugin information object retrieved from the jar file
184     * @since 5601
185     */
186    public void updateFromJar(PluginInformation other) {
187        updateLocalInfo(other);
188        if (other.icon != null) {
189            this.icon = other.icon;
190        }
191        this.early = other.early;
192        this.className = other.className;
193        this.canloadatruntime = other.canloadatruntime;
194        this.libraries = other.libraries;
195        this.stage = other.stage;
196        this.file = other.file;
197    }
198
199    private void scanManifest(Manifest manifest, boolean oldcheck) {
200        String lang = LanguageInfo.getLanguageCodeManifest();
201        Attributes attr = manifest.getMainAttributes();
202        className = attr.getValue("Plugin-Class");
203        String s = Optional.ofNullable(attr.getValue(lang+"Plugin-Link")).orElseGet(() -> attr.getValue("Plugin-Link"));
204        if (s != null && !Utils.isValidUrl(s)) {
205            Logging.info(tr("Invalid URL ''{0}'' in plugin {1}", s, name));
206            s = null;
207        }
208        link = s;
209        requires = attr.getValue("Plugin-Requires");
210        s = attr.getValue(lang+"Plugin-Description");
211        if (s == null) {
212            s = attr.getValue("Plugin-Description");
213            if (s != null) {
214                try {
215                    s = tr(s);
216                } catch (IllegalArgumentException e) {
217                    Logging.debug(e);
218                    Logging.info(tr("Invalid plugin description ''{0}'' in plugin {1}", s, name));
219                }
220            }
221        } else {
222            s = MessageFormat.format(s, (Object[]) null);
223        }
224        description = s;
225        early = Boolean.parseBoolean(attr.getValue("Plugin-Early"));
226        String stageStr = attr.getValue("Plugin-Stage");
227        stage = stageStr == null ? 50 : Integer.parseInt(stageStr);
228        version = attr.getValue("Plugin-Version");
229        s = attr.getValue("Plugin-Mainversion");
230        if (s != null) {
231            try {
232                mainversion = Integer.parseInt(s);
233            } catch (NumberFormatException e) {
234                Logging.warn(tr("Invalid plugin main version ''{0}'' in plugin {1}", s, name));
235            }
236        } else {
237            Logging.warn(tr("Missing plugin main version in plugin {0}", name));
238        }
239        author = attr.getValue("Author");
240        iconPath = attr.getValue("Plugin-Icon");
241        if (iconPath != null) {
242            if (file != null) {
243                // extract icon from the plugin jar file
244                icon = new ImageProvider(iconPath).setArchive(file).setMaxSize(ImageProvider.ImageSizes.LARGEICON).setOptional(true);
245            } else if (iconPath.startsWith("data:")) {
246                icon = new ImageProvider(iconPath).setMaxSize(ImageProvider.ImageSizes.LARGEICON).setOptional(true);
247            }
248        }
249        canloadatruntime = Boolean.parseBoolean(attr.getValue("Plugin-Canloadatruntime"));
250        if (oldcheck && mainversion > Version.getInstance().getVersion()) {
251            int myv = Version.getInstance().getVersion();
252            for (Map.Entry<Object, Object> entry : attr.entrySet()) {
253                try {
254                    String key = ((Attributes.Name) entry.getKey()).toString();
255                    if (key.endsWith("_Plugin-Url")) {
256                        int mv = Integer.parseInt(key.substring(0, key.length()-11));
257                        if (mv <= myv && (mv > mainversion || mainversion > myv)) {
258                            String v = (String) entry.getValue();
259                            int i = v.indexOf(';');
260                            if (i > 0) {
261                                downloadlink = v.substring(i+1);
262                                mainversion = mv;
263                                version = v.substring(0, i);
264                                oldmode = true;
265                            }
266                        }
267                    }
268                } catch (NumberFormatException e) {
269                    Logging.error(e);
270                }
271            }
272        }
273
274        String classPath = attr.getValue(Attributes.Name.CLASS_PATH);
275        if (classPath != null) {
276            for (String entry : classPath.split(" ")) {
277                File entryFile;
278                if (new File(entry).isAbsolute() || file == null) {
279                    entryFile = new File(entry);
280                } else {
281                    entryFile = new File(file.getParent(), entry);
282                }
283
284                libraries.add(Utils.fileToURL(entryFile));
285            }
286        }
287        for (Object o : attr.keySet()) {
288            this.attr.put(o.toString(), attr.getValue(o.toString()));
289        }
290    }
291
292    /**
293     * Replies the description as HTML document, including a link to a web page with
294     * more information, provided such a link is available.
295     *
296     * @return the description as HTML document
297     */
298    public String getDescriptionAsHtml() {
299        StringBuilder sb = new StringBuilder(128);
300        sb.append("<html><body>")
301          .append(description == null ? tr("no description available") : Utils.escapeReservedCharactersHTML(description));
302        if (link != null) {
303            sb.append(" <a href=\"").append(link).append("\">").append(tr("More info...")).append("</a>");
304        }
305        if (downloadlink != null
306                && !downloadlink.startsWith("http://svn.openstreetmap.org/applications/editors/josm/dist/")
307                && !downloadlink.startsWith("https://svn.openstreetmap.org/applications/editors/josm/dist/")
308                && !downloadlink.startsWith("http://trac.openstreetmap.org/browser/applications/editors/josm/dist/")
309                && !downloadlink.startsWith("https://github.com/JOSM/")) {
310            sb.append("<p>&nbsp;</p><p>").append(tr("<b>Plugin provided by an external source:</b> {0}", downloadlink)).append("</p>");
311        }
312        sb.append("</body></html>");
313        return sb.toString();
314    }
315
316    /**
317     * Loads and instantiates the plugin.
318     *
319     * @param klass the plugin class
320     * @param classLoader the class loader for the plugin
321     * @return the instantiated and initialized plugin
322     * @throws PluginException if the plugin cannot be loaded or instanciated
323     * @since 12322
324     */
325    public PluginProxy load(Class<?> klass, PluginClassLoader classLoader) throws PluginException {
326        try {
327            Constructor<?> c = klass.getConstructor(PluginInformation.class);
328            Object plugin = c.newInstance(this);
329            return new PluginProxy(plugin, this, classLoader);
330        } catch (ReflectiveOperationException e) {
331            throw new PluginException(name, e);
332        }
333    }
334
335    /**
336     * Loads the class of the plugin.
337     *
338     * @param classLoader the class loader to use
339     * @return the loaded class
340     * @throws PluginException if the class cannot be loaded
341     */
342    public Class<?> loadClass(ClassLoader classLoader) throws PluginException {
343        if (className == null)
344            return null;
345        try {
346            return Class.forName(className, true, classLoader);
347        } catch (NoClassDefFoundError | ClassNotFoundException | ClassCastException e) {
348            throw new PluginException(name, e);
349        }
350    }
351
352    /**
353     * Try to find a plugin after some criterias. Extract the plugin-information
354     * from the plugin and return it. The plugin is searched in the following way:
355     *<ol>
356     *<li>first look after an MANIFEST.MF in the package org.openstreetmap.josm.plugins.&lt;plugin name&gt;
357     *    (After removing all fancy characters from the plugin name).
358     *    If found, the plugin is loaded using the bootstrap classloader.</li>
359     *<li>If not found, look for a jar file in the user specific plugin directory
360     *    (~/.josm/plugins/&lt;plugin name&gt;.jar)</li>
361     *<li>If not found and the environment variable JOSM_RESOURCES + "/plugins/" exist, look there.</li>
362     *<li>Try for the java property josm.resources + "/plugins/" (set via java -Djosm.plugins.path=...)</li>
363     *<li>If the environment variable ALLUSERSPROFILE and APPDATA exist, look in
364     *    ALLUSERSPROFILE/&lt;the last stuff from APPDATA&gt;/JOSM/plugins.
365     *    (*sic* There is no easy way under Windows to get the All User's application
366     *    directory)</li>
367     *<li>Finally, look in some typical unix paths:<ul>
368     *    <li>/usr/local/share/josm/plugins/</li>
369     *    <li>/usr/local/lib/josm/plugins/</li>
370     *    <li>/usr/share/josm/plugins/</li>
371     *    <li>/usr/lib/josm/plugins/</li></ul></li>
372     *</ol>
373     * If a plugin class or jar file is found earlier in the list but seem not to
374     * be working, an PluginException is thrown rather than continuing the search.
375     * This is so JOSM can detect broken user-provided plugins and do not go silently
376     * ignore them.
377     *
378     * The plugin is not initialized. If the plugin is a .jar file, it is not loaded
379     * (only the manifest is extracted). In the classloader-case, the class is
380     * bootstraped (e.g. static {} - declarations will run. However, nothing else is done.
381     *
382     * @param pluginName The name of the plugin (in all lowercase). E.g. "lang-de"
383     * @return Information about the plugin or <code>null</code>, if the plugin
384     *         was nowhere to be found.
385     * @throws PluginException In case of broken plugins.
386     */
387    public static PluginInformation findPlugin(String pluginName) throws PluginException {
388        String name = pluginName;
389        name = name.replaceAll("[-. ]", "");
390        try (InputStream manifestStream = PluginInformation.class.getResourceAsStream("/org/openstreetmap/josm/plugins/"+name+"/MANIFEST.MF")) {
391            if (manifestStream != null) {
392                return new PluginInformation(manifestStream, pluginName, null);
393            }
394        } catch (IOException e) {
395            Logging.warn(e);
396        }
397
398        Collection<String> locations = getPluginLocations();
399
400        for (String s : locations) {
401            File pluginFile = new File(s, pluginName + ".jar");
402            if (pluginFile.exists()) {
403                return new PluginInformation(pluginFile);
404            }
405        }
406        return null;
407    }
408
409    /**
410     * Returns all possible plugin locations.
411     * @return all possible plugin locations.
412     */
413    public static Collection<String> getPluginLocations() {
414        Collection<String> locations = Main.pref.getAllPossiblePreferenceDirs();
415        Collection<String> all = new ArrayList<>(locations.size());
416        for (String s : locations) {
417            all.add(s+"plugins");
418        }
419        return all;
420    }
421
422    /**
423     * Replies true if the plugin with the given information is most likely outdated with
424     * respect to the referenceVersion.
425     *
426     * @param referenceVersion the reference version. Can be null if we don't know a
427     * reference version
428     *
429     * @return true, if the plugin needs to be updated; false, otherweise
430     */
431    public boolean isUpdateRequired(String referenceVersion) {
432        if (this.downloadlink == null) return false;
433        if (this.version == null && referenceVersion != null)
434            return true;
435        return this.version != null && !this.version.equals(referenceVersion);
436    }
437
438    /**
439     * Replies true if this this plugin should be updated/downloaded because either
440     * it is not available locally (its local version is null) or its local version is
441     * older than the available version on the server.
442     *
443     * @return true if the plugin should be updated
444     */
445    public boolean isUpdateRequired() {
446        if (this.downloadlink == null) return false;
447        if (this.localversion == null) return true;
448        return isUpdateRequired(this.localversion);
449    }
450
451    protected boolean matches(String filter, String value) {
452        if (filter == null) return true;
453        if (value == null) return false;
454        return value.toLowerCase(Locale.ENGLISH).contains(filter.toLowerCase(Locale.ENGLISH));
455    }
456
457    /**
458     * Replies true if either the name, the description, or the version match (case insensitive)
459     * one of the words in filter. Replies true if filter is null.
460     *
461     * @param filter the filter expression
462     * @return true if this plugin info matches with the filter
463     */
464    public boolean matches(String filter) {
465        if (filter == null) return true;
466        String[] words = filter.split("\\s+");
467        for (String word: words) {
468            if (matches(word, name)
469                    || matches(word, description)
470                    || matches(word, version)
471                    || matches(word, localversion))
472                return true;
473        }
474        return false;
475    }
476
477    /**
478     * Replies the name of the plugin.
479     * @return The plugin name
480     */
481    public String getName() {
482        return name;
483    }
484
485    /**
486     * Sets the name
487     * @param name Plugin name
488     */
489    public void setName(String name) {
490        this.name = name;
491    }
492
493    /**
494     * Replies the plugin icon, scaled to LARGE_ICON size.
495     * @return the plugin icon, scaled to LARGE_ICON size.
496     */
497    public ImageIcon getScaledIcon() {
498        ImageIcon img = (icon != null) ? icon.get() : null;
499        if (img == null)
500            return emptyIcon;
501        return img;
502    }
503
504    @Override
505    public final String toString() {
506        return getName();
507    }
508
509    private static List<String> getRequiredPlugins(String pluginList) {
510        List<String> requiredPlugins = new ArrayList<>();
511        if (pluginList != null) {
512            for (String s : pluginList.split(";")) {
513                String plugin = s.trim();
514                if (!plugin.isEmpty()) {
515                    requiredPlugins.add(plugin);
516                }
517            }
518        }
519        return requiredPlugins;
520    }
521
522    /**
523     * Replies the list of plugins required by the up-to-date version of this plugin.
524     * @return List of plugins required. Empty if no plugin is required.
525     * @since 5601
526     */
527    public List<String> getRequiredPlugins() {
528        return getRequiredPlugins(requires);
529    }
530
531    /**
532     * Replies the list of plugins required by the local instance of this plugin.
533     * @return List of plugins required. Empty if no plugin is required.
534     * @since 5601
535     */
536    public List<String> getLocalRequiredPlugins() {
537        return getRequiredPlugins(localrequires);
538    }
539
540    /**
541     * Updates the local fields ({@link #localversion}, {@link #localmainversion}, {@link #localrequires})
542     * to values contained in the up-to-date fields ({@link #version}, {@link #mainversion}, {@link #requires})
543     * of the given PluginInformation.
544     * @param info The plugin information to get the data from.
545     * @since 5601
546     */
547    public void updateLocalInfo(PluginInformation info) {
548        if (info != null) {
549            this.localversion = info.version;
550            this.localmainversion = info.mainversion;
551            this.localrequires = info.requires;
552        }
553    }
554}