← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Martin Packman
  • Date: 2011-12-23 19:38:22 UTC
  • mto: This revision was merged to the branch mainline in revision 6405.
  • Revision ID: martin.packman@canonical.com-20111223193822-hesheea4o8aqwexv
Accept and document passing the medium rather than transport for smart connections

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/win32utils.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Win32-specific helper functions
18
18
 
19
19
Only one dependency: ctypes should be installed.
20
20
"""
21
21
 
 
22
import glob
22
23
import os
23
24
import struct
24
25
import sys
25
26
 
 
27
from bzrlib import cmdline
 
28
from bzrlib.i18n import gettext
26
29
 
27
30
# Windows version
28
31
if sys.platform == 'win32':
64
67
    else:
65
68
        create_buffer = ctypes.create_unicode_buffer
66
69
        suffix = 'W'
 
70
try:
 
71
    import pywintypes
 
72
    has_pywintypes = True
 
73
except ImportError:
 
74
    has_pywintypes = has_win32file = has_win32api = False
 
75
else:
 
76
    try:
 
77
        import win32file
 
78
        has_win32file = True
 
79
    except ImportError:
 
80
        has_win32file = False
 
81
    try:
 
82
        import win32api
 
83
        has_win32api = True
 
84
    except ImportError:
 
85
        has_win32api = False
67
86
 
 
87
# pulling in win32com.shell is a bit of overhead, and normally we don't need
 
88
# it as ctypes is preferred and common.  lazy_imports and "optional"
 
89
# modules don't work well, so we do our own lazy thing...
 
90
has_win32com_shell = None # Set to True or False once we know for sure...
68
91
 
69
92
# Special Win32 API constants
70
93
# Handles of std streams
74
97
 
75
98
# CSIDL constants (from MSDN 2003)
76
99
CSIDL_APPDATA = 0x001A      # Application Data folder
 
100
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
77
101
CSIDL_PERSONAL = 0x0005     # My Documents folder
78
102
 
79
103
# from winapi C headers
81
105
UNLEN = 256
82
106
MAX_COMPUTERNAME_LENGTH = 31
83
107
 
 
108
# Registry data type ids
 
109
REG_SZ = 1
 
110
REG_EXPAND_SZ = 2
 
111
 
 
112
 
 
113
def debug_memory_win32api(message='', short=True):
 
114
    """Use trace.note() to dump the running memory info."""
 
115
    from bzrlib import trace
 
116
    if has_ctypes:
 
117
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
 
118
            """Used by GetProcessMemoryInfo"""
 
119
            _fields_ = [('cb', ctypes.c_ulong),
 
120
                        ('PageFaultCount', ctypes.c_ulong),
 
121
                        ('PeakWorkingSetSize', ctypes.c_size_t),
 
122
                        ('WorkingSetSize', ctypes.c_size_t),
 
123
                        ('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
 
124
                        ('QuotaPagedPoolUsage', ctypes.c_size_t),
 
125
                        ('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
 
126
                        ('QuotaNonPagedPoolUsage', ctypes.c_size_t),
 
127
                        ('PagefileUsage', ctypes.c_size_t),
 
128
                        ('PeakPagefileUsage', ctypes.c_size_t),
 
129
                        ('PrivateUsage', ctypes.c_size_t),
 
130
                       ]
 
131
        cur_process = ctypes.windll.kernel32.GetCurrentProcess()
 
132
        mem_struct = PROCESS_MEMORY_COUNTERS_EX()
 
133
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
 
134
            ctypes.byref(mem_struct),
 
135
            ctypes.sizeof(mem_struct))
 
136
        if not ret:
 
137
            trace.note(gettext('Failed to GetProcessMemoryInfo()'))
 
138
            return
 
139
        info = {'PageFaultCount': mem_struct.PageFaultCount,
 
140
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
 
141
                'WorkingSetSize': mem_struct.WorkingSetSize,
 
142
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
 
143
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
 
144
                'QuotaPeakNonPagedPoolUsage':
 
145
                    mem_struct.QuotaPeakNonPagedPoolUsage,
 
146
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
 
147
                'PagefileUsage': mem_struct.PagefileUsage,
 
148
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
 
149
                'PrivateUsage': mem_struct.PrivateUsage,
 
150
               }
 
151
    elif has_win32api:
 
152
        import win32process
 
153
        # win32process does not return PrivateUsage, because it doesn't use
 
154
        # PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
 
155
        proc = win32process.GetCurrentProcess()
 
156
        info = win32process.GetProcessMemoryInfo(proc)
 
157
    else:
 
158
        trace.note(gettext('Cannot debug memory on win32 without ctypes'
 
159
                   ' or win32process'))
 
160
        return
 
161
    if short:
 
162
        # using base-2 units (see HACKING.txt).
 
163
        trace.note(gettext('WorkingSize {0:>7}KiB'
 
164
                   '\tPeakWorking {1:>7}KiB\t{2}').format(
 
165
                   info['WorkingSetSize'] / 1024,
 
166
                   info['PeakWorkingSetSize'] / 1024,
 
167
                   message))
 
168
        return
 
169
    if message:
 
170
        trace.note('%s', message)
 
171
    trace.note(gettext('WorkingSize       %8d KiB'), info['WorkingSetSize'] / 1024)
 
172
    trace.note(gettext('PeakWorking       %8d KiB'), info['PeakWorkingSetSize'] / 1024)
 
173
    trace.note(gettext('PagefileUsage     %8d KiB'), info.get('PagefileUsage', 0) / 1024)
 
174
    trace.note(gettext('PeakPagefileUsage %8d KiB'),
 
175
               info.get('PeakPagefileUsage', 0) / 1024)
 
176
    trace.note(gettext('PrivateUsage      %8d KiB'), info.get('PrivateUsage', 0) / 1024)
 
177
    trace.note(gettext('PageFaultCount    %8d'), info.get('PageFaultCount', 0))
 
178
 
84
179
 
85
180
def get_console_size(defaultx=80, defaulty=25):
86
181
    """Return size of current console.
