/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: John Ferlito
  • Date: 2009-09-02 04:31:45 UTC
  • mto: (4665.7.1 serve-init)
  • mto: This revision was merged to the branch mainline in revision 4913.
  • Revision ID: johnf@inodes.org-20090902043145-gxdsfw03ilcwbyn5
Add a debian init script for bzr --serve

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
 
import glob
23
22
import os
24
23
import struct
25
24
import sys
26
25
 
27
 
from breezy import (
28
 
    cmdline,
29
 
    )
30
 
from breezy.i18n import gettext
31
 
 
 
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
 
 
53
 
 
54
# We can cope without it; use a separate variable to help pyflakes
 
55
try:
 
56
    import ctypes
 
57
    has_ctypes = True
 
58
except ImportError:
 
59
    has_ctypes = False
 
60
else:
 
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'
 
67
try:
 
68
    import win32file
 
69
    import pywintypes
 
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
 
78
 
 
79
# pulling in win32com.shell is a bit of overhead, and normally we don't need
 
80
# it as ctypes is preferred and common.  lazy_imports and "optional"
 
81
# modules don't work well, so we do our own lazy thing...
 
82
has_win32com_shell = None # Set to True or False once we know for sure...
32
83
 
33
84
# Special Win32 API constants
34
85
# Handles of std streams
38
89
 
39
90
# CSIDL constants (from MSDN 2003)
40
91
CSIDL_APPDATA = 0x001A      # Application Data folder
41
 
# <user name>\Local Settings\Application Data (non roaming)
42
 
CSIDL_LOCAL_APPDATA = 0x001c
 
92
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
43
93
CSIDL_PERSONAL = 0x0005     # My Documents folder
44
94
 
45
95
# from winapi C headers
54
104
 
55
105
def debug_memory_win32api(message='', short=True):
56
106
    """Use trace.note() to dump the running memory info."""
57
 
    import ctypes
58
 
    from breezy import trace
59
 
    class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
60
 
        """Used by GetProcessMemoryInfo"""
