/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: Vincent Ladeuil
  • Date: 2007-11-24 14:20:59 UTC
  • mto: (3928.1.1 bzr.integration)
  • mto: This revision was merged to the branch mainline in revision 3929.
  • Revision ID: v.ladeuil+lp@free.fr-20071124142059-2114qtsgfdv8g9p1
Ssl files needed for the test https server.

* bzrlib/tests/ssl_certs/create_ssls.py: 
Script to create the ssl keys and certificates.

* bzrlib/tests/ssl_certs/server.crt: 
Server certificate signed by the certificate authority.

* bzrlib/tests/ssl_certs/server.csr: 
Server certificate signing request.

* bzrlib/tests/ssl_certs/server_without_pass.key: 
Server key usable without password.

* bzrlib/tests/ssl_certs/server_with_pass.key: 
Server key.

* bzrlib/tests/ssl_certs/ca.key: 
Certificate authority private key.

* bzrlib/tests/ssl_certs/ca.crt: 
Certificate authority certificate.

* bzrlib/tests/ssl_certs/__init__.py: 
Provide access to ssl files (keys and certificates). 

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
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
 
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'
45
 
try:
46
 
    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
 
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'
61
67
 
62
 
# pulling in win32com.shell is a bit of overhead, and normally we don't need
63
 
# it as ctypes is preferred and common.  lazy_imports and "optional"
64
 
# modules don't work well, so we do our own lazy thing...
65
 
has_win32com_shell = None # Set to True or False once we know for sure...
66
68
 
67
69
# Special Win32 API constants
68
70
# Handles of std streams
72
74
 
73
75
# CSIDL constants (from MSDN 2003)
74
76
CSIDL_APPDATA = 0x001A      # Application Data folder
75
 
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
76
77
CSIDL_PERSONAL = 0x0005     # My Documents folder
77
78
 
78
79
# from winapi C headers
80
81
UNLEN = 256
81
82
MAX_COMPUTERNAME_LENGTH = 31
82
83
 
83
 
# Registry data type ids
84
 
REG_SZ = 1
85
 
REG_EXPAND_SZ = 2
86
 
 
87
 
 
88
 
def debug_memory_win32api(message='', short=True):
89
 
    """Use trace.note() to dump the running memory info."""
90
 
    from breezy import trace
91
 
    if has_ctypes:
92
 
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
93
 
            """Used by GetProcessMemoryInfo"""
94
 
            _fields_ = [('cb', ctypes.c_ulong),
95
 
                        ('PageFaultCount', ctypes.c_ulong),
96
 
                        ('PeakWorkingSetSize', ctypes.c_size_t),
97
 
                        ('WorkingSetSize', ctypes.c_size_t),
98
 
                        ('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
99
 
                        ('QuotaPagedPoolUsage', ctypes.c_size_t),
100
 
                        ('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
101
 
                        ('QuotaNonPagedPoolUsage', ctypes.c_size_t),
102
 
                        ('PagefileUsage', ctypes.c_size_t),
103
 
                        ('PeakPagefileUsage', ctypes.c_size_t),
104
 
                        ('PrivateUsage', ctypes.c_size_t),
105
 
                       ]
106
 
        cur_process = ctypes.windll.kernel32.GetCurrentProcess()
107
 
        mem_struct = PROCESS_MEMORY_COUNTERS_EX()
108
 
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
109
 
            ctypes.byref(mem_struct),
110
 
            ctypes.sizeof(mem_struct))
111
 
        if not ret:
112
 
            trace.note(gettext('Failed to GetProcessMemoryInfo()'))
113
 
            return
114
 
        info = {'PageFaultCount': mem_struct.PageFaultCount,
115
 
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
116
 
                'WorkingSetSize': mem_struct.WorkingSetSize,
117
 
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
118
 
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
119
 
                'QuotaPeakNonPagedPoolUsage':
120
 
                    mem_struct.QuotaPeakNonPagedPoolUsage,
121
 
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
122
 
                'PagefileUsage': mem_struct.PagefileUsage,
123
 
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
124
 
                'PrivateUsage': mem_struct.PrivateUsage,
125
 
               }
126
 
    elif has_win32api:
127
 
        import win32process
128
 
        # win32process does not return PrivateUsage, because it doesn't use
129
 
        # PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
130
 
        proc = win32process.GetCurrentProcess()
131
 
        info = win32process.GetProcessMemoryInfo(proc)
132
 
    else:
133
 
        trace.note(gettext('Cannot debug memory on win32 without ctypes'
134
 
                   ' or win32process'))
135
 
        return
136
 
    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(
140
 
                   info['WorkingSetSize'] / 1024,
141
 
                   info['PeakWorkingSetSize'] / 1024,
142
 
                   message))
