Raccourci Windows (.lnk) analyseur en Java?

StackOverflow https://stackoverflow.com/questions/309495

Question

J'utilise actuellement Win32ShellFolderManager2 et ShellFolder.getLinkLocation pour résoudre les raccourcis Windows en Java. Malheureusement, si le programme Java est exécuté en tant que service sous Vista, getLinkLocation , cela ne fonctionne pas. Plus précisément, une exception indiquant "Impossible d'obtenir la liste d'identifiants de dossiers du shell" apparaît.

La recherche sur le Web affiche des mentions de ce message d'erreur, mais toujours en relation avec JFileChooser . Je n'utilise pas JFileChooser , je dois simplement résoudre un fichier .lnk à sa destination.

Est-ce que quelqu'un connaît un analyseur tiers pour les fichiers .lnk écrits en Java que je pourrais utiliser?

Depuis, j'ai trouvé une documentation non officielle sur le format .lnk ici , mais je préférerais ne pas avoir à faire le travail si quelqu'un l'a déjà fait, car le format est plutôt effrayant.

Était-ce utile?

La solution

Ajout de commentaires (explications et crédit à chaque contributeur jusqu’à présent), vérification supplémentaire de la magie du fichier, test rapide permettant de déterminer si un fichier donné pouvait être un lien valide (sans lire tous les octets), correctif pour lancer une exception ParseException avec le message approprié à la place de ArrayIndexOutOfBoundsException si le fichier est trop petit, a effectué un nettoyage général.

