/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 bzrlib/win32utils.py

  • Committer: Andrew Bennetts
  • Date: 2009-10-21 11:13:40 UTC
  • mto: This revision was merged to the branch mainline in revision 4762.
  • Revision ID: andrew.bennetts@canonical.com-20091021111340-w7x4d5yf83qwjncc
Add test that WSGI glue allows request handlers to access paths above that request's. backing transport, so long as it is within the WSGI app's backing transport.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/win32utils.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
19
19
Only one dependency: ctypes should be installed.
20
20
"""
21
21
 
22
 
from __future__ import absolute_import
23
 
 
24
 
import glob
25
 
import operator
26
22
import os
27
23
import struct
28
24
import sys
29
25
 
30
 
from breezy import (
31
 
    cmdline,
32
 
    )
33
 
from breezy.i18n import gettext
 
26
 
 
27
# Windows version
 
28
if sys.platform == 'win32':
 
29
    _major,_minor,_build,_platform,_text = sys.getwindowsversion()
 
30
    # from MSDN:
 
31
    # dwPlatformId
 
32
    #   The operating system platform.
 
33
    #   This member can be one of the following values.
 
34
    #   ==========================  ======================================
 
35
    #   Value                       Meaning
 
36
    #   --------------------------  --------------------------------------
 
37
    #   VER_PLATFORM_WIN32_NT       The operating system is Windows Vista,
 
38
    #   2                           Windows Server "Longhorn",
 
39
    #                               Windows Server 2003, Windows XP,
 
40
    #                               Windows 2000, or Windows NT.
 
41
    #
 
42
    #   VER_PLATFORM_WIN32_WINDOWS  The operating system is Windows Me,
 
43
    #   1                           Windows 98, or Windows 95.
 
44
    #   ==========================  ======================================
 
45
    if _platform == 2:
 
46
        winver = 'Windows NT'
 
47
    else:
 
48
        # don't care about real Windows name, just to force safe operations
 
49
        winver = 'Windows 98'
 
50
else:
 
51
    winver = None
 
52
 
34
53
 
35
54
# We can cope without it; use a separate variable to help pyflakes
36
55
try:
39
58
except ImportError:
40
59
    has_ctypes = False
41
60
else:
42
 
    create_buffer = ctypes.create_unicode_buffer
43
 
    extract_buffer = operator.attrgetter("value")
44
 
    suffix = 'W'
 
61
    if winver == 'Windows 98':
 
62
        create_buffer = ctypes.create_string_buffer
 
63
        suffix = 'A'
 
64
    else:
 
65
        create_buffer = ctypes.create_unicode_buffer
 
66
        suffix = 'W'
45
67
try:
 
68
    import win32file
46
69
    import pywintypes
47
 
    has_pywintypes = True
48
 
except ImportError:
49
 
    has_pywintypes = has_win32file = has_win32api = False
50
 
else:
51
 
    try:
52
 
        import win32file
53
 
        has_win32file = True
54
 
    except ImportError:
55
 
        has_win32file = False
56
 
    try:
57
 
        import win32api
58
 
        has_win32api = True
59
 
    except ImportError:
60
 
        has_win32api = False
 
70
    has_win32file = True
 
71
except ImportError:
 
72
    has_win32file = False
 
73
try:
 
74
    import win32api
 
75
    has_win32api = True
 
76
except ImportError:
 
77
    has_win32api = False
61
78
 
62
79
# pulling in win32com.shell is a bit of overhead, and normally we don't need
63
80
# it as ctypes is preferred and common.  lazy_imports and "optional"
87
104
 
88
105
def debug_memory_win32api(message='', short=True):
89
106
    """Use trace.note() to dump the running memory info."""
90
 
    from breezy import trace
 
107
    from bzrlib import trace
91
108
    if has_ctypes:
92
109
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
93
110
            """Used by GetProcessMemoryInfo"""
109
126
            ctypes.byref(mem_struct),
110
127
            ctypes.sizeof(mem_struct))
111
128
        if not ret:
112
 
            trace.note(gettext('Failed to GetProcessMemoryInfo()'))
 
129
            trace.note('Failed to GetProcessMemoryInfo()')
113
130
            return
114
131
        info = {'PageFaultCount': mem_struct.PageFaultCount,
115
132
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
116
133
                'WorkingSetSize': mem_struct.WorkingSetSize,
117
134
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
118
135
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
119
 
                'QuotaPeakNonPagedPoolUsage':
120
 
                    mem_struct.QuotaPeakNonPagedPoolUsage,
 
136
                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
121
137
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
122
138
                'PagefileUsage': mem_struct.PagefileUsage,
123
139
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
130
146
        proc = win32process.GetCurrentProcess()
131
147
        info = win32process.GetProcessMemoryInfo(proc)
132
148
    else:
133
 
        trace.note(gettext('Cannot debug memory on win32 without ctypes'
134
 
                   ' or win32process'))
 
149
        trace.note('Cannot debug memory on win32 without ctypes'
 
150
                   ' or win32process')
135
151
        return
136
152
    if short:
137
 
        # using base-2 units (see HACKING.txt).
138
 
        trace.note(gettext('WorkingSize {0:>7}KiB'
139
 
                   '\tPeakWorking {1:>7}KiB\t{2}').format(
 
153
        trace.note('WorkingSize %7dKB'
 
154
                   '\tPeakWorking %7dKB\t%s',
140
155
                   info['WorkingSetSize'] / 1024,
141
156
                   info['PeakWorkingSetSize'] / 1024,
142
 
                   message))
 
157
                   message)
143
158
        return
144
159
    if message:
145
160
        trace.note('%s', message)
146
 
    trace.note(gettext('WorkingSize       %8d KiB'), info['WorkingSetSize'] / 1024)
147
 
    trace.note(gettext('PeakWorking       %8d KiB'), info['PeakWorkingSetSize'] / 1024)
148
 
    trace.note(gettext('PagefileUsage     %8d KiB'), info.get('PagefileUsage', 0) / 1024)
149
 
    trace.note(gettext('PeakPagefileUsage %8d KiB'),
150
 
               info.get('PeakPagefileUsage', 0) / 1024)
151
 
    trace.note(gettext('PrivateUsage      %8d KiB'), info.get('PrivateUsage', 0) / 1024)
152
 
    trace.note(gettext('PageFaultCount    %8d'), info.get('PageFaultCount', 0))
 
161
    trace.note('WorkingSize       %8d KB', info['WorkingSetSize'] / 1024)
 
162
    trace.note('PeakWorking       %8d KB', info['PeakWorkingSetSize'] / 1024)
 
163
    trace.note('PagefileUsage     %8d KB', info.get('PagefileUsage', 0) / 1024)
 
164
    trace.note('PeakPagefileUsage %8d KB', info.get('PeakPagefileUsage', 0) / 1024)
 
165
    trace.note('PrivateUsage      %8d KB', info.get('PrivateUsage', 0) / 1024)
 
166
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
153
167
 
154
168
 
155
169
def get_console_size(defaultx=80, defaulty=25):
164
178
        return (defaultx, defaulty)
165
179
 
166
180
    # To avoid problem with redirecting output via pipe
167
 
    # we need to use stderr instead of stdout
 
181
    # need to use stderr instead of stdout
168
182
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
169
183
    csbi = ctypes.create_string_buffer(22)
170
184
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
171
185
 
172
186
    if res:
173
187
        (bufx, bufy, curx, cury, wattr,
174
 
        left, top, right, bottom, maxx, maxy) = struct.unpack(
175
 
            "hhhhHhhhhhh", csbi.raw)
 
188
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
176
189
        sizex = right - left + 1
177
190
        sizey = bottom - top + 1
178
191
        return (sizex, sizey)
193
206
            pass
194
207
        else:
195
208
            buf = ctypes.create_unicode_buffer(MAX_PATH)
196
 
            if SHGetSpecialFolderPath(None, buf, csidl, 0):
 
209
            if SHGetSpecialFolderPath(None,buf,csidl,0):
197
210
                return buf.value
198
211
 
199
212
    global has_win32com_shell
223
236
    one that moves with the user as they logon to different machines, and
224
237
    a 'local' one that stays local to the machine.  This returns the 'roaming'
225
238
    directory, and thus is suitable for storing user-preferences, etc.
 
239
 
 
240
    Returned value can be unicode or plain string.
 
241
    To convert plain string to unicode use
 
242
    s.decode(osutils.get_user_encoding())
 
243
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
226
244
    """