94
189
        return (defaultx, defaulty)
95
190
 
96
191
    # To avoid problem with redirecting output via pipe
97
 
    # need to use stderr instead of stdout
 
192
    # we need to use stderr instead of stdout
98
193
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
99
194
    csbi = ctypes.create_string_buffer(22)
100
195
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
101
196
 
102
197
    if res:
103
198
        (bufx, bufy, curx, cury, wattr,
104
 
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
 
199
        left, top, right, bottom, maxx, maxy) = struct.unpack(
 
200
            "hhhhHhhhhhh", csbi.raw)
105
201
        sizex = right - left + 1
106
202
        sizey = bottom - top + 1
107
203
        return (sizex, sizey)
109
205
        return (defaultx, defaulty)
110
206
 
111
207
 
 
208
def _get_sh_special_folder_path(csidl):
 
209
    """Call SHGetSpecialFolderPathW if available, or return None.
 
210
 
 
211
    Result is always unicode (or None).
 
212
    """
 
213
    if has_ctypes:
 
214
        try:
 
215
            SHGetSpecialFolderPath = \
 
216
                ctypes.windll.shell32.SHGetSpecialFolderPathW
 
217
        except AttributeError:
 
218
            pass
 
219
        else:
 
220
            buf = ctypes.create_unicode_buffer(MAX_PATH)
 
221
            if SHGetSpecialFolderPath(None,buf,csidl,0):
 
222
                return buf.value
 
223
 
 
224
    global has_win32com_shell
 
225
    if has_win32com_shell is None:
 
226
        try:
 
227
            from win32com.shell import shell
 
228
            has_win32com_shell = True
 
229
        except ImportError:
 
230
            has_win32com_shell = False
 
231
    if has_win32com_shell:
 
232
        # still need to bind the name locally, but this is fast.
 
233
        from win32com.shell import shell
 
234
        try:
 
235
            return shell.SHGetSpecialFolderPath(0, csidl, 0)
 
236
        except shell.error:
 
237
            # possibly E_NOTIMPL meaning we can't load the function pointer,
 
238
            # or E_FAIL meaning the function failed - regardless, just ignore it
 
239
            pass
 
240
    return None
 
241
 
 
242
 
