/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to brzlib/win32utils.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 12:41:27 UTC
  • mto: This revision was merged to the branch mainline in revision 6623.
  • Revision ID: jelmer@jelmer.uk-20170521124127-iv8etg0vwymyai6y
s/bzr/brz/ in apport config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
brzlib/win32utils.py
19
19
Only one dependency: ctypes should be installed.
20
20
"""
21
21
 
 
22
from __future__ import absolute_import
 
23
 
22
24
import glob
 
25
import operator
23
26
import os
24
27
import struct
25
28
import sys
26
29
 
27
 
from breezy import (
 
30
from brzlib import (
28
31
    cmdline,
 
32
    symbol_versioning,
29
33
    )
30
 
from breezy.i18n import gettext
 
34
from brzlib.i18n import gettext
31
35
 
32
 
has_ctypes_win32 = False
 
36
# Windows version
33
37
if sys.platform == 'win32':
34
 
    try:
35
 
        import ctypes
36
 
    except ImportError:
37
 
        has_ctypes_win32 = False
38
 
 
 
38
    _major,_minor,_build,_platform,_text = sys.getwindowsversion()
 
39
    # from MSDN:
 
40
    # dwPlatformId
 
41
    #   The operating system platform.
 
42
    #   This member can be one of the following values.
 
43
    #   ==========================  ======================================
 
44
    #   Value                       Meaning
 
45
    #   --------------------------  --------------------------------------
 
46
    #   VER_PLATFORM_WIN32_NT       The operating system is Windows Vista,
 
47
    #   2                           Windows Server "Longhorn",
 
48
    #                               Windows Server 2003, Windows XP,
 
49
    #                               Windows 2000, or Windows NT.
 
50
    #
 
51
    #   VER_PLATFORM_WIN32_WINDOWS  The operating system is Windows Me,
 
52
    #   1                           Windows 98, or Windows 95.
 
53
    #   ==========================  ======================================
 
54
    if _platform == 2:
 
55
        winver = 'Windows NT'
 
56
    else:
 
57
        # don't care about real Windows name, just to force safe operations
 
58
        winver = 'Windows 98'
 
59
else:
 
60
    winver = None
 
61
 
 
62
 
 
63
# We can cope without it; use a separate variable to help pyflakes
 
64
try:
 
65
    import ctypes
 
66
    has_ctypes = True
 
67
except ImportError:
 
68
    has_ctypes = False
 
69
else:
 
70
    if winver == 'Windows 98':
 
71
        create_buffer = ctypes.create_string_buffer
 
72
        def extract_buffer(buf):
 
73
            return buf.value.decode("mbcs")
 
74
        suffix = 'A'
 
75
    else:
 
76
        create_buffer = ctypes.create_unicode_buffer
 
77
        extract_buffer = operator.attrgetter("value")
 
78
        suffix = 'W'
 
79
try:
 
80
    import pywintypes
 
81
    has_pywintypes = True
 
82
except ImportError:
 
83
    has_pywintypes = has_win32file = has_win32api = False
 
84
else:
 
85
    try:
 
86
        import win32file
 
87
        has_win32file = True
 
88
    except ImportError:
 
89
        has_win32file = False
 
90
    try:
 
91
        import win32api
 
92
        has_win32api = True
 
93
    except ImportError:
 
94
        has_win32api = False
 
95
 
 
96
# pulling in win32com.shell is a bit of overhead, and normally we don't need
 
97
# it as ctypes is preferred and common.  lazy_imports and "optional"
 
98
# modules don't work well, so we do our own lazy thing...
 
99
has_win32com_shell = None # Set to True or False once we know for sure...
39
100
 
40
101
# Special Win32 API constants
41
102
# Handles of std streams
45
106
 
46
107
# CSIDL constants (from MSDN 2003)
47
108
CSIDL_APPDATA = 0x001A      # Application Data folder
48
 
# <user name>\Local Settings\Application Data (non roaming)
49
 
CSIDL_LOCAL_APPDATA = 0x001c
 
109
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
50
110
CSIDL_PERSONAL = 0x0005     # My Documents folder
51
111
 
52
112
# from winapi C headers
61
121
 
62
122
def debug_memory_win32api(message='', short=True):
63
123
    """Use trace.note() to dump the running memory info."""
64
 
    from breezy import trace
65
 
    if has_ctypes_win32:
 
124
    from brzlib import trace
 
125
    if has_ctypes:
66
126
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
67
127
            """Used by GetProcessMemoryInfo"""
68
128
            _fields_ = [('cb', ctypes.c_ulong),
76
136
                        ('PagefileUsage', ctypes.c_size_t),
77
137
                        ('PeakPagefileUsage', ctypes.c_size_t),
78
138
                        ('PrivateUsage', ctypes.c_size_t),
79
 
                        ]
 
139
                       ]
80
140
        cur_process = ctypes.windll.kernel32.GetCurrentProcess()
81
141
        mem_struct = PROCESS_MEMORY_COUNTERS_EX()
82
 
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(
83
 
            cur_process, ctypes.byref(mem_struct), ctypes.sizeof(mem_struct))
 
142
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
 
143
            ctypes.byref(mem_struct),
 
144
            ctypes.sizeof(mem_struct))
84
145
        if not ret:
85
146
            trace.note(gettext('Failed to GetProcessMemoryInfo()'))
86
147
            return
95
156
                'PagefileUsage': mem_struct.PagefileUsage,
96
157
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
97
158
                'PrivateUsage': mem_struct.PrivateUsage,
98
 
                }
 
159
               }
 
160
    elif has_win32api:
 
161
        import win32process
 
162
        # win32process does not return PrivateUsage, because it doesn't use
 
163
        # PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
 
164
        proc = win32process.GetCurrentProcess()
 
165
        info = win32process.GetProcessMemoryInfo(proc)
99
166
    else:
100
167
        trace.note(gettext('Cannot debug memory on win32 without ctypes'
101
 
                           ' or win32process'))
 
168
                   ' or win32process'))
102
169
        return
103
170
    if short:
104
171
        # using base-2 units (see HACKING.txt).
105
172
        trace.note(gettext('WorkingSize {0:>7}KiB'
106
 
                           '\tPeakWorking {1:>7}KiB\t{2}').format(
 
173
                   '\tPeakWorking {1:>7}KiB\t{2}').format(
107
174
                   info['WorkingSetSize'] / 1024,
108
175
                   info['PeakWorkingSetSize'] / 1024,
109
176
                   message))
110
177
        return
111
178
    if message:
112
179
        trace.note('%s', message)
113
 
    trace.note(gettext('WorkingSize       %8d KiB'),
114
 
               info['WorkingSetSize'] / 1024)
115
 
    trace.note(gettext('PeakWorking       %8d KiB'),
116
 
               info['PeakWorkingSetSize'] / 1024)
117
 
    trace.note(gettext('PagefileUsage     %8d KiB'),
118
 
               info.get('PagefileUsage', 0) / 1024)
 
180
    trace.note(gettext('WorkingSize       %8d KiB'), info['WorkingSetSize'] / 1024)
 
181
    trace.note(gettext('PeakWorking       %8d KiB'), info['PeakWorkingSetSize'] / 1024)
 
182
    trace.note(gettext('PagefileUsage     %8d KiB'), info.get('PagefileUsage', 0) / 1024)
119
183
    trace.note(gettext('PeakPagefileUsage %8d KiB'),
120
184
               info.get('PeakPagefileUsage', 0) / 1024)
121
 
    trace.note(gettext('PrivateUsage      %8d KiB'),
122
 
               info.get('PrivateUsage', 0) / 1024)
 
185
    trace.note(gettext('PrivateUsage      %8d KiB'), info.get('PrivateUsage', 0) / 1024)
123
186
    trace.note(gettext('PageFaultCount    %8d'), info.get('PageFaultCount', 0))
124
187
 
125
188
 
130
193
    console window and return tuple (sizex, sizey) if success,
131
194
    or default size (defaultx, defaulty) otherwise.
132
195
    """