227
245
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
228
246
    if appdata:
229
247
        return appdata
230
 
    # Use APPDATA if defined, will return None if not
231
 
    return get_environ_unicode('APPDATA')
 
248
    # from env variable
 
249
    appdata = os.environ.get('APPDATA')
 
250
    if appdata:
 
251
        return appdata
 
252
    # if we fall to this point we on win98
 
253
    # at least try C:/WINDOWS/Application Data
 
254
    windir = os.environ.get('windir')
 
255
    if windir:
 
256
        appdata = os.path.join(windir, 'Application Data')
 
257
        if os.path.isdir(appdata):
 
258
            return appdata
 
259
    # did not find anything
 
260
    return None
232
261
 
233
262
 
234
263
def get_local_appdata_location():
240
269
    a 'local' one that stays local to the machine.  This returns the 'local'
241
270
    directory, and thus is suitable for caches, temp files and other things
242
271
    which don't need to move with the user.
 
272
 
 
273
    Returned value can be unicode or plain string.
 
274
    To convert plain string to unicode use
 
275
    s.decode(osutils.get_user_encoding())
 
276
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
243
277
    """
244
278
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
245
279
    if local:
246
280
        return local
247
281
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
248
 
    local = get_environ_unicode('LOCALAPPDATA')
 
282
    local = os.environ.get('LOCALAPPDATA')
249
283
    if local:
250
284
        return local
251
285
    return get_appdata_location()
256
290
    Assume on win32 it's the <My Documents> folder.
257
291
    If location cannot be obtained return system drive root,
258
292
    i.e. C:\
 
293
 
 
294
    Returned value can be unicode or plain string.
 
295
    To convert plain string to unicode use
 
296
    s.decode(osutils.get_user_encoding())
259
297
    """
