SYMBOLIC_LINK_REPARSE_BUFFER.PrintName() - Code Metrics - Inspection of "Add support for symlinks in cookiecutter templates" - audreyr/cookiecutter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#868)

unknown

created 2017-04-22 19:57 UTC

SYMBOLIC_LINK_REPARSE_BUFFER.PrintName() A

↳ Parent: SYMBOLIC_LINK_REPARSE_BUFFER

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
c	1
b	0
f	0
dl	0
loc	5
rs	9.4285

# Functions for identifying and following symlinks in Windows
# from user `eryksun` http://stackoverflow.com/a/27979160
# 16 Jan 2015
# See http://stackoverflow.com/a/15259028 for more information

import os
from shutil import copystat, copy2, Error

from ctypes import c_ubyte, c_buffer, c_wchar_p, c_uint32
from ctypes.wintypes import (
    POINTER, DWORD, LPCWSTR, HANDLE,
    LPVOID, BOOL, USHORT, WCHAR, ULONG,
    WinDLL, Structure, addressof, WinError,
    Union, byref
)

kernel32 = WinDLL('kernel32')
LPDWORD = POINTER(DWORD)
UCHAR = c_ubyte

GetFileAttributesW = kernel32.GetFileAttributesW
GetFileAttributesW.restype = DWORD
GetFileAttributesW.argtypes = (LPCWSTR,)  # lpFileName In

INVALID_FILE_ATTRIBUTES = 0xFFFFFFFF
FILE_ATTRIBUTE_REPARSE_POINT = 0x00400

CreateFileW = kernel32.CreateFileW
CreateFileW.restype = HANDLE
CreateFileW.argtypes = (LPCWSTR,  # lpFileName In
                        DWORD,    # dwDesiredAccess In
                        DWORD,    # dwShareMode In
                        LPVOID,   # lpSecurityAttributes In_opt
                        DWORD,    # dwCreationDisposition In
                        DWORD,    # dwFlagsAndAttributes In
                        HANDLE)   # hTemplateFile In_opt

CloseHandle = kernel32.CloseHandle
CloseHandle.restype = BOOL
CloseHandle.argtypes = (HANDLE,)  # hObject In

INVALID_HANDLE_VALUE = HANDLE(-1).value
OPEN_EXISTING = 3
FILE_FLAG_BACKUP_SEMANTICS = 0x02000000
FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000

DeviceIoControl = kernel32.DeviceIoControl
DeviceIoControl.restype = BOOL
DeviceIoControl.argtypes = (HANDLE,   # hDevice In
                            DWORD,    # dwIoControlCode In
                            LPVOID,   # lpInBuffer In_opt
                            DWORD,    # nInBufferSize In
                            LPVOID,   # lpOutBuffer Out_opt
                            DWORD,    # nOutBufferSize In
                            LPDWORD,  # lpBytesReturned Out_opt
                            LPVOID)   # lpOverlapped Inout_opt

FSCTL_GET_REPARSE_POINT = 0x000900A8
IO_REPARSE_TAG_MOUNT_POINT = 0xA0000003
IO_REPARSE_TAG_SYMLINK = 0xA000000C
MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 0x4000


class GENERIC_REPARSE_BUFFER(Structure):
    _fields_ = (('DataBuffer', UCHAR * 1),)