133
 
    if not has_ctypes_win32:
 
196
    if not has_ctypes:
134
197
        # no ctypes is found
135
198
        return (defaultx, defaulty)
136
199
 
142
205
 
143
206
    if res:
144
207
        (bufx, bufy, curx, cury, wattr,
145
 
         left, top, right, bottom, maxx, maxy) = struct.unpack(
 
208
        left, top, right, bottom, maxx, maxy) = struct.unpack(
146
209
            "hhhhHhhhhhh", csbi.raw)
147
210
        sizex = right - left + 1
148
211
        sizey = bottom - top + 1
156
219
 
157
220
    Result is always unicode (or None).
158
221
    """
159
 
    if has_ctypes_win32:
 
222
    if has_ctypes:
160
223
        try:
161
224
            SHGetSpecialFolderPath = \
162
225
                ctypes.windll.shell32.SHGetSpecialFolderPathW
164
227
            pass
165
228
        else:
166
229
            buf = ctypes.create_unicode_buffer(MAX_PATH)
167
 
            if SHGetSpecialFolderPath(None, buf, csidl, 0):
 
230
            if SHGetSpecialFolderPath(None,buf,csidl,0):
168
231
                return buf.value
 
232
 
 
233
    global has_win32com_shell
 
234
    if has_win32com_shell is None:
 
235
        try:
 
236
            from win32com.shell import shell
 
237
            has_win32com_shell = True
 
238
        except ImportError:
 
239
            has_win32com_shell = False
 
240
    if has_win32com_shell:
 
241
        # still need to bind the name locally, but this is fast.
 
242
        from win32com.shell import shell
 
243
        try:
 
244
            return shell.SHGetSpecialFolderPath(0, csidl, 0)
 
245
        except shell.error:
 
246
            # possibly E_NOTIMPL meaning we can't load the function pointer,
 
247
            # or E_FAIL meaning the function failed - regardless, just ignore it
 
248
            pass
169
249
    return None
170
250
 
171
251
 
225
305
    if windir:
226
306
        return os.path.splitdrive(windir)[0] + '/'
227
307
    # otherwise C:\ is good enough for 98% users
228
 
    return u'C:/'
 
308
    return unicode('C:/')
229
309
 
230
310
 
231
311
def get_user_name():
232
312
    """Return user name as login name.