112
243
def get_appdata_location():
113
244
    """Return Application Data location.
114
245
    Return None if we cannot obtain location.
115
246
 
116
 
    Returned value can be unicode or plain sring.
 
247
    Windows defines two 'Application Data' folders per user - a 'roaming'
 
248
    one that moves with the user as they logon to different machines, and
 
249
    a 'local' one that stays local to the machine.  This returns the 'roaming'
 
250
    directory, and thus is suitable for storing user-preferences, etc.
 
251
 
 
252
    Returned value can be unicode or plain string.
117
253
    To convert plain string to unicode use
118
 
    s.decode(bzrlib.user_encoding)
 
254
    s.decode(osutils.get_user_encoding())
 
255
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
119
256
    """
120
 
    if has_ctypes:
121
 
        try:
122
 
            SHGetSpecialFolderPath = \
123
 
                ctypes.windll.shell32.SHGetSpecialFolderPathW
124
 
        except AttributeError:
125
 
            pass
126
 
        else:
127
 
            buf = ctypes.create_unicode_buffer(MAX_PATH)
128
 
            if SHGetSpecialFolderPath(None,buf,CSIDL_APPDATA,0):
129
 
                return buf.value
 
257
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
 
258
    if appdata:
 
259
        return appdata
130
260
    # from env variable
131
261
    appdata = os.environ.get('APPDATA')
132
262
    if appdata:
142
272
    return None
143
273
 
144
274
 
 
275
def get_local_appdata_location():
 
276
    """Return Local Application Data location.
 
277
    Return the same as get_appdata_location() if we cannot obtain location.
 
278
 
 
279
    Windows defines two 'Application Data' folders per user - a 'roaming'
 
280
    one that moves with the user as they logon to different machines, and
 
281
    a 'local' one that stays local to the machine.  This returns the 'local'
 
282
    directory, and thus is suitable for caches, temp files and other things
 
283
    which don't need to move with the user.
 
284
 
 
285
    Returned value can be unicode or plain string.
 
286
    To convert plain string to unicode use
 
287
    s.decode(osutils.get_user_encoding())
 
288
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
 
289
    """
 
290
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
 
291
    if local:
 
292
        return local
 
293
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
 
294
    local = os.environ.get('LOCALAPPDATA')
 
295
    if local:
 
296
        return local
 
297
    return get_appdata_location()
 
298
 
 
299
 
145
300
def get_home_location():
146
301
    """Return user's home location.
147
302
    Assume on win32 it's the <My Documents> folder.
148
303
    If location cannot be obtained return system drive root,
149
304
    i.e. C:\
150
305
 
151
 
    Returned value can be unicode or plain sring.
 
306
    Returned value can be unicode or plain string.
152
307
    To convert plain string to unicode use
153
 
    s.decode(bzrlib.user_encoding)
 
308
    s.decode(osutils.get_user_encoding())
154
309
    """
155
 
    if has_ctypes:
156
 
        try:
157
 
            SHGetSpecialFolderPath = \
158
 
                ctypes.windll.shell32.SHGetSpecialFolderPathW
159
 
        except AttributeError:
160
 
            pass
161
 
        else:
162
 
            buf = ctypes.create_unicode_buffer(MAX_PATH)
163
 
            if SHGetSpecialFolderPath(None,buf,CSIDL_PERSONAL,0):
164
 
                return buf.value
 
310
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
 
311
    if home:
 
312
        return home
165
313
    # try for HOME env variable
166
314
    home = os.path.expanduser('~')
167
315
    if home != '~':
169
317
    # at least return windows root directory
170
318
    windir = os.environ.get('windir')
171
319
    if windir:
172
 
        return os.path.splitdrive(windir) + '/'
 
320
        return os.path.splitdrive(windir)[0] + '/'
173
321
    # otherwise C:\ is good enough for 98% users
174
322
    return 'C:/'
175
323
 
178
326
    """Return user name as login name.
179
327
    If name cannot be obtained return None.
180
328
 
181
 
    Returned value can be unicode or plain sring.
 
329
    Returned value can be unicode or plain string.
182
330
    To convert plain string to unicode use
183
 
    s.decode(bzrlib.user_encoding)
 
331
    s.decode(osutils.get_user_encoding())
184
332
    """
185
333
    if has_ctypes:
186
334
        try:
197
345
    return os.environ.get('USERNAME', None)