143
 
        return
144
 
    if message:
145
 
        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))
153
 
 
154
84
 
155
85
def get_console_size(defaultx=80, defaulty=25):
156
86
    """Return size of current console.
164
94
        return (defaultx, defaulty)
165
95
 
166
96
    # To avoid problem with redirecting output via pipe
167
 
    # we need to use stderr instead of stdout
 
97
    # need to use stderr instead of stdout
168
98
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
169
99
    csbi = ctypes.create_string_buffer(22)
170
100
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
171
101
 
172
102
    if res:
173
103
        (bufx, bufy, curx, cury, wattr,
174
 
        left, top, right, bottom, maxx, maxy) = struct.unpack(
175
 
            "hhhhHhhhhhh", csbi.raw)
 
104
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
176
105
        sizex = right - left + 1
177
106
        sizey = bottom - top + 1
178
107
        return (sizex, sizey)
180
109
        return (defaultx, defaulty)
181
110
 
182
111
 
183
 
def _get_sh_special_folder_path(csidl):
184
 
    """Call SHGetSpecialFolderPathW if available, or return None.
185
 
 
186
 
    Result is always unicode (or None).
187
 
    """
188
 
    if has_ctypes:
189
 
        try:
190
 
            SHGetSpecialFolderPath = \
191
 
                ctypes.windll.shell32.SHGetSpecialFolderPathW
192
 
        except AttributeError:
193
 
            pass
194
 
        else:
195
 
            buf = ctypes.create_unicode_buffer(MAX_PATH)
196
 
            if SHGetSpecialFolderPath(None, buf, csidl, 0):
197
 
                return buf.value
198
 
 
199
 
    global has_win32com_shell
200
 
    if has_win32com_shell is None:
201
 
        try:
202
 
            from win32com.shell import shell
203
 
            has_win32com_shell = True
204
 
        except ImportError:
205
 
            has_win32com_shell = False
206
 
    if has_win32com_shell:
207
 
        # still need to bind the name locally, but this is fast.
208
 
        from win32com.shell import shell
209
 
        try:
210
 
            return shell.SHGetSpecialFolderPath(0, csidl, 0)
211
 
        except shell.error:
212
 
            # possibly E_NOTIMPL meaning we can't load the function pointer,
213
 
            # or E_FAIL meaning the function failed - regardless, just ignore it
214
 
            pass
215
 
    return None
216
 
 
217
 
 
218
112
def get_appdata_location():
219
113
    """Return Application Data location.
220
114
    Return None if we cannot obtain location.
221
115
 
222
 
    Windows defines two 'Application Data' folders per user - a 'roaming'
223
 
    one that moves with the user as they logon to different machines, and
224
 
    a 'local' one that stays local to the machine.  This returns the 'roaming'
225
 
    directory, and thus is suitable for storing user-preferences, etc.
 
116
    Returned value can be unicode or plain sring.
 
117
    To convert plain string to unicode use
 
118
    s.decode(bzrlib.user_encoding)
226
119
    """
227
 
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
 
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
 
130
    # from env variable
 
131
    appdata = os.environ.get('APPDATA')
228
132
    if appdata:
229
133
        return appdata
230
 
    # Use APPDATA if defined, will return None if not
231
 
    return get_environ_unicode('APPDATA')
232
 
 
233
 
 
234
 
def get_local_appdata_location():
235
 
    """Return Local Application Data location.
236
 
    Return the same as get_appdata_location() if we cannot obtain location.
237
 
 
238
 
    Windows defines two 'Application Data' folders per user - a 'roaming'
239
 
    one that moves with the user as they logon to different machines, and
240
 
    a 'local' one that stays local to the machine.  This returns the 'local'
241
 
    directory, and thus is suitable for caches, temp files and other things
242
 
    which don't need to move with the user.