61
 
        _fields_ = [('cb', ctypes.c_ulong),
62
 
                    ('PageFaultCount', ctypes.c_ulong),
63
 
                    ('PeakWorkingSetSize', ctypes.c_size_t),
64
 
                    ('WorkingSetSize', ctypes.c_size_t),
65
 
                    ('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
66
 
                    ('QuotaPagedPoolUsage', ctypes.c_size_t),
67
 
                    ('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
68
 
                    ('QuotaNonPagedPoolUsage', ctypes.c_size_t),
69
 
                    ('PagefileUsage', ctypes.c_size_t),
70
 
                    ('PeakPagefileUsage', ctypes.c_size_t),
71
 
                    ('PrivateUsage', ctypes.c_size_t),
72
 
                    ]
73
 
    cur_process = ctypes.windll.kernel32.GetCurrentProcess()
74
 
    mem_struct = PROCESS_MEMORY_COUNTERS_EX()
75
 
    ret = ctypes.windll.psapi.GetProcessMemoryInfo(
76
 
        cur_process, ctypes.byref(mem_struct), ctypes.sizeof(mem_struct))
77
 
    if not ret:
78
 
        trace.note(gettext('Failed to GetProcessMemoryInfo()'))
 
107
    from bzrlib import trace
 
108
    if has_ctypes:
 
109
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
 
110
            """Used by GetProcessMemoryInfo"""
 
111
            _fields_ = [('cb', ctypes.c_ulong),
 
112
                        ('PageFaultCount', ctypes.c_ulong),
 
113
                        ('PeakWorkingSetSize', ctypes.c_size_t),
 
114
                        ('WorkingSetSize', ctypes.c_size_t),
 
115
                        ('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
 
116
                        ('QuotaPagedPoolUsage', ctypes.c_size_t),
 
117
                        ('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
 
118
                        ('QuotaNonPagedPoolUsage', ctypes.c_size_t),
 
119
                        ('PagefileUsage', ctypes.c_size_t),
 
120
                        ('PeakPagefileUsage', ctypes.c_size_t),
 
121
                        ('PrivateUsage', ctypes.c_size_t),
 
122
                       ]
 
123
        cur_process = ctypes.windll.kernel32.GetCurrentProcess()
 
124
        mem_struct = PROCESS_MEMORY_COUNTERS_EX()
 
125
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
 
126
            ctypes.byref(mem_struct),
 
127
            ctypes.sizeof(mem_struct))
 
128
        if not ret:
 
129
            trace.note('Failed to GetProcessMemoryInfo()')
 
130
            return
 
131
        info = {'PageFaultCount': mem_struct.PageFaultCount,
 
132
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
 
133
                'WorkingSetSize': mem_struct.WorkingSetSize,
 
134
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
 
135
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
 
136
                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
 
137
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
 
138
                'PagefileUsage': mem_struct.PagefileUsage,
 
139
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
 
140
                'PrivateUsage': mem_struct.PrivateUsage,
 
141
               }
 
142
    elif has_win32api:
 
143
        import win32process
 
144
        # win32process does not return PrivateUsage, because it doesn't use
 
145
        # PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
 
146
        proc = win32process.GetCurrentProcess()
 
147
        info = win32process.GetProcessMemoryInfo(proc)
 
148
    else:
 
149
        trace.note('Cannot debug memory on win32 without ctypes'
 
150
                   ' or win32process')
79
151
        return
80
 
    info = {'PageFaultCount': mem_struct.PageFaultCount,
81
 
            'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
82
 
            'WorkingSetSize': mem_struct.WorkingSetSize,
83
 
            'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
84
 
            'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
85
 
            'QuotaPeakNonPagedPoolUsage':
86
 
                mem_struct.QuotaPeakNonPagedPoolUsage,
87
 
            'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
88
 
            'PagefileUsage': mem_struct.PagefileUsage,
89
 
            'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
90
 
            'PrivateUsage': mem_struct.PrivateUsage,
91
 
            }
92
152
    if short:
93
 
        # using base-2 units (see HACKING.txt).
94
 
        trace.note(gettext('WorkingSize {0:>7}KiB'
95
 
                           '\tPeakWorking {1:>7}KiB\t{2}').format(
 
153
        trace.note('WorkingSize %7dKB'
 
154
                   '\tPeakWorking %7dKB\t%s',
96
155
                   info['WorkingSetSize'] / 1024,
97
156
                   info['PeakWorkingSetSize'] / 1024,
98
 
                   message))
 
157
                   message)
99
158
        return
100
159
    if message:
101
160
        trace.note('%s', message)
102
 
    trace.note(gettext('WorkingSize       %8d KiB'),
103
 
               info['WorkingSetSize'] / 1024)
104
 
    trace.note(gettext('PeakWorking       %8d KiB'),
105
 
               info['PeakWorkingSetSize'] / 1024)
106
 
    trace.note(gettext('PagefileUsage     %8d KiB'),
107
 
               info.get('PagefileUsage', 0) / 1024)
108
 
    trace.note(gettext('PeakPagefileUsage %8d KiB'),
109
 
               info.get('PeakPagefileUsage', 0) / 1024)
110
 
    trace.note(gettext('PrivateUsage      %8d KiB'),
111
 
               info.get('PrivateUsage', 0) / 1024)
112
 
    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))
113
167
 
114
168
 
115
169
def get_console_size(defaultx=80, defaulty=25):
119
173
    console window and return tuple (sizex, sizey) if success,
120
174
    or default size (defaultx, defaulty) otherwise.
121
175
    """
122
 
    import ctypes
 
176
    if not has_ctypes:
 
177
        # no ctypes is found
 
178
        return (defaultx, defaulty)
 
179
 
123
180
    # To avoid problem with redirecting output via pipe
124
 
    # we need to use stderr instead of stdout
 
181
    # need to use stderr instead of stdout
125
182
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
126
183
    csbi = ctypes.create_string_buffer(22)
127
184
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
128
185
 
129
186
    if res:
130
187
        (bufx, bufy, curx, cury, wattr,
131
 
         left, top, right, bottom, maxx, maxy) = struct.unpack(
132
 
            "hhhhHhhhhhh", csbi.raw)
 
188
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
133
189
        sizex = right - left + 1
134
190
        sizey = bottom - top + 1
135
191
        return (sizex, sizey)
142
198
 
143
199
    Result is always unicode (or None).
144
200
    """
145
 
    import ctypes
146
 
    try:
147
 
        SHGetSpecialFolderPath = \
148
 
            ctypes.windll.shell32.SHGetSpecialFolderPathW
149
 
    except AttributeError:
150
 
        pass
151
 
    else:
152
 
        buf = ctypes.create_unicode_buffer(MAX_PATH)
153
 
        if SHGetSpecialFolderPath(None, buf, csidl, 0):
154
 
            return buf.value
 
201
    if has_ctypes:
 
202
        try:
 
203
            SHGetSpecialFolderPath = \
 
204
                ctypes.windll.shell32.SHGetSpecialFolderPathW
 
205
        except AttributeError:
 
206
            pass
 
207
        else:
 
208
            buf = ctypes.create_unicode_buffer(MAX_PATH)
 
209
            if SHGetSpecialFolderPath(None,buf,csidl,0):
 
210
                return buf.value
 
211
 
 
212
    global has_win32com_shell
 
213
    if has_win32com_shell is None:
 
214
        try:
 
215
            from win32com.shell import shell
 
216
            has_win32com_shell = True
 
217
        except ImportError:
 
218
            has_win32com_shell = False
 
219
    if has_win32com_shell:
 
220
        # still need to bind the name locally, but this is fast.
 
221
        from win32com.shell import shell
 
222
        try:
 
223
            return shell.SHGetSpecialFolderPath(0, csidl, 0)
 
224
        except shell.error:
 
225
            # possibly E_NOTIMPL meaning we can't load the function pointer,
 
226
            # or E_FAIL meaning the function failed - regardless, just ignore it
 
227
            pass
 
228
    return None
155
229
 
156
230
 
157
231
def get_appdata_location():
162
236
    one that moves with the user as they logon to different machines, and
163
237
    a 'local' one that stays local to the machine.  This returns the 'roaming'
164
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')
165
244
    """
166
245
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
167
246
    if appdata:
168
247
        return appdata
169
 
    # Use APPDATA if defined, will return None if not
170
 
    return os.environ.get('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
171
261
 
172
262
 
173
263
def get_local_appdata_location():
179
269
    a 'local' one that stays local to the machine.  This returns the 'local'
180
270
    directory, and thus is suitable for caches, temp files and other things
181
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')
182
277
    """
183
278
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
184
279
    if local:
195
290
    Assume on win32 it's the <My Documents> folder.
196
291
    If location cannot be obtained return system drive root,
197
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())
198
297
    """
199
298
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
200
299
    if home:
201
300
        return home
202
 
    home = os.environ.get('HOME')
203
 
    if home is not None:
 
301
    # try for HOME env variable
 
302
    home = os.path.expanduser('~')
 
303
    if home != '~':
204
304
        return home
205
 
    homepath = os.environ.get('HOMEPATH')
206
 
    if homepath is not None:
207
 
        return os.path.join(os.environ.get('HOMEDIR', ''), home)
208
305
    # at least return windows root directory
209
 
    windir = os.environ.get('WINDIR')
 
306
    windir = os.environ.get('windir')
210
307
    if windir:
211
308
        return os.path.splitdrive(windir)[0] + '/'
212
309
    # otherwise C:\ is good enough for 98% users
213
 
    return u'C:/'
 
310
    return 'C:/'
214
311
 
215
312
 
216
313
def get_user_name():
217
314
    """Return user name as login name.