Source ici (si vous avez Pour toute modification, envoyez-les directement dans le repo / projet . 

package org.stackoverflowusers.file;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.text.ParseException;

/**
 * Represents a Windows shortcut (typically visible to Java only as a '.lnk' file).
 *
 * Retrieved 2011-09-23 from http://stackoverflow.com/questions/309495/windows-shortcut-lnk-parser-in-java/672775#672775
 * Originally called LnkParser
 *
 * Written by: (the stack overflow users, obviously!)
 *   Apache Commons VFS dependency removed by crysxd (why were we using that!?) https://github.com/crysxd
 *   Headerified, refactored and commented by Code Bling http://stackoverflow.com/users/675721/code-bling
 *   Network file support added by Stefan Cordes http://stackoverflow.com/users/81330/stefan-cordes
 *   Adapted by Sam Brightman http://stackoverflow.com/users/2492/sam-brightman
 *   Based on information in 'The Windows Shortcut File Format' by Jesse Hager <jessehager@iname.com>
 *   And somewhat based on code from the book 'Swing Hacks: Tips and Tools for Killer GUIs'
 *     by Joshua Marinacci and Chris Adamson
 *     ISBN: 0-596-00907-0
 *     http://www.oreilly.com/catalog/swinghks/
 */
public class WindowsShortcut
{
    private boolean isDirectory;
    private boolean isLocal;
    private String real_file;

    /**
     * Provides a quick test to see if this could be a valid link !
     * If you try to instantiate a new WindowShortcut and the link is not valid,
     * Exceptions may be thrown and Exceptions are extremely slow to generate,
     * therefore any code needing to loop through several files should first check this.
     *
     * @param file the potential link
     * @return true if may be a link, false otherwise
     * @throws IOException if an IOException is thrown while reading from the file
     */
    public static boolean isPotentialValidLink(File file) throws IOException {
        final int minimum_length = 0x64;
        InputStream fis = new FileInputStream(file);
        boolean isPotentiallyValid = false;
        try {
            isPotentiallyValid = file.isFile()
                && file.getName().toLowerCase().endsWith(".lnk")
                && fis.available() >= minimum_length
                && isMagicPresent(getBytes(fis, 32));
        } finally {
            fis.close();
        }
        return isPotentiallyValid;
    }

    public WindowsShortcut(File file) throws IOException, ParseException {
        InputStream in = new FileInputStream(file);
        try {
            parseLink(getBytes(in));
        } finally {
            in.close();
        }
    }

    /**
     * @return the name of the filesystem object pointed to by this shortcut
     */
    public String getRealFilename() {
        return real_file;
    }

    /**
     * Tests if the shortcut points to a local resource.
     * @return true if the 'local' bit is set in this shortcut, false otherwise
     */
    public boolean isLocal() {
        return isLocal;
    }

    /**
     * Tests if the shortcut points to a directory.
     * @return true if the 'directory' bit is set in this shortcut, false otherwise
     */
    public boolean isDirectory() {
        return isDirectory;
    }

    /**
     * Gets all the bytes from an InputStream
     * @param in the InputStream from which to read bytes
     * @return array of all the bytes contained in 'in'
     * @throws IOException if an IOException is encountered while reading the data from the InputStream
     */
    private static byte[] getBytes(InputStream in) throws IOException {
        return getBytes(in, null);
    }

    /**
     * Gets up to max bytes from an InputStream
     * @param in the InputStream from which to read bytes
     * @param max maximum number of bytes to read
     * @return array of all the bytes contained in 'in'
     * @throws IOException if an IOException is encountered while reading the data from the InputStream
     */
    private static byte[] getBytes(InputStream in, Integer max) throws IOException {
        // read the entire file into a byte buffer
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        byte[] buff = new byte[256];
        while (max == null || max > 0) {
            int n = in.read(buff);
            if (n == -1) {
                break;
            }
            bout.write(buff, 0, n);
            if (max != null)
                max -= n;
        }
        in.close();
        return bout.toByteArray();
    }

    private static boolean isMagicPresent(byte[] link) {
        final int magic = 0x0000004C;
        final int magic_offset = 0x00;
        return link.length >= 32 && bytesToDword(link, magic_offset) == magic;
    }

    /**
     * Gobbles up link data by parsing it and storing info in member fields
     * @param link all the bytes from the .lnk file
     */
    private void parseLink(byte[] link) throws ParseException {
        try {
            if (!isMagicPresent(link))
                throw new ParseException("Invalid shortcut; magic is missing", 0);

            // get the flags byte
            byte flags = link[0x14];

            // get the file attributes byte
            final int file_atts_offset = 0x18;
            byte file_atts = link[file_atts_offset];
            byte is_dir_mask = (byte)0x10;
            if ((file_atts & is_dir_mask) > 0) {
                isDirectory = true;
            } else {
                isDirectory = false;
            }

            // if the shell settings are present, skip them
            final int shell_offset = 0x4c;
            final byte has_shell_mask = (byte)0x01;
            int shell_len = 0;
            if ((flags & has_shell_mask) > 0) {
                // the plus 2 accounts for the length marker itself
                shell_len = bytesToWord(link, shell_offset) + 2;
            }

            // get to the file settings
            int file_start = 0x4c + shell_len;

            final int file_location_info_flag_offset_offset = 0x08;
            int file_location_info_flag = link[file_start + file_location_info_flag_offset_offset];
            isLocal = (file_location_info_flag & 2) == 0;
            // get the local volume and local system values
            //final int localVolumeTable_offset_offset = 0x0C;
            final int basename_offset_offset = 0x10;
            final int networkVolumeTable_offset_offset = 0x14;
            final int finalname_offset_offset = 0x18;
            int finalname_offset = link[file_start + finalname_offset_offset] + file_start;
            String finalname = getNullDelimitedString(link, finalname_offset);
            if (isLocal) {
                int basename_offset = link[file_start + basename_offset_offset] + file_start;
                String basename = getNullDelimitedString(link, basename_offset);
                real_file = basename + finalname;
            } else {
                int networkVolumeTable_offset = link[file_start + networkVolumeTable_offset_offset] + file_start;
                int shareName_offset_offset = 0x08;
                int shareName_offset = link[networkVolumeTable_offset + shareName_offset_offset]
                    + networkVolumeTable_offset;
                String shareName = getNullDelimitedString(link, shareName_offset);
                real_file = shareName + "\\" + finalname;
            }
        } catch (ArrayIndexOutOfBoundsException e) {
            throw new ParseException("Could not be parsed, probably not a valid WindowsShortcut", 0);
        }
    }

    private static String getNullDelimitedString(byte[] bytes, int off) {
        int len = 0;
        // count bytes until the null character (0)
        while (true) {
            if (bytes[off + len] == 0) {
                break;
            }
            len++;
        }
        return new String(bytes, off, len);
    }

    /*
     * convert two bytes into a short note, this is little endian because it's
     * for an Intel only OS.
     */
    private static int bytesToWord(byte[] bytes, int off) {
        return ((bytes[off + 1] & 0xff) << 8) | (bytes[off] & 0xff);
    }

    private static int bytesToDword(byte[] bytes, int off) {
        return (bytesToWord(bytes, off + 2) << 16) | bytesToWord(bytes, off);
    }

}

Autres conseils

La solution de Sam Brightman ne concerne que les fichiers locaux. J'ai ajouté un support pour les fichiers réseau:

  • Analyseur de raccourci Windows (.lnk) en Java?
  • http://code.google.com/p /8bits/downloads/detail?name=The_Windows_Shortcut_File_Format.pdf

  • http://www.javafaq.nu/java- example-code-468.html 

    public class LnkParser {

public LnkParser(File f) throws IOException {
    parse(f);
}

private boolean isDirectory;
private boolean isLocal;

public boolean isDirectory() {
    return isDirectory;
}

private String real_file;

public String getRealFilename() {
    return real_file;
}

private void parse(File f) throws IOException {
    // read the entire file into a byte buffer
    FileInputStream fin = new FileInputStream(f);
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    byte[] buff = new byte[256];
    while (true) {
        int n = fin.read(buff);
        if (n == -1) {
            break;
        }
        bout.write(buff, 0, n);
    }
    fin.close();
    byte[] link = bout.toByteArray();

    parseLink(link);
}

private void parseLink(byte[] link) {
    // get the flags byte
    byte flags = link[0x14];

    // get the file attributes byte
    final int file_atts_offset = 0x18;
    byte file_atts = link[file_atts_offset];
    byte is_dir_mask = (byte)0x10;
    if ((file_atts & is_dir_mask) > 0) {
        isDirectory = true;
    } else {
        isDirectory = false;
    }

    // if the shell settings are present, skip them
    final int shell_offset = 0x4c;
    final byte has_shell_mask = (byte)0x01;
    int shell_len = 0;
    if ((flags & has_shell_mask) > 0) {
        // the plus 2 accounts for the length marker itself
        shell_len = bytes2short(link, shell_offset) + 2;
    }

    // get to the file settings
    int file_start = 0x4c + shell_len;

    final int file_location_info_flag_offset_offset = 0x08;
    int file_location_info_flag = link[file_start + file_location_info_flag_offset_offset];
    isLocal = (file_location_info_flag & 2) == 0;
    // get the local volume and local system values
    //final int localVolumeTable_offset_offset = 0x0C;
    final int basename_offset_offset = 0x10;
    final int networkVolumeTable_offset_offset = 0x14;
    final int finalname_offset_offset = 0x18;
    int finalname_offset = link[file_start + finalname_offset_offset] + file_start;
    String finalname = getNullDelimitedString(link, finalname_offset);
    if (isLocal) {
        int basename_offset = link[file_start + basename_offset_offset] + file_start;
        String basename = getNullDelimitedString(link, basename_offset);
        real_file = basename + finalname;
    } else {
        int networkVolumeTable_offset = link[file_start + networkVolumeTable_offset_offset] + file_start;
        int shareName_offset_offset = 0x08;
        int shareName_offset = link[networkVolumeTable_offset + shareName_offset_offset]
                + networkVolumeTable_offset;
        String shareName = getNullDelimitedString(link, shareName_offset);
        real_file = shareName + "\\" + finalname;
    }
}

private static String getNullDelimitedString(byte[] bytes, int off) {
    int len = 0;
    // count bytes until the null character (0)
    while (true) {
        if (bytes[off + len] == 0) {
            break;
        }
        len++;
    }
    return new String(bytes, off, len);
}

/*
 * convert two bytes into a short note, this is little endian because it's
 * for an Intel only OS.
 */
private static int bytes2short(byte[] bytes, int off) {
    return ((bytes[off + 1] & 0xff) << 8) | (bytes[off] & 0xff);
}

/**
 * Returns the value of the instance variable 'isLocal'.
 *
 * @return Returns the isLocal.
 */
public boolean isLocal() {
    return isLocal;
}
}

Je peux recommander ce référentiel sur GitHub:

https://github.com/BlackOverlord666/mslinks

J'ai trouvé une solution simple pour créer des raccourcis:

ShellLink.createLink ("chemin / vers / existant / fichier.txt", "chemin / vers / le / future / shortcut.lnk");

Si vous voulez lire des raccourcis: 

File shortcut = ...;
String pathToExistingFile = new ShellLink(shortcut).resolveTarget();

Si vous souhaitez changer l'icône du raccourci, utilisez: 

ShellLink sl = ...;
sl.setIconLocation("/path/to/icon/file");

Vous pouvez modifier la plupart des propriétés du lien raccourci, telles que répertoire de travail, texte d'info-bulle, icône, arguments de ligne de commande, touches de raccourci, création de liens vers des fichiers et répertoires partagés sur un réseau local , etc. ...

J'espère que cela vous aide:)

Sincères amitiés Josua Frank

J'ai également travaillé (je n'ai plus de temps pour ça) sur '.lnk' en Java. Mon code est ici