class SYMBOLIC_LINK_REPARSE_BUFFER(Structure):
    _fields_ = (('SubstituteNameOffset', USHORT),
                ('SubstituteNameLength', USHORT),
                ('PrintNameOffset', USHORT),
                ('PrintNameLength', USHORT),
                ('Flags', ULONG),
                ('PathBuffer', WCHAR * 1))

    @property
    def PrintName(self):
        arrayt = WCHAR * (self.PrintNameLength // 2)
        offset = type(self).PathBuffer.offset + self.PrintNameOffset
        return arrayt.from_address(addressof(self) + offset).value


class MOUNT_POINT_REPARSE_BUFFER(Structure):
    _fields_ = (('SubstituteNameOffset', USHORT),
                ('SubstituteNameLength', USHORT),
                ('PrintNameOffset', USHORT),
                ('PrintNameLength', USHORT),
                ('PathBuffer', WCHAR * 1))

    @property
    def PrintName(self):
        arrayt = WCHAR * (self.PrintNameLength // 2)
        offset = type(self).PathBuffer.offset + self.PrintNameOffset
        return arrayt.from_address(addressof(self) + offset).value


class REPARSE_DATA_BUFFER(Structure):
    class REPARSE_BUFFER(Union):
        _fields_ = (('SymbolicLinkReparseBuffer',
                     SYMBOLIC_LINK_REPARSE_BUFFER),
                    ('MountPointReparseBuffer',
                     MOUNT_POINT_REPARSE_BUFFER),
                    ('GenericReparseBuffer',
                     GENERIC_REPARSE_BUFFER))
    _fields_ = (('ReparseTag', ULONG),
                ('ReparseDataLength', USHORT),
                ('Reserved', USHORT),
                ('ReparseBuffer', REPARSE_BUFFER))
    _anonymous_ = ('ReparseBuffer',)


def islink(path):
    result = GetFileAttributesW(path)
    if result == INVALID_FILE_ATTRIBUTES:
        raise WinError()
    return bool(result & FILE_ATTRIBUTE_REPARSE_POINT)


def readlink(path):
    reparse_point_handle = CreateFileW(path,
                                       0,
                                       0,
                                       None,
                                       OPEN_EXISTING,
                                       FILE_FLAG_OPEN_REPARSE_POINT |
                                       FILE_FLAG_BACKUP_SEMANTICS,
                                       None)
    if reparse_point_handle == INVALID_HANDLE_VALUE:
        raise WinError()
    target_buffer = c_buffer(MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
    n_bytes_returned = DWORD()
    io_result = DeviceIoControl(reparse_point_handle,
                                FSCTL_GET_REPARSE_POINT,
                                None, 0,
                                target_buffer, len(target_buffer),
                                byref(n_bytes_returned),
                                None)
    CloseHandle(reparse_point_handle)
    if not io_result:
        raise WinError()
    rdb = REPARSE_DATA_BUFFER.from_buffer(target_buffer)
    if rdb.ReparseTag == IO_REPARSE_TAG_SYMLINK:
        return rdb.SymbolicLinkReparseBuffer.PrintName
    elif rdb.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT:
        return rdb.MountPointReparseBuffer.PrintName
    raise ValueError("not a link")


# symlink function from Stackoverflow user Gian Marco Gherardi, 23 Feb 2013
# http://stackoverflow.com/a/15043806
def symlink(source, link_name):
    csl = kernel32.CreateSymbolicLinkW
    csl.argtypes = (c_wchar_p, c_wchar_p, c_uint32)
    csl.restype = c_ubyte

    flags = 1 if os.path.isdir(source) else 0

    if csl(link_name, source, flags) == 0:
        raise WinError()


# reimplement copytree, but using the windows-specfic symlink functions
def copytree(src, dst, symlinks=False):
    names = os.listdir(src)
    os.makedirs(dst)
    errors = []
    for name in names:
        srcname = os.path.join(src, name)
        dstname = os.path.join(dst, name)
        try:
            if symlinks and islink(srcname):
                linkto = readlink(srcname)
                symlink(linkto, dstname)
            elif os.path.isdir(srcname):
                copytree(srcname, dstname, symlinks)
            else:
                copy2(srcname, dstname)
        except OSError as why:
            errors.append((srcname, dstname, str(why)))
        # catch the Error from the recursive copytree so that we can
        # continue with other files
        except Error as err:
            errors.extend(err.args[0])
    try:
        copystat(src, dst)
    except OSError as why:
        # can't copy file access times on Windows
        if why.winerror is None:
            errors.extend((src, dst, str(why)))
    if errors:
        raise Error(errors)


1			# Functions for identifying and following symlinks in Windows
2			# from user `eryksun` http://stackoverflow.com/a/27979160
3			# 16 Jan 2015
4			# See http://stackoverflow.com/a/15259028 for more information
5
6			import os
7			from shutil import copystat, copy2, Error
8
9			from ctypes import c_ubyte, c_buffer, c_wchar_p, c_uint32
10			from ctypes.wintypes import (
11			POINTER, DWORD, LPCWSTR, HANDLE,
12			LPVOID, BOOL, USHORT, WCHAR, ULONG,
13			WinDLL, Structure, addressof, WinError,
14			Union, byref
15			)
16
17			kernel32 = WinDLL('kernel32')
18			LPDWORD = POINTER(DWORD)
19			UCHAR = c_ubyte
20
21			GetFileAttributesW = kernel32.GetFileAttributesW
22			GetFileAttributesW.restype = DWORD
23			GetFileAttributesW.argtypes = (LPCWSTR,) # lpFileName In
24
25			INVALID_FILE_ATTRIBUTES = 0xFFFFFFFF
26			FILE_ATTRIBUTE_REPARSE_POINT = 0x00400
27
28			CreateFileW = kernel32.CreateFileW
29			CreateFileW.restype = HANDLE
30			CreateFileW.argtypes = (LPCWSTR, # lpFileName In
31			DWORD, # dwDesiredAccess In
32			DWORD, # dwShareMode In
33			LPVOID, # lpSecurityAttributes In_opt
34			DWORD, # dwCreationDisposition In
35			DWORD, # dwFlagsAndAttributes In
36			HANDLE) # hTemplateFile In_opt
37
38			CloseHandle = kernel32.CloseHandle
39			CloseHandle.restype = BOOL
40			CloseHandle.argtypes = (HANDLE,) # hObject In
41
42			INVALID_HANDLE_VALUE = HANDLE(-1).value
43			OPEN_EXISTING = 3
44			FILE_FLAG_BACKUP_SEMANTICS = 0x02000000
45			FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000
46
47			DeviceIoControl = kernel32.DeviceIoControl
48			DeviceIoControl.restype = BOOL
49			DeviceIoControl.argtypes = (HANDLE, # hDevice In
50			DWORD, # dwIoControlCode In
51			LPVOID, # lpInBuffer In_opt
52			DWORD, # nInBufferSize In
53			LPVOID, # lpOutBuffer Out_opt
54			DWORD, # nOutBufferSize In
55			LPDWORD, # lpBytesReturned Out_opt
56			LPVOID) # lpOverlapped Inout_opt
57
58			FSCTL_GET_REPARSE_POINT = 0x000900A8
59			IO_REPARSE_TAG_MOUNT_POINT = 0xA0000003
60			IO_REPARSE_TAG_SYMLINK = 0xA000000C
61			MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 0x4000
62
63
64			class GENERIC_REPARSE_BUFFER(Structure):
65			_fields_ = (('DataBuffer', UCHAR * 1),)
66
67
68			class SYMBOLIC_LINK_REPARSE_BUFFER(Structure):
69			_fields_ = (('SubstituteNameOffset', USHORT),
70			('SubstituteNameLength', USHORT),
71			('PrintNameOffset', USHORT),
72			('PrintNameLength', USHORT),
73			('Flags', ULONG),
74			('PathBuffer', WCHAR * 1))
75
76			@property
77			def PrintName(self):
78			arrayt = WCHAR * (self.PrintNameLength // 2)
79			offset = type(self).PathBuffer.offset + self.PrintNameOffset
80			return arrayt.from_address(addressof(self) + offset).value
81
82
83			class MOUNT_POINT_REPARSE_BUFFER(Structure):
84			_fields_ = (('SubstituteNameOffset', USHORT),
85			('SubstituteNameLength', USHORT),
86			('PrintNameOffset', USHORT),
87			('PrintNameLength', USHORT),
88			('PathBuffer', WCHAR * 1))
89
90			@property
91			def PrintName(self):
92			arrayt = WCHAR * (self.PrintNameLength // 2)
93			offset = type(self).PathBuffer.offset + self.PrintNameOffset
94			return arrayt.from_address(addressof(self) + offset).value
95
96
97			class REPARSE_DATA_BUFFER(Structure):
98			class REPARSE_BUFFER(Union):
99			_fields_ = (('SymbolicLinkReparseBuffer',
100			SYMBOLIC_LINK_REPARSE_BUFFER),
101			('MountPointReparseBuffer',
102			MOUNT_POINT_REPARSE_BUFFER),
103			('GenericReparseBuffer',
104			GENERIC_REPARSE_BUFFER))
105			_fields_ = (('ReparseTag', ULONG),
106			('ReparseDataLength', USHORT),
107			('Reserved', USHORT),
108			('ReparseBuffer', REPARSE_BUFFER))
109			_anonymous_ = ('ReparseBuffer',)
110
111
112			def islink(path):
113			result = GetFileAttributesW(path)
114			if result == INVALID_FILE_ATTRIBUTES:
115			raise WinError()
116			return bool(result & FILE_ATTRIBUTE_REPARSE_POINT)
117
118
119			def readlink(path):
120			reparse_point_handle = CreateFileW(path,
121			0,
122			0,
123			None,
124			OPEN_EXISTING,
125			FILE_FLAG_OPEN_REPARSE_POINT \|
126			FILE_FLAG_BACKUP_SEMANTICS,
127			None)
128			if reparse_point_handle == INVALID_HANDLE_VALUE:
129			raise WinError()
130			target_buffer = c_buffer(MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
131			n_bytes_returned = DWORD()
132			io_result = DeviceIoControl(reparse_point_handle,
133			FSCTL_GET_REPARSE_POINT,
134			None, 0,
135			target_buffer, len(target_buffer),
136			byref(n_bytes_returned),
137			None)
138			CloseHandle(reparse_point_handle)
139			if not io_result:
140			raise WinError()
141			rdb = REPARSE_DATA_BUFFER.from_buffer(target_buffer)
142			if rdb.ReparseTag == IO_REPARSE_TAG_SYMLINK:
143			return rdb.SymbolicLinkReparseBuffer.PrintName
144			elif rdb.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT:
145			return rdb.MountPointReparseBuffer.PrintName
146			raise ValueError("not a link")
147
148
149			# symlink function from Stackoverflow user Gian Marco Gherardi, 23 Feb 2013
150			# http://stackoverflow.com/a/15043806
151			def symlink(source, link_name):
152			csl = kernel32.CreateSymbolicLinkW
153			csl.argtypes = (c_wchar_p, c_wchar_p, c_uint32)
154			csl.restype = c_ubyte
155
156			flags = 1 if os.path.isdir(source) else 0
157
158			if csl(link_name, source, flags) == 0:
159			raise WinError()
160
161
162			# reimplement copytree, but using the windows-specfic symlink functions
163			def copytree(src, dst, symlinks=False):
164			names = os.listdir(src)
165			os.makedirs(dst)
166			errors = []
167			for name in names:
168			srcname = os.path.join(src, name)
169			dstname = os.path.join(dst, name)
170			try:
171			if symlinks and islink(srcname):
172			linkto = readlink(srcname)
173			symlink(linkto, dstname)
174			elif os.path.isdir(srcname):
175			copytree(srcname, dstname, symlinks)
176			else:
177			copy2(srcname, dstname)
178			except OSError as why:
179			errors.append((srcname, dstname, str(why)))
180			# catch the Error from the recursive copytree so that we can
181			# continue with other files
182			except Error as err:
183			errors.extend(err.args[0])
184			try:
185			copystat(src, dst)
186			except OSError as why:
187			# can't copy file access times on Windows
188			if why.winerror is None:
189			errors.extend((src, dst, str(why)))
190			if errors:
191			raise Error(errors)
192

audreyr / cookiecutter

Pull Request — master (#868)

SYMBOLIC_LINK_REPARSE_BUFFER.PrintName() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like