198
346
 
199
347
 
 
348
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
 
349
# computer or the cluster associated with the local computer."
 
350
_WIN32_ComputerNameDnsHostname = 1
 
351
 
200
352
def get_host_name():
201
353
    """Return host machine name.
202
354
    If name cannot be obtained return None.
203
355
 
204
 
    Returned value can be unicode or plain sring.
205
 
    To convert plain string to unicode use
206
 
    s.decode(bzrlib.user_encoding)
 
356
    :return: A unicode string representing the host name. On win98, this may be
 
357
        a plain string as win32 api doesn't support unicode.
207
358
    """
 
359
    if has_win32api:
 
360
        try:
 
361
            return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
 
362
        except (NotImplementedError, win32api.error):
 
363
            # NotImplemented will happen on win9x...
 
364
            pass
208
365
    if has_ctypes:
209
366
        try:
210
367
            kernel32 = ctypes.windll.kernel32
211
 
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix)
212
368
        except AttributeError:
213
 
            pass
 
369
            pass # Missing the module we need
214
370
        else:
215
371
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
216
372
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
217
 
            if GetComputerName(buf, ctypes.byref(n)):
218
 
                return buf.value
219
 
    # otherwise try env variables
220
 
    return os.environ.get('COMPUTERNAME', None)
 
373
 
 
374
            # Try GetComputerNameEx which gives a proper Unicode hostname
 
375
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
 
376
                                        None)
 
377
            if (GetComputerNameEx is not None
 
378
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
 
379
                                      buf, ctypes.byref(n))):
 
380
                return buf.value
 
381
 
 
382
            # Try GetComputerName in case GetComputerNameEx wasn't found
 
383
            # It returns the NETBIOS name, which isn't as good, but still ok.
 
384
            # The first GetComputerNameEx might have changed 'n', so reset it
 
385
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
 
386
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
 
387
                                      None)
 
388
            if (GetComputerName is not None
 
389
                and GetComputerName(buf, ctypes.byref(n))):
 
390
                return buf.value
 
391
    # otherwise try env variables, which will be 'mbcs' encoded
 
392
    # on Windows (Python doesn't expose the native win32 unicode environment)
 
393
    # According to this:
 
394
    # http://msdn.microsoft.com/en-us/library/aa246807.aspx
 
395
    # environment variables should always be encoded in 'mbcs'.
 
396
    try:
 
397
        return os.environ['COMPUTERNAME'].decode("mbcs")
 
398
    except KeyError:
 
399
        return None
221
400
 
222
401
 
223
402
def _ensure_unicode(s):
224
403
    if s and type(s) != unicode:
225
 
        import bzrlib
226
 
        s = s.decode(bzrlib.user_encoding)
 
404
        from bzrlib import osutils
 
405
        s = s.decode(osutils.get_user_encoding())
227
406
    return s
228
 
    
 
407
 
229
408
 
230
409
def get_appdata_location_unicode():
231
410
    return _ensure_unicode(get_appdata_location())
238
417
 
239
418
def get_host_name_unicode():
240
419
    return _ensure_unicode(get_host_name())
 
420
 
 
421
 
 
422
def _ensure_with_dir(path):
 
423
    if (not os.path.split(path)[0] or path.startswith(u'*')
 
424
        or path.startswith(u'?')):
 
425
        return u'./' + path, True
 
426
    else:
 
427
        return path, False
 
428
 
 
429
def _undo_ensure_with_dir(path, corrected):
 
430
    if corrected:
 
431
        return path[2:]
 
432
    else:
 
433
        return path
 
434
 
 
435
 
 
436
 
 
437
def glob_one(possible_glob):
 
438
    """Same as glob.glob().
 
439
 
 
440
    work around bugs in glob.glob()
 
441
    - Python bug #1001604 ("glob doesn't return unicode with ...")
 
442
    - failing expansion for */* with non-iso-8859-* chars
 
443
    """
 
444
    corrected_glob, corrected = _ensure_with_dir(possible_glob)
 
445
    glob_files = glob.glob(corrected_glob)
 
446
 
 
447
    if not glob_files:
 
448
        # special case to let the normal code path handle
 
449
        # files that do not exist, etc.
 