C’est un peu désordonné (quelques trashs de test) mais l’analyse locale et réseau fonctionne bien. La création de liens est également implémentée. Merci de tester et de m'envoyer les correctifs.

Exemple d'analyse: 

Shortcut scut = Shortcut.loadShortcut(new File("C:\\t.lnk"));
System.out.println(scut.toString());

Création d'un nouveau lien: 

Shortcut scut = new Shortcut(new File("C:\\temp"));
OutputStream os = new FileOutputStream("C:\\t.lnk");
os.write(scut.getBytes());
os.flush();
os.close();

Le code plan9assembler lié à semble fonctionner avec des modifications mineures. Je pense que c'est juste le " & amp; 0xff " pour empêcher l’extension de la signature lorsque octets sont convertis au format int dans la fonction bytes2short qui doivent être modifiés. J'ai ajouté la fonctionnalité décrite dans http://www.i2s-lab.com/ Papers / The_Windows_Shortcut_File_Format.pdf pour concaténer la " dernière partie du chemin d'accès " même si dans la pratique cela ne semble pas être utilisé dans mes exemples. Je n'ai ajouté aucune vérification d'erreur à l'en-tête ni traité de partage réseau. Voici ce que j'utilise maintenant: 

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.text.DecimalFormat;
import java.text.NumberFormat;