233
313
    If name cannot be obtained return None.
234
314
    """
235
 
    if has_ctypes_win32:
 
315
    if has_ctypes:
236
316
        try:
237
317
            advapi32 = ctypes.windll.advapi32
238
 
            GetUserName = getattr(advapi32, 'GetUserNameW')
 
318
            GetUserName = getattr(advapi32, 'GetUserName'+suffix)
239
319
        except AttributeError:
240
320
            pass
241
321
        else:
242
 
            buf = ctypes.create_unicode_buffer(UNLEN + 1)
243
 
            n = ctypes.c_int(UNLEN + 1)
 
322
            buf = create_buffer(UNLEN+1)
 
323
            n = ctypes.c_int(UNLEN+1)
244
324
            if GetUserName(buf, ctypes.byref(n)):
245
 
                return buf.value
 
325
                return extract_buffer(buf)
246
326
    # otherwise try env variables
247
327
    return get_environ_unicode('USERNAME')
248
328
 
251
331
# computer or the cluster associated with the local computer."
252
332
_WIN32_ComputerNameDnsHostname = 1
253
333
 
254
 
 
255
334
def get_host_name():
256
335
    """Return host machine name.
257
336
    If name cannot be obtained return None.
258
337
 
259
338
    :return: A unicode string representing the host name.
260
339
    """
261
 
    if has_ctypes_win32:
 
340
    if has_win32api:
 
341
        try:
 
342
            return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
 
343
        except (NotImplementedError, win32api.error):
 
344
            # NotImplemented will happen on win9x...
 
345
            pass
 
346
    if has_ctypes:
262
347
        try:
263
348
            kernel32 = ctypes.windll.kernel32
264
349
        except AttributeError:
265
 
            pass  # Missing the module we need
 
350
            pass # Missing the module we need
266
351
        else:
267
 
            buf = ctypes.create_unicode_buffer(MAX_COMPUTERNAME_LENGTH + 1)
268
 
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH + 1)
 
352
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
 
353
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
269
354
 
270
355
            # Try GetComputerNameEx which gives a proper Unicode hostname
271
 
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameExW', None)
 
356
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
 
357
                                        None)
272
358
            if (GetComputerNameEx is not None
273
359
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
274
360
                                      buf, ctypes.byref(n))):
275
 
                return buf.value
 
361
                return extract_buffer(buf)
 
362
 
 
363
            # Try GetComputerName in case GetComputerNameEx wasn't found
 
364
            # It returns the NETBIOS name, which isn't as good, but still ok.
 
365
            # The first GetComputerNameEx might have changed 'n', so reset it
 
366
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
 
367
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
 
368
                                      None)
 
369
            if (GetComputerName is not None
 
370
                and GetComputerName(buf, ctypes.byref(n))):
 
371
                return extract_buffer(buf)
276
372
    return get_environ_unicode('COMPUTERNAME')
277
373
 
278
374
 
 
375
@symbol_versioning.deprecated_function(
 
376
    symbol_versioning.deprecated_in((2, 5, 0)))
 
377
def _ensure_unicode(s):
 
378
    if s and type(s) != unicode:
 
379
        from brzlib import osutils
 
380
        s = s.decode(osutils.get_user_encoding())
 
381
    return s
 
382
 
 
383
 
 
384
get_appdata_location_unicode = symbol_versioning.deprecated_function(
 
385
    symbol_versioning.deprecated_in((2, 5, 0)))(get_appdata_location)
 
386
 
 
387
get_home_location_unicode = symbol_versioning.deprecated_function(
 
388
    symbol_versioning.deprecated_in((2, 5, 0)))(get_home_location)
 
389
 
 
390
get_user_name_unicode = symbol_versioning.deprecated_function(
 
391
    symbol_versioning.deprecated_in((2, 5, 0)))(get_user_name)
 
392
 
 
393
get_host_name_unicode = symbol_versioning.deprecated_function(
 
394
    symbol_versioning.deprecated_in((2, 5, 0)))(get_host_name)
 
395
 
 
396
 
279
397
def _ensure_with_dir(path):
280
398
    if (not os.path.split(path)[0] or path.startswith(u'*')
281
 
            or path.startswith(u'?')):
 
399
        or path.startswith(u'?')):
282
400
        return u'./' + path, True
283
401
    else:
284
402
        return path, False
285
403
 
286
 
 
287
404
def _undo_ensure_with_dir(path, corrected):
288
405
    if corrected:
289
406
        return path[2:]
320
437
    :param file_list: A list of filenames which may include shell globs.
321
438
    :return: An expanded list of filenames.
322
439
 
323
 
    Introduced in breezy 0.18.
 
440
    Introduced in brzlib 0.18.
324
441
    """