260
298
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
261
299
    if home:
262
300
        return home
263
 
    home = get_environ_unicode('HOME')
264
 
    if home is not None:
 
301
    # try for HOME env variable
 
302
    home = os.path.expanduser('~')
 
303
    if home != '~':
265
304
        return home
266
 
    homepath = get_environ_unicode('HOMEPATH')
267
 
    if homepath is not None:
268
 
        return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
269
305
    # at least return windows root directory
270
 
    windir = get_environ_unicode('WINDIR')
 
306
    windir = os.environ.get('windir')
271
307
    if windir:
272
308
        return os.path.splitdrive(windir)[0] + '/'
273
309
    # otherwise C:\ is good enough for 98% users
274
 
    return u'C:/'
 
310
    return 'C:/'
275
311
 
276
312
 
277
313
def get_user_name():
278
314
    """Return user name as login name.
279
315
    If name cannot be obtained return None.
 
316
 
 
317
    Returned value can be unicode or plain string.
 
318
    To convert plain string to unicode use
 
319
    s.decode(osutils.get_user_encoding())
280
320
    """
281
321
    if has_ctypes:
282
322
        try:
288
328
            buf = create_buffer(UNLEN+1)
289
329
            n = ctypes.c_int(UNLEN+1)
290
330
            if GetUserName(buf, ctypes.byref(n)):
291
 
                return extract_buffer(buf)
 
331
                return buf.value
292
332
    # otherwise try env variables
293
 
    return get_environ_unicode('USERNAME')
 
333
    return os.environ.get('USERNAME', None)
294
334
 
295
335
 
296
336
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
301
341
    """Return host machine name.
302
342
    If name cannot be obtained return None.
303
343
 
304
 
    :return: A unicode string representing the host name.
 
344
    :return: A unicode string representing the host name. On win98, this may be
 
345
        a plain string as win32 api doesn't support unicode.
305
346
    """
306
347
    if has_win32api:
307
348
        try:
324
365
            if (GetComputerNameEx is not None
325
366
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
326
367
                                      buf, ctypes.byref(n))):
327
 
                return extract_buffer(buf)
 
368
                return buf.value
328
369
 
329
370
            # Try GetComputerName in case GetComputerNameEx wasn't found
330
371
            # It returns the NETBIOS name, which isn't as good, but still ok.
334
375
                                      None)
335
376
            if (GetComputerName is not None
336
377
                and GetComputerName(buf, ctypes.byref(n))):
337
 
                return extract_buffer(buf)
338
 
    return get_environ_unicode('COMPUTERNAME')
 
378
                return buf.value
 
379
    # otherwise try env variables, which will be 'mbcs' encoded
 
380
    # on Windows (Python doesn't expose the native win32 unicode environment)
 
381
    # According to this:
 
382
    # http://msdn.microsoft.com/en-us/library/aa246807.aspx
 
383
    # environment variables should always be encoded in 'mbcs'.
 
384
    try:
 
385
        return os.environ['COMPUTERNAME'].decode("mbcs")
 
386
    except KeyError:
 
387
        return None
 
388
 
 
389
 
 
390
def _ensure_unicode(s):
 
391
    from bzrlib import osutils
 
392
    if s and type(s) != unicode:
 
393
        from bzrlib import osutils
 
394
        s = s.decode(osutils.get_user_encoding())
 
395
    return s
 
396
 
 
397
 
 
398
def get_appdata_location_unicode():
 
399
    return _ensure_unicode(get_appdata_location())
 
400
 
 
401
def get_home_location_unicode():
 
402
    return _ensure_unicode(get_home_location())
 
403
 
 
404
def get_user_name_unicode():
 
405
    return _ensure_unicode(get_user_name())
 
406
 
 
407
def get_host_name_unicode():
 
408
    return _ensure_unicode(get_host_name())
339
409
 
340
410
 
341
411
def _ensure_with_dir(path):
342
 
    if (not os.path.split(path)[0] or path.startswith(u'*')
343
 
        or path.startswith(u'?')):
 
412
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
344
413
        return u'./' + path, True
345
414
    else:
346
415
        return path, False
352
421
        return path
353
422
 
354
423
 
355
 
def glob_one(possible_glob):
356
 
    """Same as glob.glob().
357
 
 
358
 
    work around bugs in glob.glob()
359
 
    - Python bug #1001604 ("glob doesn't return unicode with ...")
360
 
    - failing expansion for */* with non-iso-8859-* chars
361
 
    """
362
 
    corrected_glob, corrected = _ensure_with_dir(possible_glob)
363
 
    glob_files = glob.glob(corrected_glob)
364
 
 
365
 
    if not glob_files:
366
 
        # special case to let the normal code path handle
367
 
        # files that do not exist, etc.
368
 
        glob_files = [possible_glob]
369
 
    elif corrected:
370
 
        glob_files = [_undo_ensure_with_dir(elem, corrected)
371
 
                      for elem in glob_files]
372
 
    return [elem.replace(u'\\', u'/') for elem in glob_files]
373
 
 
374
424
 
375
425
def glob_expand(file_list):
376
426
    """Replacement for glob expansion by the shell.
381
431
    :param file_list: A list of filenames which may include shell globs.
382
432
    :return: An expanded list of filenames.
383
433
 
384
 
    Introduced in breezy 0.18.
 
434
    Introduced in bzrlib 0.18.
385
435
    """
386
436
    if not file_list:
387
437
        return []
 
438
    import glob
388
439
    expanded_file_list = []
389
440
    for possible_glob in file_list:
390
 
        expanded_file_list.extend(glob_one(possible_glob))
391
 
    return expanded_file_list
 
441
        # work around bugs in glob.glob()
 
442
        # - Python bug #1001604 ("glob doesn't return unicode with ...")
 
443
        # - failing expansion for */* with non-iso-8859-* chars
 
444
        possible_glob, corrected = _ensure_with_dir(possible_glob)
 
445
        glob_files = glob.glob(possible_glob)
 
446
 
 
447
        if glob_files == []:
 
448
            # special case to let the normal code path handle
 