public class LnkParser {

    public LnkParser(File f) throws Exception {
        parse(f);
    }

    private boolean is_dir;

    public boolean isDirectory() {
        return is_dir;
    }

    private String real_file;

    public String getRealFilename() {
        return real_file;
    }

    private void parse(File f) throws Exception {
        // read the entire file into a byte buffer
        FileInputStream fin = new FileInputStream(f);
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        byte[] buff = new byte[256];
        while (true) {
            int n = fin.read(buff);
            if (n == -1) {
                break;
            }
            bout.write(buff, 0, n);
        }
        fin.close();
        byte[] link = bout.toByteArray();

        // get the flags byte
        byte flags = link[0x14];

        // get the file attributes byte
        final int file_atts_offset = 0x18;
        byte file_atts = link[file_atts_offset];
        byte is_dir_mask = (byte) 0x10;
        if ((file_atts & is_dir_mask) > 0) {
            is_dir = true;
        } else {
            is_dir = false;
        }

        // if the shell settings are present, skip them
        final int shell_offset = 0x4c;
        final byte has_shell_mask = (byte) 0x01;
        int shell_len = 0;
        if ((flags & has_shell_mask) > 0) {
            // the plus 2 accounts for the length marker itself
            shell_len = bytes2short(link, shell_offset) + 2;
        }

        // get to the file settings
        int file_start = 0x4c + shell_len;

        // get the local volume and local system values
        final int basename_offset_offset = 0x10;
        final int finalname_offset_offset = 0x18;
        int basename_offset = link[file_start + basename_offset_offset]
                                + file_start;
        int finalname_offset = link[file_start + finalname_offset_offset]
                                + file_start;
        String basename = getNullDelimitedString(link, basename_offset);
        String finalname = getNullDelimitedString(link, finalname_offset);
        real_file = basename + finalname;
    }