218
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())
219
320
    """
220
 
    try:
221
 
        advapi32 = ctypes.windll.advapi32
222
 
        GetUserName = getattr(advapi32, 'GetUserNameW')
223
 
    except AttributeError:
224
 
        pass
225
 
    else:
226
 
        buf = ctypes.create_unicode_buffer(UNLEN + 1)
227
 
        n = ctypes.c_int(UNLEN + 1)
228
 
        if GetUserName(buf, ctypes.byref(n)):
229
 
            return buf.value
 
321
    if has_ctypes:
 
322
        try:
 
323
            advapi32 = ctypes.windll.advapi32
 
324
            GetUserName = getattr(advapi32, 'GetUserName'+suffix)
 
325
        except AttributeError:
 
326
            pass
 
327
        else:
 
328
            buf = create_buffer(UNLEN+1)
 
329
            n = ctypes.c_int(UNLEN+1)
 
330
            if GetUserName(buf, ctypes.byref(n)):
 
331
                return buf.value
230
332
    # otherwise try env variables
231
 
    return os.environ.get('USERNAME')
 
333
    return os.environ.get('USERNAME', None)
232
334
 
233
335
 
234
336
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
235
337
# computer or the cluster associated with the local computer."
236
338
_WIN32_ComputerNameDnsHostname = 1
237
339
 
238
 
 
239
340
def get_host_name():
240
341
    """Return host machine name.
241
342
    If name cannot be obtained return None.