325
442
    if not file_list:
326
443
        return []
348
465
 
349
466
    try:
350
467
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
351
 
                               'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
352
 
                               basename)
 
468
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
 
469
            basename)
353
470
    except EnvironmentError:
354
471
        return appname
355
472
 
373
490
 
374
491
def set_file_attr_hidden(path):
375
492
    """Set file attributes to hidden if possible"""
376
 
    if not has_ctypes_win32:
377
 
        return
378
 
    from ctypes.wintypes import BOOL, DWORD, LPCWSTR
379
 
    _kernel32 = ctypes.windll.kernel32
380
 
    # <https://docs.microsoft.com/windows/desktop/api/fileapi/nf-fileapi-setfileattributesw>
381
 
    _SetFileAttributesW = ctypes.WINFUNCTYPE(BOOL, LPCWSTR, DWORD)(
382
 
        ("SetFileAttributesW", _kernel32))
383
 
    FILE_ATTRIBUTE_HIDDEN = 2
384
 
    if not SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN):
385
 
        e = ctypes.WinError()
386
 
        from . import trace
387
 
        trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
 
493
    if has_win32file:
 
494
        if winver != 'Windows 98':
 
495
            SetFileAttributes = win32file.SetFileAttributesW
 
496
        else:
 
497
            SetFileAttributes = win32file.SetFileAttributes
 
498
        try:
 
499
            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
 
500
        except pywintypes.error, e:
 
501
            from brzlib import trace
 
502
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
388
503
 
389
504
 
390
505
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
401
516
    :return: A list of unicode strings.
402
517
    """
403
518
    # First, split the command line
404
 
    s = cmdline.Splitter(
405
 
        command_line, single_quotes_allowed=single_quotes_allowed)
406
 
 
407
 
    # Bug #587868 Now make sure that the length of s agrees with sys.argv
408
 
    # we do this by simply counting the number of arguments in each. The counts should
409
 
    # agree no matter what encoding sys.argv is in (AFAIK)
410
 
    # len(arguments) < len(sys.argv) should be an impossibility since python gets
 
519
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
 
520
    
 
521
    # Bug #587868 Now make sure that the length of s agrees with sys.argv 
 
522
    # we do this by simply counting the number of arguments in each. The counts should 
 
523
    # agree no matter what encoding sys.argv is in (AFAIK) 
 
524
    # len(arguments) < len(sys.argv) should be an impossibility since python gets 
411
525
    # args from the very same PEB as does GetCommandLineW
412
526
    arguments = list(s)
413
 
 
 
527
    
414
528
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
415
529
    if len(arguments) < len(argv):
416
530
        raise AssertionError("Split command line can't be shorter than argv")
417
531
    arguments = arguments[len(arguments) - len(argv):]
418
 
 
 
532
    
419
533
    # Carry on to process globs (metachars) in the command line
420
534
    # expand globs if necessary
421
535
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
429
543
    return args
430
544
 
431
545
 
432
 
if has_ctypes_win32:
 
546
if has_ctypes and winver == 'Windows NT':
433
547
    def get_unicode_argv():
434
548
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
435
549
        GetCommandLineW = prototype(("GetCommandLineW",
440
554
        # Skip the first argument, since we only care about parameters
441
555
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
442
556
        return argv
 
557
    
443
558
 
444
559
    def get_environ_unicode(key, default=None):
445
560
        """Get `key` from environment as unicode or `default` if unset