449
            # files that do not exists
 
450
            expanded_file_list.append(
 
451
                _undo_ensure_with_dir(possible_glob, corrected))
 
452
        else:
 
453
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
 
454
            expanded_file_list += glob_files
 
455
 
 
456
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list]
392
457
 
393
458
 
394
459
def get_app_path(appname):
395
 
    r"""Look up in Windows registry for full path to application executable.
 
460
    """Look up in Windows registry for full path to application executable.
396
461
    Typically, applications create subkey with their basename
397
462
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
398
463
 
435
500
def set_file_attr_hidden(path):
436
501
    """Set file attributes to hidden if possible"""
437
502
    if has_win32file:
438
 
        SetFileAttributes = win32file.SetFileAttributesW
 
503
        if winver != 'Windows 98':
 
504
            SetFileAttributes = win32file.SetFileAttributesW
 
505
        else:
 
506
            SetFileAttributes = win32file.SetFileAttributes
439
507
        try:
440
508
            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
441
 
        except pywintypes.error as e:
442
 
            from . import trace
 
509
        except pywintypes.error, e:
 
510
            from bzrlib import trace
443
511
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
444
512
 
445
513
 
446
 
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
447
 
    """Convert a Unicode command line into a list of argv arguments.
448
 
 
449
 
    It performs wildcard expansion to make wildcards act closer to how they
450
 
    work in posix shells, versus how they work by default on Windows. Quoted
451
 
    arguments are left untouched.
452
 
 
453
 
    :param command_line: The unicode string to split into an arg list.
454
 
    :param single_quotes_allowed: Whether single quotes are accepted as quoting
455
 
                                  characters like double quotes. False by
456
 
                                  default.
457
 
    :return: A list of unicode strings.
458
 
    """
459
 
    # First, split the command line
460
 
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
461
 
    
462
 
    # Bug #587868 Now make sure that the length of s agrees with sys.argv 
463
 
    # we do this by simply counting the number of arguments in each. The counts should 
464
 
    # agree no matter what encoding sys.argv is in (AFAIK) 
465
 
    # len(arguments) < len(sys.argv) should be an impossibility since python gets 
466
 
    # args from the very same PEB as does GetCommandLineW
467
 
    arguments = list(s)
468
 
    
469
 
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
470
 
    if len(arguments) < len(argv):
471
 
        raise AssertionError("Split command line can't be shorter than argv")
472
 
    arguments = arguments[len(arguments) - len(argv):]
473
 
    
474
 
    # Carry on to process globs (metachars) in the command line
475
 
    # expand globs if necessary
476
 
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
477
 
    #       '**/' style globs
478
 
    args = []
479
 
    for is_quoted, arg in arguments:
480
 
        if is_quoted or not glob.has_magic(arg):
481
 
            args.append(arg)
482
 
        else:
483
 
            args.extend(glob_one(arg))
484
 
    return args
485
 
 
486
 
 
487
 
if has_ctypes:
 
514
if has_ctypes and winver != 'Windows 98':
488
515
    def get_unicode_argv():
489
 
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
490
 
        GetCommandLineW = prototype(("GetCommandLineW",
491
 
                                     ctypes.windll.kernel32))
492
 
        command_line = GetCommandLineW()
493
 
        if command_line is None:
494
 
            raise ctypes.WinError()
 
516
        LPCWSTR = ctypes.c_wchar_p
 
517
        INT = ctypes.c_int
 
518
        POINTER = ctypes.POINTER
 
519
        prototype = ctypes.WINFUNCTYPE(LPCWSTR)
 
520
        GetCommandLine = prototype(("GetCommandLineW",
 
521
                                    ctypes.windll.kernel32))
 
522
        prototype = ctypes.WINFUNCTYPE(POINTER(LPCWSTR), LPCWSTR, POINTER(INT))
 
523
        CommandLineToArgv = prototype(("CommandLineToArgvW",
 
524
                                       ctypes.windll.shell32))
 
525
        c = INT(0)
 
526
        pargv = CommandLineToArgv(GetCommandLine(), ctypes.byref(c))
495
527
        # Skip the first argument, since we only care about parameters