242
343
 
243
 
    :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.
244
346
    """
245
 
    import ctypes
246
 
    buf = ctypes.create_unicode_buffer(MAX_COMPUTERNAME_LENGTH + 1)
247
 
    n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH + 1)
248
 
 
249
 
    # Try GetComputerNameEx which gives a proper Unicode hostname
250
 
    GetComputerNameEx = getattr(
251
 
        ctypes.windll.kernel32, 'GetComputerNameExW', None)
252
 
    if (GetComputerNameEx is not None
253
 
        and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
254
 
                              buf, ctypes.byref(n))):
255
 
        return buf.value
256
 
    return os.environ.get('COMPUTERNAME')
 
347
    if has_win32api:
 
348
        try:
 
349
            return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
 
350
        except (NotImplementedError, win32api.error):
 
351
            # NotImplemented will happen on win9x...
 
352
            pass
 
353
    if has_ctypes:
 
354
        try:
 
355
            kernel32 = ctypes.windll.kernel32
 
356
        except AttributeError:
 
357
            pass # Missing the module we need
 
358
        else:
 
359
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
 
360
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
 
361
 
 
362
            # Try GetComputerNameEx which gives a proper Unicode hostname
 
363
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
 
364
                                        None)
 
365
            if (GetComputerNameEx is not None
 
366
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
 
367
                                      buf, ctypes.byref(n))):
 
368
                return buf.value
 
369
 
 
370
            # Try GetComputerName in case GetComputerNameEx wasn't found
 
371
            # It returns the NETBIOS name, which isn't as good, but still ok.
 
372
            # The first GetComputerNameEx might have changed 'n', so reset it
 
373
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
 
374
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
 
375
                                      None)
 
376
            if (GetComputerName is not None
 
377
                and GetComputerName(buf, ctypes.byref(n))):
 
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())
257
409
 
258
410
 
259
411
def _ensure_with_dir(path):
260
 
    if (not os.path.split(path)[0] or path.startswith(u'*')
261
 
            or path.startswith(u'?')):
 
412
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
262
413
        return u'./' + path, True
263
414
    else:
264
415
        return path, False
265
416
 
266
 
 
267
417
def _undo_ensure_with_dir(path, corrected):
268
418
    if corrected:
269
419
        return path[2:]
271
421
        return path
272
422
 
273
423
 
274
 
def glob_one(possible_glob):
275
 
    """Same as glob.glob().
276
 
 
277
 
    work around bugs in glob.glob()
278
 
    - Python bug #1001604 ("glob doesn't return unicode with ...")