243
 
    """
244
 
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
245
 
    if local:
246
 
        return local
247
 
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
248
 
    local = get_environ_unicode('LOCALAPPDATA')
249
 
    if local:
250
 
        return local
251
 
    return get_appdata_location()
 
134
    # if we fall to this point we on win98
 
135
    # at least try C:/WINDOWS/Application Data
 
136
    windir = os.environ.get('windir')
 
137
    if windir:
 
138
        appdata = os.path.join(windir, 'Application Data')
 
139
        if os.path.isdir(appdata):
 
140
            return appdata
 
141
    # did not find anything
 
142
    return None
252
143
 
253
144
 
254
145
def get_home_location():
256
147
    Assume on win32 it's the <My Documents> folder.
257
148
    If location cannot be obtained return system drive root,
258
149
    i.e. C:\
 
150
 
 
151
    Returned value can be unicode or plain sring.
 
152
    To convert plain string to unicode use
 
153
    s.decode(bzrlib.user_encoding)
259
154
    """
260
 
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
261
 
    if home:
262
 
        return home
263
 
    home = get_environ_unicode('HOME')
264
 
    if home is not None:
265
 
        return home
266
 
    homepath = get_environ_unicode('HOMEPATH')
267
 
    if homepath is not None:
268
 
        return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
 
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
 
165
    # try for HOME env variable
 
166
    home = os.path.expanduser('~')
 
167
    if home != '~':
 
168
        return home
269
169
    # at least return windows root directory
270
 
    windir = get_environ_unicode('WINDIR')
 
170
    windir = os.environ.get('windir')
271
171
    if windir:
272
172
        return os.path.splitdrive(windir)[0] + '/'
273
173
    # otherwise C:\ is good enough for 98% users
274
 
    return u'C:/'
 
174
    return 'C:/'
275
175
 
276
176
 
277
177
def get_user_name():
278
178
    """Return user name as login name.
279
179
    If name cannot be obtained return None.
 
180
 
 
181
    Returned value can be unicode or plain sring.
 
182
    To convert plain string to unicode use
 
183
    s.decode(bzrlib.user_encoding)
280
184
    """
281
185
    if has_ctypes:
282
186
        try:
288
192
            buf = create_buffer(UNLEN+1)
289
193
            n = ctypes.c_int(UNLEN+1)
290
194
            if GetUserName(buf, ctypes.byref(n)):
291
 
                return extract_buffer(buf)
 
195
                return buf.value
292
196
    # otherwise try env variables
293
 
    return get_environ_unicode('USERNAME')
294
 
 
295
 
 
296
 
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
297
 
# computer or the cluster associated with the local computer."
298
 
_WIN32_ComputerNameDnsHostname = 1
 
197
    return os.environ.get('USERNAME', None)
 
198
 
299
199
 
300
200
def get_host_name():
301
201
    """Return host machine name.
302
202
    If name cannot be obtained return None.
303
203
 
304
 
    :return: A unicode string representing the host name.
 
204
    Returned value can be unicode or plain sring.
 
205
    To convert plain string to unicode use
 
206
    s.decode(bzrlib.user_encoding)
305
207
    """
306
 
    if has_win32api:
307
 
        try:
308
 
            return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
309
 
        except (NotImplementedError, win32api.error):
310
 
            # NotImplemented will happen on win9x...
311
 
            pass
312
208
    if has_ctypes:
313
209
        try:
314
210
            kernel32 = ctypes.windll.kernel32
 
211
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix)
315
212
        except AttributeError:
316
 
            pass # Missing the module we need
 
213
            pass
317
214
        else:
318
215
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
319
216
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
320
 
 
321
 
            # Try GetComputerNameEx which gives a proper Unicode hostname
322
 
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
323
 
                                        None)
324
 
            if (GetComputerNameEx is not None
325
 
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
326
 
                                      buf, ctypes.byref(n))):
327
 
                return extract_buffer(buf)
328
 
 
329
 
            # Try GetComputerName in case GetComputerNameEx wasn't found
330
 
            # It returns the NETBIOS name, which isn't as good, but still ok.
331
 
            # The first GetComputerNameEx might have changed 'n', so reset it
332
 
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
333
 
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
334
 
                                      None)
335
 
            if (GetComputerName is not None
336
 
                and GetComputerName(buf, ctypes.byref(n))):
337
 
                return extract_buffer(buf)
338
 
    return get_environ_unicode('COMPUTERNAME')
 
217
            if GetComputerName(buf, ctypes.byref(n)):
 
218
                return buf.value
 
219
    # otherwise try env variables
 
220
    return os.environ.get('COMPUTERNAME', None)
 
221
 
 
222
 
 
223
def _ensure_unicode(s):
 
224
    if s and type(s) != unicode:
 
225
        import bzrlib
 
226
        s = s.decode(bzrlib.user_encoding)
 
227
    return s
 
228
    
 
229
 
 
230
def get_appdata_location_unicode():
 