450
        glob_files = [possible_glob]
 
451
    elif corrected:
 
452
        glob_files = [_undo_ensure_with_dir(elem, corrected)
 
453
                      for elem in glob_files]
 
454
    return [elem.replace(u'\\', u'/') for elem in glob_files]
 
455
 
 
456
 
 
457
def glob_expand(file_list):
 
458
    """Replacement for glob expansion by the shell.
 
459
 
 
460
    Win32's cmd.exe does not do glob expansion (eg ``*.py``), so we do our own
 
461
    here.
 
462
 
 
463
    :param file_list: A list of filenames which may include shell globs.
 
464
    :return: An expanded list of filenames.
 
465
 
 
466
    Introduced in bzrlib 0.18.
 
467
    """
 
468
    if not file_list:
 
469
        return []
 
470
    expanded_file_list = []
 
471
    for possible_glob in file_list:
 
472
        expanded_file_list.extend(glob_one(possible_glob))
 
473
    return expanded_file_list
 
474
 
 
475
 
 
476
def get_app_path(appname):
 
477
    r"""Look up in Windows registry for full path to application executable.
 
478
    Typically, applications create subkey with their basename
 
479
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
 
480
 
 
481
    :param  appname:    name of application (if no filename extension
 
482
                        is specified, .exe used)
 
483
    :return:    full path to aplication executable from registry,
 
484
                or appname itself if nothing found.
 
485
    """
 
486
    import _winreg
 
487
 
 
488
    basename = appname
 
489
    if not os.path.splitext(basename)[1]:
 
490
        basename = appname + '.exe'
 
491
 
 
492
    try:
 
493
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
 
494
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
 
495
            basename)
 
496
    except EnvironmentError:
 
497
        return appname
 
498
 
 
499
    try:
 
500
        try:
 
501
            path, type_id = _winreg.QueryValueEx(hkey, '')
 
502
        except WindowsError:
 
503
            return appname
 
504
    finally:
 
505
        _winreg.CloseKey(hkey)
 
506
 
 
507
    if type_id == REG_SZ:
 
508
        return path
 
509
    if type_id == REG_EXPAND_SZ and has_win32api:
 
510
        fullpath = win32api.ExpandEnvironmentStrings(path)
 
511
        if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
 
512
            fullpath = fullpath[1:-1]   # remove quotes around value
 
513
        return fullpath
 
514
    return appname
 
515
 
 
516
 
 
517
def set_file_attr_hidden(path):
 
518
    """Set file attributes to hidden if possible"""
 
519
    if has_win32file:
 
520
        if winver != 'Windows 98':
 
521
            SetFileAttributes = win32file.SetFileAttributesW
 
522
        else:
 
523
            SetFileAttributes = win32file.SetFileAttributes
 
524
        try:
 
525
            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
 
526
        except pywintypes.error, e:
 
527
            from bzrlib import trace
 
528
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
 
529
 
 
530
 
 
531
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
 
532
    """Convert a Unicode command line into a list of argv arguments.
 
533
 
 
534
    It performs wildcard expansion to make wildcards act closer to how they
 
535
    work in posix shells, versus how they work by default on Windows. Quoted
 
536
    arguments are left untouched.
 
537
 
 
538
    :param command_line: The unicode string to split into an arg list.
 
539
    :param single_quotes_allowed: Whether single quotes are accepted as quoting
 
540
                                  characters like double quotes. False by
 
541
                                  default.
 
542
    :return: A list of unicode strings.
 
543
    """
 
544
    # First, spit the command line
 
545
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
 
546
    
 
547
    # Bug #587868 Now make sure that the length of s agrees with sys.argv 
 
548
    # we do this by simply counting the number of arguments in each. The counts should 
 
549
    # agree no matter what encoding sys.argv is in (AFAIK) 
 
550
    # len(arguments) < len(sys.argv) should be an impossibility since python gets 
 
551
    # args from the very same PEB as does GetCommandLineW
 
552
    arguments = list(s)
 
553
    
 
554
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
 
555
    if len(arguments) < len(argv):
 
556
        raise AssertionError("Split command line can't be shorter than argv")
 
557
    arguments = arguments[len(arguments) - len(argv):]
 
