编程与调试 -- Windows 的快捷方式，符号链接，软链接和硬链接

ln -s source dist        # 建立软连接
ln source dist           # 建立硬连接

创建符号链接。

MKLINK [[/D] | [/H] | [/J]] Link Target

        /D      符号链接（Symbolic Link）。创建目录符号链接。默认为文件符号链接。
        /H      硬链接（Hard Link）。创建硬链接而非符号链接。
        /J      目录联接（Junction Point）。创建目录联接。
        Link    指定新的符号链接名称。
        Target  指定新链接引用的路径（相对或绝对）。

bool LocalFileHandle::isSymbolicLink() const {
    readFileInfo();
    if (m_fileInfo) {
        return (((WIN32_FILE_ATTRIBUTE_DATA *)m_fileInfo)->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0;
    }
    return false;
}

#encoding=utf8
import re, os, sys
# https://pypi.org/project/ntfsutils/
# https://github.com/juntalis/ntfslink-python
# https://stackoverflow.com/questions/1143260/create-ntfs-junction-point-in-python/10221068
from win32file import * # pip install pywin32
from winioctlcon import *
import struct

__all__ = ['islink', 'readlink']

# Win32file doesn't seem to have this attribute.
FILE_ATTRIBUTE_DIRECTORY     = 0x00000010
FILE_ATTRIBUTE_REPARSE_POINT = 0x00000400
IO_REPARSE_TAG_MOUNT_POINT   = 0xA0000003
IO_REPARSE_TAG_SYMLINK       = 0xA000000C
# To make things easier.
REPARSE_FOLDER = (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT)

# For the parse_reparse_buffer function
SYMBOLIC_LINK  = 'symbolic'
MOUNTPOINT     = 'mountpoint'
GENERIC        = 'generic'

def mklinkd(link, target):
    child = subprocess.Popen(['MKLINK', '/D', link, target],
        stdout = subprocess.PIPE,
        stderr = subprocess.STDOUT,
        shell = True)
    streamdata = child.communicate()[0]
    return streamdata

def islink(fpath): # 原版存在 bug，修复了一下。
    """ Windows islink implementation. """
    attr = GetFileAttributes(fpath)
    if attr & FILE_ATTRIBUTE_REPARSE_POINT == FILE_ATTRIBUTE_REPARSE_POINT:
        return True
    return False

def parse_reparse_buffer(original):
    """ Implementing the below in Python:

    typedef struct _REPARSE_DATA_BUFFER {
        ULONG  ReparseTag;
        USHORT ReparseDataLength;
        USHORT Reserved;
        union {
            struct {
                USHORT SubstituteNameOffset;
                USHORT SubstituteNameLength;
                USHORT PrintNameOffset;
                USHORT PrintNameLength;
                ULONG Flags;
                WCHAR PathBuffer[1];
            } SymbolicLinkReparseBuffer;
            struct {
                USHORT SubstituteNameOffset;
                USHORT SubstituteNameLength;
                USHORT PrintNameOffset;
                USHORT PrintNameLength;
                WCHAR PathBuffer[1];
            } MountPointReparseBuffer;
            struct {
                UCHAR  DataBuffer[1];
            } GenericReparseBuffer;
        } DUMMYUNIONNAME;
    } REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;

    """
    # Size of our data types
    SZULONG = 4 # sizeof(ULONG)
    SZUSHORT = 2 # sizeof(USHORT)

    # Our structure.
    # Probably a better way to iterate a dictionary in a particular order,
    # but I was in a hurry, unfortunately, so I used pkeys.
    buffer = {
        'tag' : SZULONG,
        'data_length' : SZUSHORT,
        'reserved' : SZUSHORT,
        SYMBOLIC_LINK : {
            'substitute_name_offset' : SZUSHORT,
            'substitute_name_length' : SZUSHORT,
            'print_name_offset' : SZUSHORT,
            'print_name_length' : SZUSHORT,
            'flags' : SZULONG,
            'buffer' : u'',
            'pkeys' : [
                'substitute_name_offset',
                'substitute_name_length',
                'print_name_offset',
                'print_name_length',
                'flags',
            ]
        },
        MOUNTPOINT : {
            'substitute_name_offset' : SZUSHORT,
            'substitute_name_length' : SZUSHORT,
            'print_name_offset' : SZUSHORT,
            'print_name_length' : SZUSHORT,
            'buffer' : u'',
            'pkeys' : [
                'substitute_name_offset',
                'substitute_name_length',
                'print_name_offset',
                'print_name_length',
            ]
        },
        GENERIC : {
            'pkeys' : [],
            'buffer': ''
        }
    }

    # Header stuff
    buffer['tag'] = struct.unpack('L', original[:SZULONG])[0]

    reparsetype = SYMBOLIC_LINK
    if buffer['tag'] == IO_REPARSE_TAG_SYMLINK:
        reparsetype = SYMBOLIC_LINK
    elif buffer['tag'] == IO_REPARSE_TAG_MOUNT_POINT:
        reparsetype = MOUNTPOINT
    else:
        assert False, buffer['tag']

    buffer['data_length'] = original[SZULONG:SZUSHORT]
    buffer['reserved'] = original[SZULONG+SZUSHORT:SZUSHORT]
    original = original[8:]

    # Parsing
    k = reparsetype
    for c in buffer[k]['pkeys']:
        if type(buffer[k][c]) == int:
            sz = buffer[k][c]
            bytes = original[:sz]
            buffer[k][c] = 0
            for b in bytes:
                n = b # ord(b)
                if n:
                    buffer[k][c] += n
            original = original[sz:]

    # Using the offset and length's grabbed, we'll set the buffer.
    buffer[k]['buffer'] = original
    return reparsetype, buffer

def readlink(fpath):
    """ Windows readlink implementation. """
    # This wouldn't return true if the file didn't exist, as far as I know.
    if not islink(fpath):
        return None

    if os.path.isdir(fpath):
        dwFlagsAndAttributes = FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS
    else:
        dwFlagsAndAttributes = FILE_FLAG_OPEN_REPARSE_POINT

    # Open the file correctly depending on the string type.
    handle = CreateFileW(fpath, GENERIC_READ, 0, None, OPEN_EXISTING, dwFlagsAndAttributes, 0) \
                if type(fpath) == type("unicode") else \
            CreateFile(fpath, GENERIC_READ, 0, None, OPEN_EXISTING, dwFlagsAndAttributes, 0)
    if handle == INVALID_HANDLE_VALUE:
        return None

    # MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 16384 = (16*1024)
    buffer = DeviceIoControl(handle, FSCTL_GET_REPARSE_POINT, None, 16*1024)
    # Above will return an ugly string (byte array), so we'll need to parse it.

    # But first, we'll close the handle to our file so we're not locking it anymore.
    CloseHandle(handle)

    # Minimum possible length (assuming that the length of the target is bigger than 0)
    if len(buffer) < 9:
        return None
    # Parse and return our result.
    reparsetype, result = parse_reparse_buffer(buffer)
    offset = result[reparsetype]['substitute_name_offset']
    ending = offset + result[reparsetype]['substitute_name_length']
    rpath = result[reparsetype]['buffer'][offset:ending].replace(b'\x00', b'')
    if len(rpath) > 4 and rpath[0:4] == b'\\??\\':
        rpath = rpath[4:]
    return rpath.decode("gbk")

def realpath(fpath):
    from os import path
    while islink(fpath):
        rpath = readlink(fpath)
        if not path.isabs(rpath):
            rpath = path.abspath(path.join(path.dirname(fpath), rpath))
        fpath = rpath
    return fpath

def dprint(link):
    linklen = len(link)
    linelen = 80
    sepleft = int((linelen - 2 - linklen) / 2)
    sepright = linelen - 2 - linklen - sepleft
    islinkp = islink(link)
    print('-' * sepleft, link, '-' * sepright)

    if islinkp:
        print('IsLink: %s ReadLink: %s' % (islinkp, readlink(link)))
    else:
        print('IsLink: %s' % islinkp)

    print('RealPath: %s' % realpath(link))

    # https://docs.python.org/3/library/os.path.html
    # os.path.islink(path)      判断路径是否为链接
    # os.path.ismount(path)     判断路径是否为挂载点
    # os.path.realpath(path)    返回 path 的真实路径
    print(">>", os.path.islink(link),
          link, "->", os.path.realpath(link))

    link = os.path.normpath(os.path.abspath(link))
    while link and len(link) > 3: # E:\
        link = os.path.split(link)[0]
        if islink(link):
            print('Parent IsLink: %s -> %s' % (link, realpath(link)))
    print('-' * linelen)

def example():

    from os import system, unlink
    clear = "clear" in sys.argv

    system('cmd.exe /c echo test.txt > test.txt')
    system('mklink test-link.txt test.txt') # 文件类型为 .symlink
    dprint("test.txt")
    dprint("test-link.txt")
    if clear:
        unlink('test-link.txt')
        unlink('test.txt')

    # MKLINK /D Link Target # 创建指向文件夹的符号链接
    # MKLINK /J Link Target # 创建指向文件夹的软链接（联接）
    system("mkdir test")
    system("mkdir test\\subtest")
    system('cmd.exe /c echo test\\subtest.txt > test\\subtest.txt')
    system('cmd.exe /c echo test\\subtest\\subtest.txt > test\\subtest\\subtest.txt')

    system("mklink /D D:\\test-dlink {}".format(os.path.abspath("test")))
    system("mklink /J D:\\test-jlink test")
    dprint("D:\\test-dlink")
    dprint("D:\\test-jlink")

    dprint("test\\subtest\\subtest.txt")
    dprint("D:\\test-dlink\\subtest\\subtest.txt")
    dprint("D:\\test-jlink\\subtest\\subtest.txt")

    if clear:
        unlink('test\\subtest.txt')
        unlink('test\\subtest\\subtest.txt')
        # os.rmdir(path) # removedirs
        os.rmdir("test\\subtest")
        os.rmdir("test")
        os.rmdir("D:\\test-dlink")
        os.rmdir("D:\\test-jlink")

if __name__=='__main__':
    example()

E:\kSource\pythonx>python pymklink.py clear
为 test-link.txt <<===>> test.txt 创建的符号链接
----------------------------------- test.txt -----------------------------------
IsLink: False
RealPath: test.txt
>> False test.txt -> E:\kSource\pythonx\test.txt
--------------------------------------------------------------------------------
-------------------------------- test-link.txt ---------------------------------
IsLink: True ReadLink: test.txt
RealPath: E:\kSource\pythonx\test.txt
>> True test-link.txt -> E:\kSource\pythonx\test.txt
--------------------------------------------------------------------------------
为 D:\test-dlink <<===>> E:\kSource\pythonx\test 创建的符号链接
为 D:\test-jlink <<===>> test 创建的联接
-------------------------------- D:\test-dlink ---------------------------------
IsLink: True ReadLink: E:\kSource\pythonx\test
RealPath: E:\kSource\pythonx\test
>> True D:\test-dlink -> E:\kSource\pythonx\test
--------------------------------------------------------------------------------
-------------------------------- D:\test-jlink ---------------------------------
IsLink: True ReadLink: E:\kSource\pythonx\test
RealPath: E:\kSource\pythonx\test
>> False D:\test-jlink -> E:\kSource\pythonx\test
--------------------------------------------------------------------------------
--------------------------- test\subtest\subtest.txt ---------------------------
IsLink: False
RealPath: test\subtest\subtest.txt
>> False test\subtest\subtest.txt -> E:\kSource\pythonx\test\subtest\subtest.txt
--------------------------------------------------------------------------------
---------------------- D:\test-dlink\subtest\subtest.txt -----------------------
IsLink: False
RealPath: D:\test-dlink\subtest\subtest.txt
>> False D:\test-dlink\subtest\subtest.txt -> E:\kSource\pythonx\test\subtest\subtest.txt
Parent IsLink: D:\test-dlink -> E:\kSource\pythonx\test
--------------------------------------------------------------------------------
---------------------- D:\test-jlink\subtest\subtest.txt -----------------------
IsLink: False
RealPath: D:\test-jlink\subtest\subtest.txt
>> False D:\test-jlink\subtest\subtest.txt -> E:\kSource\pythonx\test\subtest\subtest.txt
Parent IsLink: D:\test-jlink -> E:\kSource\pythonx\test
--------------------------------------------------------------------------------