    private static String getNullDelimitedString(byte[] bytes, int off) {
        int len = 0;
        // count bytes until the null character (0)
        while (true) {
            if (bytes[off + len] == 0) {
                break;
            }
            len++;
        }
        return new String(bytes, off, len);
    }

    /*
     * convert two bytes into a short note, this is little endian because it's
     * for an Intel only OS.
     */
    private static int bytes2short(byte[] bytes, int off) {
        return ((bytes[off + 1] & 0xff) << 8) | (bytes[off] & 0xff);
    }
}

Ce code court est vraiment utile ...

Mais deux corrections sont nécessaires:

  • isPotentialValidLink a été amélioré pour ne pas charger le fichier si le nom ne se termine pas par ".lnk"

    . 
      public static boolean isPotentialValidLink(final File file) {
    final int minimum_length = 0x64;
    boolean isPotentiallyValid = false;
    if (file.getName().toLowerCase().endsWith(".lnk"))
        try (final InputStream fis = new FileInputStream(file)) {
            isPotentiallyValid = file.isFile() && fis.available() >= minimum_length && isMagicPresent(getBytes(fis, 32));
        } catch (Exception e) {
            // forget it
        }
    return isPotentiallyValid;
  }

  • le décalage doit être calculé avec 32 bits non seulement un octet ... 

     final int finalname_offset = bytesToDword(link,file_start + finalname_offset_offset) + file_start;
 final int basename_offset = bytesToDword(link,file_start + basename_offset_offset) + file_start;

Le code donné fonctionne bien, mais a un bogue. Un octet Java est une valeur signée comprise entre -128 et 127. Nous souhaitons une valeur non signée comprise entre 0 et 255 pour obtenir les résultats corrects. Modifiez simplement la fonction bytes2short comme suit: 

static int bytes2short(byte[] bytes, int off) {
    int low = (bytes[off]<0 ? bytes[off]+256 : bytes[off]);
    int high = (bytes[off+1]<0 ? bytes[off+1]+256 : bytes[off+1])<<8;
    return 0 | low | high;
}

La solution de @Code Bling ne fonctionne pas pour moi dans Fichiers du répertoire de l'utilisateur.
Par exemple & C; C: /Users/Username/Filename.txt" ;.
La raison en est la suivante: dans The_Windows_Shortcut_File_Format.Pdf

qui a été mentionné par @Stefan Cordes à la page 6, indique que seuls les 2 premiers bits sont importants pour les informations de volumes. Tous les autres bits peuvent être remplis de façon aléatoire lorsque le premier bit d’information de volume est "0".

Donc s'il s'agit de: 

isLocal = (file_location_info_flag & 2) == 0;

alors file_location_info_flag pourrait être "3". Ce fichier est toujours local mais cette ligne de code attribue false à isLocal .

Je suggère donc l'ajustement suivant au code de @Code Bling: 

isLocal = (file_location_info_flag & 1) == 1;
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top