Getting the lnk target; did I miss something?

[suedunham]

My problem is solved; my script is run; my Windows lnks are converted. There is no fire to put out, but I'm a bit ashamed of how I did it, and I wonder if there is a better way than I found to get the whole target value of the lnk_file object.

Mine is a simple use case. I only have links to other files and directories on my local filesystem, and there are no commands or flags to open them with,

I first tried combining the string_data.working_directory() and string_data.relative_path() methods. This has some wrinkles with . or .. terms in the middle, but pathlib.Path().resolve() could tidy those up. More fatal were at least one case where the lnk pointed to a directory; the relative_path() was simply "./DirName" and the working_directory() was None.

Then I tried an approach based on lnk_file.targets.primary_name(). This got me most of the way there, except that I could not get the initial root slash or the Windows volume letter at the beginning of the path. Those two elements in the targets don't have primary_name() methods.

I stuck with that though, and hacked up something in the except clause leaning on _raw_target.

    def get_target(self) -> Path | None:
        """Get target from Windows lnk via targets.

        The constituents of the lnk_file.targets property do not have
        a property_name method in the case of the root_folder and the
        my_computer types. This means that the initial / and the drive
        letter are not accessible cleanly this way, so we descend into
        hackery then.
        """

        def get_primary_name(target):
            """Get primary name of target."""
            try:
                return target.primary_name()
            except AttributeError:
                # Return slash if target is root_folder.
                # Yes, my_computer starts with a slash too. It is needed
                # here as well. When Path is done with it, it's three.
                return_value = '/'
                # my_computer._raw_target starts with "/D:", etc.
                if chr(target._raw_target[0]) == '/':
                    return_value = target._raw_target[:3].decode(UTF8)
                return return_value

        target = None
        if self.lnk.targets is not None:
            target = Path('/'.join(get_primary_name(target)
                                   for target in self.lnk.targets))
        return target

That self.lnk part is set thusly:

    def read_windows_lnk(self) -> LnkParse3.lnk_file:
        """Read Windows lnk file with LnkParse3."""
        with open(self.windows_file, "rb") as win:
            return LnkParse3.lnk_file(win)

So, yeah, yuck. Still, that was the best I could find. Is there something better that I'm not seeing?

[Matmaus]

Hi, based on documentation and on my quick dive into this problem I would suggest to use LinkInfo

The LinkInfo structure specifies information necessary to resolve a link target if it is not found in its
original location. This includes information about the volume that the target was stored on, the
mapped drive letter, and a Universal Naming Convention (UNC) form of the path if one existed
when the link was created.

In the example below, you can see three approaches. The first one is yours, the second one is based on combining working directory and relative path. As you have said, . and .. can be resolved by using pathlib but I found one more complicated problem - interleaving paths, e.g. Working directory: C:\Users\admin\AppData\Local\Temp\ and Relative path: "..\\..\\..\\..\\..\\..\\Local\\Temp\\MZ\x90". Resolved it by using only a filename from the relative path (not sure whether it is a stable solution).

The last example is giving the best results I would say. Also, don't forget to pass a correct code page if necessary.

(I use PureWindowsPath because I don't work on Windows).

import pathlib

import LnkParse3

def get_target(lnk_file: LnkParse3.lnk_file) -> pathlib.Path | None:

    def get_primary_name(target):
        """Get primary name of target."""
        try:
            return target.primary_name()
        except AttributeError:
            return_value = '/'
            if chr(target._raw_target[0]) == '/':
                return_value = target._raw_target[:3].decode('utf-8')
            return return_value

    target = None
    if lnk_file.targets is not None:
        target = pathlib.PureWindowsPath('/'.join(get_primary_name(target)
                                for target in lnk_file.targets))
    return target

def get_target2(lnk_file: LnkParse3.lnk_file) -> pathlib.Path | None:
    part1 = lnk_file.string_data.working_directory() if lnk_file.has_working_dir() else ""
    # HACK: Use only the filename to avoid paths like C:\dir1\dir2\..\..\..\..\dir1\dir2\file.txt
    # created by merging the working directory and the relative path.
    part2 = pathlib.PureWindowsPath(lnk_file.string_data.relative_path()).name if lnk_file.has_relative_path() else ""
    if part1 or part2:
        return pathlib.PureWindowsPath(part1, part2)
    return None

def get_target3(lnk_file: LnkParse3.lnk_file) -> pathlib.Path | None:
    if lnk_file.has_link_info():
        part1 = lnk_file.info.local_base_path_unicode() if lnk_file.info.local_base_path_unicode() else lnk_file.info.local_base_path()
        part2 = lnk_file.info.common_path_suffix_unicode() if lnk_file.info.common_path_suffix_unicode() else lnk_file.info.common_path_suffix()
        if part1 or part2:
            return pathlib.PureWindowsPath(part1 or '', part2 or '')
    return None
    

filename = 'tests/samples/decoding_error3'
with open(filename, "rb") as win:
    lnk_file = LnkParse3.lnk_file(win, cp='windows-1251')
    print(get_target(lnk_file))
    print(get_target2(lnk_file))
    print(get_target3(lnk_file))