279
 
    - failing expansion for */* with non-iso-8859-* chars
280
 
    """
281
 
    corrected_glob, corrected = _ensure_with_dir(possible_glob)
282
 
    glob_files = glob.glob(corrected_glob)
283
 
 
284
 
    if not glob_files:
285
 
        # special case to let the normal code path handle
286
 
        # files that do not exist, etc.
287
 
        glob_files = [possible_glob]
288
 
    elif corrected:
289
 
        glob_files = [_undo_ensure_with_dir(elem, corrected)
290
 
                      for elem in glob_files]
291
 
    return [elem.replace(u'\\', u'/') for elem in glob_files]
292
 
 
293
424
 
294
425
def glob_expand(file_list):
295
426
    """Replacement for glob expansion by the shell.
300
431
    :param file_list: A list of filenames which may include shell globs.
301
432
    :return: An expanded list of filenames.
302
433
 
303
 
    Introduced in breezy 0.18.
 
434
    Introduced in bzrlib 0.18.
304
435
    """
305
436
    if not file_list:
306
437
        return []
 
438
    import glob
307
439
    expanded_file_list = []
308
440
    for possible_glob in file_list:
309
 
        expanded_file_list.extend(glob_one(possible_glob))
310
 
    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]
311
457
 
312
458
 
313
459
def get_app_path(appname):
314
 
    r"""Look up in Windows registry for full path to application executable.
 
460
    """Look up in Windows registry for full path to application executable.
315
461
    Typically, applications create subkey with their basename
316
462
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
317
463
 
328
474
 
329
475
    try:
330
476
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
331
 
                               'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
332
 
                               basename)
 
477
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
 
478
            basename)
333
479
    except EnvironmentError:
334
480
        return appname
335
481
 
343
489
 
344
490
    if type_id == REG_SZ:
345
491
        return path
 
492
    if type_id == REG_EXPAND_SZ and has_win32api:
 
493
        fullpath = win32api.ExpandEnvironmentStrings(path)
 
494
        if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
 
495
            fullpath = fullpath[1:-1]   # remove quotes around value
 
496
        return fullpath
346
497
    return appname
347
498
 
348
499
 
349
500
def set_file_attr_hidden(path):
350
501
    """Set file attributes to hidden if possible"""
351
 
    from ctypes.wintypes import BOOL, DWORD, LPWSTR
352
 
    import ctypes
353
 
    # <https://docs.microsoft.com/windows/desktop/api/fileapi/nf-fileapi-setfileattributesw>
354
 
    SetFileAttributes = ctypes.windll.kernel32.SetFileAttributesW
355
 
    SetFileAttributes.argtypes = LPWSTR, DWORD
356
 
    SetFileAttributes.restype = BOOL
357
 
    FILE_ATTRIBUTE_HIDDEN = 2
358
 
    if not SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN):
359
 
        e = ctypes.WinError()
360
 
        from . import trace
361
 
        trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
362
 
 
363
 
 
364
 
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
365
 
    """Convert a Unicode command line into a list of argv arguments.
366
 
 
367
 
    It performs wildcard expansion to make wildcards act closer to how they
368
 
    work in posix shells, versus how they work by default on Windows. Quoted
369
 
    arguments are left untouched.
370
 
 
371
 
    :param command_line: The unicode string to split into an arg list.
372
 
    :param single_quotes_allowed: Whether single quotes are accepted as quoting
373
 
                                  characters like double quotes. False by
374
 
                                  default.
375
 
    :return: A list of unicode strings.
376
 
    """
377
 
    # First, split the command line
378
 
    s = cmdline.Splitter(
379
 
        command_line, single_quotes_allowed=single_quotes_allowed)
380
 
 
381
 
    # Bug #587868 Now make sure that the length of s agrees with sys.argv
382
 
    # we do this by simply counting the number of arguments in each. The counts should
383
 
    # agree no matter what encoding sys.argv is in (AFAIK)
384
 
    # len(arguments) < len(sys.argv) should be an impossibility since python gets
385
 
    # args from the very same PEB as does GetCommandLineW
386
 
    arguments = list(s)
387
 
 
388
 
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
389
 
    if len(arguments) < len(argv):
390
 
        raise AssertionError("Split command line can't be shorter than argv")
391
 
    arguments = arguments[len(arguments) - len(argv):]
392
 
 
393
 
    # Carry on to process globs (metachars) in the command line
394
 
    # expand globs if necessary
395
 
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
396
 
    #       '**/' style globs
397
 
    args = []
398
 
    for is_quoted, arg in arguments:
399
 
        if is_quoted or not glob.has_magic(arg):
400
 
            args.append(arg)
 
502
    if has_win32file:
 
503
        if winver != 'Windows 98':
 
504
            SetFileAttributes = win32file.SetFileAttributesW
401
505
        else:
402
 
            args.extend(glob_one(arg))
403
 
    return args
404
 
 
405
 
 
406
 
def _ctypes_is_local_pid_dead(pid):
407
 
    import ctypes
408
 
    kernel32 = ctypes.wintypes.windll.kernel32
409
 
    """True if pid doesn't correspond to live process on this machine"""
410
 
    handle = kernel32.OpenProcess(1, False, pid)
411
 
    if not handle:
412
 
        errorcode = ctypes.GetLastError()
413
 
        if errorcode == 5:  # ERROR_ACCESS_DENIED
414
 
            # Probably something alive we're not allowed to kill
415
 
            return False
416
 
        elif errorcode == 87:  # ERROR_INVALID_PARAMETER
417
 
            return True
418
 
        raise ctypes.WinError(errorcode)
419
 
    Kernel32.CloseHandle(handle)
420
 
    return False
421
 
 
422
 
is_local_pid_dead = _ctypes_is_local_pid_dead
 
506
            SetFileAttributes = win32file.SetFileAttributes
 
507
        try:
 
508
            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
 
509
        except pywintypes.error, e:
 
510
            from bzrlib import trace
 
511
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
 
512
 
 
513
 
 
514
if has_ctypes and winver != 'Windows 98':
 
515
    def get_unicode_argv():
 
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))
 
527
        # Skip the first argument, since we only care about parameters
 
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:]
 
538
        return argv
 
539
else:
 
540
    get_unicode_argv = None