558
    
 
559
    # Carry on to process globs (metachars) in the command line
 
560
    # expand globs if necessary
 
561
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
 
562
    #       '**/' style globs
 
563
    args = []
 
564
    for is_quoted, arg in arguments:
 
565
        if is_quoted or not glob.has_magic(arg):
 
566
            args.append(arg)
 
567
        else:
 
568
            args.extend(glob_one(arg))
 
569
    return args
 
570
 
 
571
 
 
572
if has_ctypes and winver == 'Windows NT':
 
573
    def get_unicode_argv():
 
574
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
 
575
        GetCommandLineW = prototype(("GetCommandLineW",
 
576
                                     ctypes.windll.kernel32))
 
577
        command_line = GetCommandLineW()
 
578
        if command_line is None:
 
579
            raise ctypes.WinError()
 
580
        # Skip the first argument, since we only care about parameters
 
581
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
 
582
        return argv
 
583
    
 
584
 
 
585
    def get_environ_unicode(key, default=None):
 
586
        """Get `key` from environment as unicode or `default` if unset
 
587
 
 
588
        A large enough buffer will be allocated to retrieve the value, though
 
589
        it may take two calls to the underlying library function.
 
590
 
 
591
        This needs ctypes because pywin32 does not expose the wide version.
 
592
        """
 
593
        cfunc = getattr(get_environ_unicode, "_c_function", None)
 
594
        if cfunc is None:
 
595
            from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR
 
596
            cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
 
597
                ("GetEnvironmentVariableW", ctypes.windll.kernel32))
 
598
            get_environ_unicode._c_function = cfunc
 
599
        buffer_size = 256 # heuristic, 256 characters often enough
 
600
        while True:
 
601
            buffer = ctypes.create_unicode_buffer(buffer_size)
 
602
            length = cfunc(key, buffer, buffer_size)
 
603
            if not length:
 
604
                code = ctypes.GetLastError()
 
605
                if code == 203: # ERROR_ENVVAR_NOT_FOUND
 
606
                    return default
 
607
                raise ctypes.WinError(code)
 
608
            if buffer_size > length:
 
609
                return buffer[:length]
 
610
            buffer_size = length
 
611
else:
 
612
    get_unicode_argv = get_environ_unicode = None
 
613
 
 
614
 
 
615
if has_win32api:
 
616
    def _pywin32_is_local_pid_dead(pid):
 
617
        """True if pid doesn't correspond to live process on this machine"""
 
618
        try:
 
619
            handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
 
620
        except pywintypes.error, e:
 
621
            if e[0] == 5: # ERROR_ACCESS_DENIED
 
622
                # Probably something alive we're not allowed to kill
 
623
                return False
 
624
            elif e[0] == 87: # ERROR_INVALID_PARAMETER
 
625
                return True
 
626
            raise
 
627
        handle.close()
 
628
        return False
 
629
    is_local_pid_dead = _pywin32_is_local_pid_dead
 
630
elif has_ctypes and sys.platform == 'win32':
 
631
    from ctypes.wintypes import BOOL, DWORD, HANDLE
 
632
    _kernel32 = ctypes.windll.kernel32
 
633
    _CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
 
634
        ("CloseHandle", _kernel32))
 
635
    _OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
 
636
        ("OpenProcess", _kernel32))
 
637
    def _ctypes_is_local_pid_dead(pid):
 
638
        """True if pid doesn't correspond to live process on this machine"""
 
639
        handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
 
640
        if not handle:
 
641
            errorcode = ctypes.GetLastError()
 
642
            if errorcode == 5: # ERROR_ACCESS_DENIED
 
643
                # Probably something alive we're not allowed to kill
 
644
                return False
 
645
            elif errorcode == 87: # ERROR_INVALID_PARAMETER
 
646
                return True
 
647
            raise ctypes.WinError(errorcode)
 
648
        _CloseHandle(handle)
 
649
        return False
 
650
    is_local_pid_dead = _ctypes_is_local_pid_dead
 
651
 
 
652
 
 
653
def _is_pywintypes_error(evalue):
 
654
    """True if exception instance is an error from pywin32"""
 
655
    if has_pywintypes and isinstance(evalue, pywintypes.error):
 
656
        return True
 
657
    return False