451
566
 
452
567
        A large enough buffer will be allocated to retrieve the value, though
453
568
        it may take two calls to the underlying library function.
 
569
 
 
570
        This needs ctypes because pywin32 does not expose the wide version.
454
571
        """
455
572
        cfunc = getattr(get_environ_unicode, "_c_function", None)
456
573
        if cfunc is None:
458
575
            cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
459
576
                ("GetEnvironmentVariableW", ctypes.windll.kernel32))
460
577
            get_environ_unicode._c_function = cfunc
461
 
        buffer_size = 256  # heuristic, 256 characters often enough
 
578
        buffer_size = 256 # heuristic, 256 characters often enough
462
579
        while True:
463
 
            buf = ctypes.create_unicode_buffer(buffer_size)
464
 
            length = cfunc(key, buf, buffer_size)
 
580
            buffer = ctypes.create_unicode_buffer(buffer_size)
 
581
            length = cfunc(key, buffer, buffer_size)
465
582
            if not length:
466
583
                code = ctypes.GetLastError()
467
 
                if code == 203:  # ERROR_ENVVAR_NOT_FOUND
 
584
                if code == 203: # ERROR_ENVVAR_NOT_FOUND
468
585
                    return default
469
586
                raise ctypes.WinError(code)
470
587
            if buffer_size > length:
471
 
                return buf[:length]
 
588
                return buffer[:length]
472
589
            buffer_size = length
473
 
 
474
 
 
475
 
if has_ctypes_win32:
 
590
else:
 
591
    get_unicode_argv = None
 
592
    def get_environ_unicode(key, default=None):
 
593
        """Get `key` from environment as unicode or `default` if unset
 
594
 
 
595
        Fallback version that should basically never be needed.
 
596
        """
 
597
        from brzlib import osutils
 
598
        try:
 
599
            return os.environ[key].decode(osutils.get_user_encoding())
 
600
        except KeyError:
 
601
            return default
 
602
 
 
603
 
 
604
if has_win32api:
 
605
    def _pywin32_is_local_pid_dead(pid):
 
606
        """True if pid doesn't correspond to live process on this machine"""
 
607
        try:
 
608
            handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
 
609
        except pywintypes.error, e:
 
610
            if e[0] == 5: # ERROR_ACCESS_DENIED
 
611
                # Probably something alive we're not allowed to kill
 
612
                return False
 
613
            elif e[0] == 87: # ERROR_INVALID_PARAMETER
 
614
                return True
 
615
            raise
 
616
        handle.close()
 
617
        return False
 
618
    is_local_pid_dead = _pywin32_is_local_pid_dead
 
619
elif has_ctypes and sys.platform == 'win32':
476
620
    from ctypes.wintypes import BOOL, DWORD, HANDLE
477
621
    _kernel32 = ctypes.windll.kernel32
478
622
    _CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
479
623
        ("CloseHandle", _kernel32))
480
624
    _OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
481
625
        ("OpenProcess", _kernel32))
482
 
 
483
626
    def _ctypes_is_local_pid_dead(pid):
484
627
        """True if pid doesn't correspond to live process on this machine"""
485
 
        handle = _OpenProcess(1, False, pid)  # PROCESS_TERMINATE
 
628
        handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
486
629
        if not handle:
487
630
            errorcode = ctypes.GetLastError()
488
 
            if errorcode == 5:  # ERROR_ACCESS_DENIED
 
631
            if errorcode == 5: # ERROR_ACCESS_DENIED
489
632
                # Probably something alive we're not allowed to kill
490
633
                return False
491
 
            elif errorcode == 87:  # ERROR_INVALID_PARAMETER
 
634
            elif errorcode == 87: # ERROR_INVALID_PARAMETER
492
635
                return True
493
636
            raise ctypes.WinError(errorcode)
494
637
        _CloseHandle(handle)
495
638
        return False
496
 
 
497
639
    is_local_pid_dead = _ctypes_is_local_pid_dead
 
640
 
 
641
 
 
642
def _is_pywintypes_error(evalue):
 
643
    """True if exception instance is an error from pywin32"""
 
644
    if has_pywintypes and isinstance(evalue, pywintypes.error):
 
645
        return True
 
646
    return False