231
    return _ensure_unicode(get_appdata_location())
 
232
 
 
233
def get_home_location_unicode():
 
234
    return _ensure_unicode(get_home_location())
 
235
 
 
236
def get_user_name_unicode():
 
237
    return _ensure_unicode(get_user_name())
 
238
 
 
239
def get_host_name_unicode():
 
240
    return _ensure_unicode(get_host_name())
339
241
 
340
242
 
341
243
def _ensure_with_dir(path):
342
 
    if (not os.path.split(path)[0] or path.startswith(u'*')
343
 
        or path.startswith(u'?')):
 
244
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
344
245
        return u'./' + path, True
345
246
    else:
346
247
        return path, False
347
 
 
 
248
    
348
249
def _undo_ensure_with_dir(path, corrected):
349
250
    if corrected:
350
251
        return path[2:]
352
253
        return path
353
254
 
354
255
 
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
256
 
375
257
def glob_expand(file_list):
376
258
    """Replacement for glob expansion by the shell.
381
263
    :param file_list: A list of filenames which may include shell globs.
382
264
    :return: An expanded list of filenames.
383
265
 
384
 
    Introduced in breezy 0.18.
 
266
    Introduced in bzrlib 0.18.
385
267
    """
386
268
    if not file_list:
387
269
        return []
 
270
    import glob
388
271
    expanded_file_list = []
389
272
    for possible_glob in file_list:
390
 
        expanded_file_list.extend(glob_one(possible_glob))
391
 
    return expanded_file_list
 
273
        
 
274
        # work around bugs in glob.glob()
 
275
        # - Python bug #1001604 ("glob doesn't return unicode with ...")
 
276
        # - failing expansion for */* with non-iso-8859-* chars
 
277
        possible_glob, corrected = _ensure_with_dir(possible_glob)
 
278
        glob_files = glob.glob(possible_glob)
 
279
 
 
280
        if glob_files == []:
 
281
            # special case to let the normal code path handle
 
282
            # files that do not exists
 
283
            expanded_file_list.append(
 
284
                _undo_ensure_with_dir(possible_glob, corrected))
 
285
        else:
 
286
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
 
287
            expanded_file_list += glob_files
 
288
            
 
289
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list] 
392
290
 
393
291
 
394
292
def get_app_path(appname):
395
 
    r"""Look up in Windows registry for full path to application executable.
396
 
    Typically, applications create subkey with their basename
 
293
    """Look up in Windows registry for full path to application executable.
 
294
    Typicaly, applications create subkey with their basename
397
295
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
398
296
 
399
297
    :param  appname:    name of application (if no filename extension
402
300
                or appname itself if nothing found.
403
301
    """
404
302
    import _winreg
 
303
    try:
 
304
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
 
305
                               r'SOFTWARE\Microsoft\Windows'
 
306
                               r'\CurrentVersion\App Paths')
 
307
    except EnvironmentError:
 
308
        return appname
405
309
 
406
310
    basename = appname
407
311
    if not os.path.splitext(basename)[1]:
408
312
        basename = appname + '.exe'
409
 
 
410
 
    try:
411
 
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
412
 
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
413
 
            basename)
414
 
    except EnvironmentError:
415
 
        return appname
416
 
 
417
313
    try:
418
314
        try:
419
 
            path, type_id = _winreg.QueryValueEx(hkey, '')
 
315
            fullpath = _winreg.QueryValue(hkey, basename)
420
316
        except WindowsError:
421
 
            return appname
 
317
            fullpath = appname
422
318
    finally:
423
319
        _winreg.CloseKey(hkey)
424
320
 
425
 
    if type_id == REG_SZ:
426
 
        return path
427
 
    if type_id == REG_EXPAND_SZ and has_win32api:
428
 
        fullpath = win32api.ExpandEnvironmentStrings(path)
429
 
        if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
430
 
            fullpath = fullpath[1:-1]   # remove quotes around value
431
 
        return fullpath
432
 
    return appname
433
 
 
434
 
 
435
 
def set_file_attr_hidden(path):
436
 
    """Set file attributes to hidden if possible"""
437
 
    if has_win32file:
438
 
        SetFileAttributes = win32file.SetFileAttributesW
439
 
        try:
440
 
            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
441
 
        except pywintypes.error as e:
442
 
            from . import trace
443
 
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
444
 
 
445
 
 
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:
488
 
    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()
495
 
        # Skip the first argument, since we only care about parameters
496
 
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
497
 
        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
 
321
    return fullpath