496
 
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
 
528
        argv = [pargv[i] for i in range(1, c.value)]
 
529
        if getattr(sys, 'frozen', None) is None:
 
530
            # Invoked via 'python.exe' which takes the form:
 
531
            #   python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
 
532
            # we need to get only BZR_OPTIONS part,
 
533
            # so let's using sys.argv[1:] as reference to get the tail
 
534
            # of unicode argv
 
535
            tail_len = len(sys.argv[1:])
 
536
            ix = len(argv) - tail_len
 
537
            argv = argv[ix:]
497
538
        return argv
498
 
 
499
 
 
500
 
    def get_environ_unicode(key, default=None):
501
 
        """Get `key` from environment as unicode or `default` if unset
502
 
 
503
 
        The environment is natively unicode on modern windows versions but
504
 
        Python 2 only accesses it through the legacy bytestring api.
505
 
 
506
 
        Environmental variable names are case insenstive on Windows.
507
 
 
508
 
        A large enough buffer will be allocated to retrieve the value, though
509
 
        it may take two calls to the underlying library function.
510
 
 
511
 
        This needs ctypes because pywin32 does not expose the wide version.
512
 
        """
513
 
        cfunc = getattr(get_environ_unicode, "_c_function", None)
514
 
        if cfunc is None:
515
 
            from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR
516
 
            cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
517
 
                ("GetEnvironmentVariableW", ctypes.windll.kernel32))
518
 
            get_environ_unicode._c_function = cfunc
519
 
        buffer_size = 256 # heuristic, 256 characters often enough
520
 
        while True:
521
 
            buffer = ctypes.create_unicode_buffer(buffer_size)
522
 
            length = cfunc(key, buffer, buffer_size)
523
 
            if not length:
524
 
                code = ctypes.GetLastError()
525
 
                if code == 203: # ERROR_ENVVAR_NOT_FOUND
526
 
                    return default
527
 
                raise ctypes.WinError(code)
528
 
            if buffer_size > length:
529
 
                return buffer[:length]
530
 
            buffer_size = length
531
 
 
532
 
 
533
 
if has_win32api:
534
 
    def _pywin32_is_local_pid_dead(pid):
535
 
        """True if pid doesn't correspond to live process on this machine"""
536
 
        try:
537
 
            handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
538
 
        except pywintypes.error as e:
539
 
            if e[0] == 5: # ERROR_ACCESS_DENIED
540
 
                # Probably something alive we're not allowed to kill
541
 
                return False
542
 
            elif e[0] == 87: # ERROR_INVALID_PARAMETER
543
 
                return True
544
 
            raise
545
 
        handle.close()
546
 
        return False
547
 
    is_local_pid_dead = _pywin32_is_local_pid_dead
548
 
elif has_ctypes and sys.platform == 'win32':
549
 
    from ctypes.wintypes import BOOL, DWORD, HANDLE
550
 
    _kernel32 = ctypes.windll.kernel32
551
 
    _CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
552
 
        ("CloseHandle", _kernel32))
553
 
    _OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
554
 
        ("OpenProcess", _kernel32))
555
 
    def _ctypes_is_local_pid_dead(pid):
556
 
        """True if pid doesn't correspond to live process on this machine"""
557
 
        handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
558
 
        if not handle:
559
 
            errorcode = ctypes.GetLastError()
560
 
            if errorcode == 5: # ERROR_ACCESS_DENIED
561
 
                # Probably something alive we're not allowed to kill
562
 
                return False
563
 
            elif errorcode == 87: # ERROR_INVALID_PARAMETER
564
 
                return True
565
 
            raise ctypes.WinError(errorcode)
566
 
        _CloseHandle(handle)
567
 
        return False
568
 
    is_local_pid_dead = _ctypes_is_local_pid_dead
569
 
 
570
 
 
571
 
def _is_pywintypes_error(evalue):
572
 
    """True if exception instance is an error from pywin32"""
573
 
    if has_pywintypes and isinstance(evalue, pywintypes.error):
574
 
        return True
575
 
    return False
 
539
else:
 
540
    get_unicode_argv = None