/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 breezy/urlutils.py

  • Committer: Jelmer Vernooij
  • Date: 2019-12-28 14:10:36 UTC
  • mto: This revision was merged to the branch mainline in revision 7431.
  • Revision ID: jelmer@jelmer.uk-20191228141036-hsqitjor9m5fsri1
Python3 compatibility.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/urlutils.py
16
16
 
17
17
"""A collection of function for handling URL operations."""
18
18
 
 
19
from __future__ import absolute_import
 
20
 
19
21
import os
20
22
import re
21
23
import sys
22
24
 
23
 
from bzrlib.lazy_import import lazy_import
24
 
lazy_import(globals(), """
25
 
from posixpath import split as _posix_split, normpath as _posix_normpath
26
 
import urllib
27
 
import urlparse
 
25
try:
 
26
    import urlparse
 
27
except ImportError:
 
28
    from urllib import parse as urlparse
28
29
 
29
 
from bzrlib import (
 
30
from . import (
30
31
    errors,
31
32
    osutils,
32
33
    )
 
34
 
 
35
from .lazy_import import lazy_import
 
36
lazy_import(globals(), """
 
37
from posixpath import split as _posix_split
33
38
""")
34
39
 
 
40
from .sixish import (
 
41
    int2byte,
 
42
    PY3,
 
43
    text_type,
 
44
    unichr,
 
45
    )
 
46
 
 
47
 
 
48
class InvalidURL(errors.PathError):
 
49
 
 
50
    _fmt = 'Invalid url supplied to transport: "%(path)s"%(extra)s'
 
51
 
 
52
 
 
53
class InvalidURLJoin(errors.PathError):
 
54
 
 
55
    _fmt = "Invalid URL join request: %(reason)s: %(base)r + %(join_args)r"
 
56
 
 
57
    def __init__(self, reason, base, join_args):
 
58
        self.reason = reason
 
59
        self.base = base
 
60
        self.join_args = join_args
 
61
        errors.PathError.__init__(self, base, reason)
 
62
 
 
63
 
 
64
class InvalidRebaseURLs(errors.PathError):
 
65
 
 
66
    _fmt = "URLs differ by more than path: %(from_)r and %(to)r"
 
67
 
 
68
    def __init__(self, from_, to):
 
69
        self.from_ = from_
 
70
        self.to = to
 
71
        errors.PathError.__init__(
 
72
            self, from_, 'URLs differ by more than path.')
 
73
 
35
74
 
36
75
def basename(url, exclude_trailing_slash=True):
37
76
    """Return the last component of a URL.
60
99
    return split(url, exclude_trailing_slash=exclude_trailing_slash)[0]
61
100
 
62
101
 
63
 
def escape(relpath):
 
102
if PY3:
 
103
    quote_from_bytes = urlparse.quote_from_bytes
 
104
    quote = urlparse.quote
 
105
    unquote_to_bytes = urlparse.unquote_to_bytes
 
106
else:
 
107
    # Private copies of quote and unquote, copied from Python's urllib module
 
108
    # because urllib unconditionally imports socket, which imports ssl.
 
109
 
 
110
    always_safe = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
111
                   'abcdefghijklmnopqrstuvwxyz'
 
112
                   '0123456789' '_.-')
 
113
    _safe_map = {}
 
114
    for i, c in zip(range(256), ''.join(map(chr, range(256)))):
 
115
        _safe_map[c] = c if (
 
116
            i < 128 and c in always_safe) else '%{0:02X}'.format(i)
 
117
    _safe_quoters = {}
 
118
 
 
119
    def quote_from_bytes(s, safe='/'):
 
120
        """quote('abc def') -> 'abc%20def'
 
121
 
 
122
        Each part of a URL, e.g. the path info, the query, etc., has a
 
123
        different set of reserved characters that must be quoted.
 
124
 
 
125
        RFC 2396 Uniform Resource Identifiers (URI): Generic Syntax lists
 
126
        the following reserved characters.
 
127
 
 
128
        reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
 
129
                      "$" | ","
 
130
 
 
131
        Each of these characters is reserved in some component of a URL,
 
132
        but not necessarily in all of them.
 
133
 
 
134
        By default, the quote function is intended for quoting the path
 
135
        section of a URL.  Thus, it will not encode '/'.  This character
 
136
        is reserved, but in typical usage the quote function is being
 
137
        called on a path where the existing slash characters are used as
 
138
        reserved characters.
 
139
        """
 
140
        # fastpath
 
141
        if not s:
 
142
            if s is None:
 
143
                raise TypeError('None object cannot be quoted')
 
144
            return s
 
145
        cachekey = (safe, always_safe)
 
146
        try:
 
147
            (quoter, safe) = _safe_quoters[cachekey]
 
148
        except KeyError:
 
149
            safe_map = _safe_map.copy()
 
150
            safe_map.update([(c, c) for c in safe])
 
151
            quoter = safe_map.__getitem__
 
152
            safe = always_safe + safe
 
153
            _safe_quoters[cachekey] = (quoter, safe)
 
154
        if not s.rstrip(safe):
 
155
            return s
 
156
        return ''.join(map(quoter, s))
 
157
 
 
158
    quote = quote_from_bytes
 
159
    unquote_to_bytes = urlparse.unquote
 
160
 
 
161
 
 
162
unquote = urlparse.unquote
 
163
 
 
164
 
 
165
def escape(relpath, safe='/~'):
64
166
    """Escape relpath to be a valid url."""
65
 
    if isinstance(relpath, unicode):
 
167
    if not isinstance(relpath, str) and sys.version_info[0] == 2:
 
168
        # GZ 2019-06-16: Should use _fs_enc instead here really?
66
169
        relpath = relpath.encode('utf-8')
67
 
    # After quoting and encoding, the path should be perfectly
68
 
    # safe as a plain ASCII string, str() just enforces this
69
 
    return str(urllib.quote(relpath, safe='/~'))
 
170
    return quote(relpath, safe=safe)
70
171
 
71
172
 
72
173
def file_relpath(base, path):
76
177
    """
77
178
    if len(base) < MIN_ABS_FILEURL_LENGTH:
78
179
        raise ValueError('Length of base (%r) must equal or'
79
 
            ' exceed the platform minimum url length (which is %d)' %
80
 
            (base, MIN_ABS_FILEURL_LENGTH))
81
 
    base = local_path_from_url(base)
82
 
    path = local_path_from_url(path)
 
180
                         ' exceed the platform minimum url length (which is %d)' %
 
181
                         (base, MIN_ABS_FILEURL_LENGTH))
 
182
    base = osutils.normpath(local_path_from_url(base))
 
183
    path = osutils.normpath(local_path_from_url(path))
83
184
    return escape(osutils.relpath(base, path))
84
185
 
85
186
 
101
202
    first_path_slash = path.find('/')
102
203
    if first_path_slash == -1:
103
204
        return len(scheme), None
104
 
    return len(scheme), first_path_slash+len(scheme)+3
 
205
    return len(scheme), first_path_slash + m.start('path')
 
206
 
 
207
 
 
208
def is_url(url):
 
209
    """Tests whether a URL is in actual fact a URL."""
 
210
    return _url_scheme_re.match(url) is not None
105
211
 
106
212
 
107
213
def join(base, *args):
118
224
    """
119
225
    if not args:
120
226
        return base
121
 
    match = _url_scheme_re.match(base)
122
 
    scheme = None
123
 
    if match:
124
 
        scheme = match.group('scheme')
125
 
        path = match.group('path').split('/')
126
 
        if path[-1:] == ['']:
127
 
            # Strip off a trailing slash
128
 
            # This helps both when we are at the root, and when
129
 
            # 'base' has an extra slash at the end
130
 
            path = path[:-1]
131
 
    else:
132
 
        path = base.split('/')
133
 
 
134
 
    if scheme is not None and len(path) >= 1:
135
 
        host = path[:1]
136
 
        # the path should be represented as an abs path.
137
 
        # we know this must be absolute because of the presence of a URL scheme.
138
 
        remove_root = True
139
 
        path = [''] + path[1:]
140
 
    else:
141
 
        # create an empty host, but dont alter the path - this might be a
142
 
        # relative url fragment.
143
 
        host = []
144
 
        remove_root = False
145
 
 
 
227
    scheme_end, path_start = _find_scheme_and_separator(base)
 
228
    if scheme_end is None and path_start is None:
 
229
        path_start = 0
 
230
    elif path_start is None:
 
231
        path_start = len(base)
 
232
    path = base[path_start:]
146
233
    for arg in args:
147
 
        match = _url_scheme_re.match(arg)
148
 
        if match:
149
 
            # Absolute URL
150
 
            scheme = match.group('scheme')
151
 
            # this skips .. normalisation, making http://host/../../..
152
 
            # be rather strange.
153
 
            path = match.group('path').split('/')
154
 
            # set the host and path according to new absolute URL, discarding
155
 
            # any previous values.
156
 
            # XXX: duplicates mess from earlier in this function.  This URL
157
 
            # manipulation code needs some cleaning up.
158
 
            if scheme is not None and len(path) >= 1:
159
 
                host = path[:1]
160
 
                path = path[1:]
161
 
                # url scheme implies absolute path.
162
 
                path = [''] + path
163
 
            else:
164
 
                # no url scheme we take the path as is.
165
 
                host = []
 
234
        arg_scheme_end, arg_path_start = _find_scheme_and_separator(arg)
 
235
        if arg_scheme_end is None and arg_path_start is None:
 
236
            arg_path_start = 0
 
237
        elif arg_path_start is None:
 
238
            arg_path_start = len(arg)
 
239
        if arg_scheme_end is not None:
 
240
            base = arg
 
241
            path = arg[arg_path_start:]
 
242
            scheme_end = arg_scheme_end
 
243
            path_start = arg_path_start
166
244
        else:
167
 
            path = '/'.join(path)
168
245
            path = joinpath(path, arg)
169
 
            path = path.split('/')
170
 
    if remove_root and path[0:1] == ['']:
171
 
        del path[0]
172
 
    if host:
173
 
        # Remove the leading slash from the path, so long as it isn't also the
174
 
        # trailing slash, which we want to keep if present.
175
 
        if path and path[0] == '' and len(path) > 1:
176
 
            del path[0]
177
 
        path = host + path
178
 
 
179
 
    if scheme is None:
180
 
        return '/'.join(path)
181
 
    return scheme + '://' + '/'.join(path)
 
246
    return base[:path_start] + path
182
247
 
183
248
 
184
249
def joinpath(base, *args):
193
258
    """
194
259
    path = base.split('/')
195
260
    if len(path) > 1 and path[-1] == '':
196
 
        #If the path ends in a trailing /, remove it.
 
261
        # If the path ends in a trailing /, remove it.
197
262
        path.pop()
198
263
    for arg in args:
199
264
        if arg.startswith('/'):
203
268
                continue
204
269
            elif chunk == '..':
205
270
                if path == ['']:
206
 
                    raise errors.InvalidURLJoin('Cannot go above root',
207
 
                            base, args)
 
271
                    raise InvalidURLJoin('Cannot go above root',
 
272
                                         base, args)
208
273
                path.pop()
209
274
            else:
210
275
                path.append(chunk)
217
282
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
218
283
def _posix_local_path_from_url(url):
219
284
    """Convert a url like file:///path/to/foo into /path/to/foo"""
 
285
    url = split_segment_parameters_raw(url)[0]
220
286
    file_localhost_prefix = 'file://localhost/'
221
287
    if url.startswith(file_localhost_prefix):
222
288
        path = url[len(file_localhost_prefix) - 1:]
223
289
    elif not url.startswith('file:///'):
224
 
        raise errors.InvalidURL(
 
290
        raise InvalidURL(
225
291
            url, 'local urls must start with file:/// or file://localhost/')
226
292
    else:
227
293
        path = url[len('file://'):]
236
302
    """
237
303
    # importing directly from posixpath allows us to test this
238
304
    # on non-posix platforms
239
 
    return 'file://' + escape(_posix_normpath(
240
 
        osutils._posix_abspath(path)))
 
305
    return 'file://' + escape(osutils._posix_abspath(path))
241
306
 
242
307
 
243
308
def _win32_local_path_from_url(url):
244
309
    """Convert a url like file:///C:/path/to/foo into C:/path/to/foo"""
245
310
    if not url.startswith('file://'):
246
 
        raise errors.InvalidURL(url, 'local urls must start with file:///, '
247
 
                                     'UNC path urls must start with file://')
 
311
        raise InvalidURL(url, 'local urls must start with file:///, '
 
312
                         'UNC path urls must start with file://')
 
313
    url = split_segment_parameters_raw(url)[0]
248
314
    # We strip off all 3 slashes
249
315
    win32_url = url[len('file:'):]
250
316
    # check for UNC path: //HOST/path
251
317
    if not win32_url.startswith('///'):
252
318
        if (win32_url[2] == '/'
253
 
            or win32_url[3] in '|:'):
254
 
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
255
 
                ' have form file://HOST/path')
 
319
                or win32_url[3] in '|:'):
 
320
            raise InvalidURL(url, 'Win32 UNC path urls'
 
321
                             ' have form file://HOST/path')
256
322
        return unescape(win32_url)
257
323
 
258
324
    # allow empty paths so we can serve all roots
260
326
        return '/'
261
327
 
262
328
    # usual local path with drive letter
263
 
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
264
 
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
265
 
        or win32_url[4] not in  '|:'
266
 
        or win32_url[5] != '/'):
267
 
        raise errors.InvalidURL(url, 'Win32 file urls start with'
268
 
                ' file:///x:/, where x is a valid drive letter')
 
329
    if (len(win32_url) < 6
 
330
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
331
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ') or
 
332
        win32_url[4] not in '|:'
 
333
            or win32_url[5] != '/'):
 
334
        raise InvalidURL(url, 'Win32 file urls start with'
 
335
                         ' file:///x:/, where x is a valid drive letter')
269
336
    return win32_url[3].upper() + u':' + unescape(win32_url[5:])
270
337
 
271
338
 
278
345
    # on non-win32 platform
279
346
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
280
347
    #       which actually strips trailing space characters.
281
 
    #       The worst part is that under linux ntpath.abspath has different
 
348
    #       The worst part is that on linux ntpath.abspath has different
282
349
    #       semantics, since 'nt' is not an available module.
283
350
    if path == '/':
284
351
        return 'file:///'
288
355
    if win32_path.startswith('//'):
289
356
        return 'file:' + escape(win32_path)
290
357
    return ('file:///' + str(win32_path[0].upper()) + ':' +
291
 
        escape(win32_path[2:]))
 
358
            escape(win32_path[2:]))
292
359
 
293
360
 
294
361
local_path_to_url = _posix_local_path_to_url
303
370
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
304
371
 
305
372
 
306
 
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
307
 
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
 
373
_url_scheme_re = re.compile('^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
 
374
_url_hex_escapes_re = re.compile('(%[0-9a-fA-F]{2})')
308
375
 
309
376
 
310
377
def _unescape_safe_chars(matchobj):
339
406
    :param url: Either a hybrid URL or a local path
340
407
    :return: A normalized URL which only includes 7-bit ASCII characters.
341
408
    """
342
 
    m = _url_scheme_re.match(url)
343
 
    if not m:
 
409
    scheme_end, path_start = _find_scheme_and_separator(url)
 
410
    if scheme_end is None:
344
411
        return local_path_to_url(url)
345
 
    scheme = m.group('scheme')
346
 
    path = m.group('path')
347
 
    if not isinstance(url, unicode):
 
412
    prefix = url[:path_start]
 
413
    path = url[path_start:]
 
414
    if not isinstance(url, text_type):
348
415
        for c in url:
349
416
            if c not in _url_safe_characters:
350
 
                raise errors.InvalidURL(url, 'URLs can only contain specific'
351
 
                                            ' safe characters (not %r)' % c)
 
417
                raise InvalidURL(url, 'URLs can only contain specific'
 
418
                                 ' safe characters (not %r)' % c)
352
419
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
353
 
        return str(scheme + '://' + ''.join(path))
 
420
        return str(prefix + ''.join(path))
354
421
 
355
422
    # We have a unicode (hybrid) url
356
423
    path_chars = list(path)
357
424
 
358
 
    for i in xrange(len(path_chars)):
 
425
    for i in range(len(path_chars)):
359
426
        if path_chars[i] not in _url_safe_characters:
360
 
            chars = path_chars[i].encode('utf-8')
361
427
            path_chars[i] = ''.join(
362
 
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
 
428
                ['%%%02X' % c for c in bytearray(path_chars[i].encode('utf-8'))])
363
429
    path = ''.join(path_chars)
364
430
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
365
 
    return str(scheme + '://' + path)
 
431
    return str(prefix + path)
366
432
 
367
433
 
368
434
def relative_url(base, other):
385
451
    if base_scheme != other_scheme:
386
452
        return other
387
453
    elif sys.platform == 'win32' and base_scheme == 'file://':
388
 
        base_drive = base[base_first_slash+1:base_first_slash+3]
389
 
        other_drive = other[other_first_slash+1:other_first_slash+3]
 
454
        base_drive = base[base_first_slash + 1:base_first_slash + 3]
 
455
        other_drive = other[other_first_slash + 1:other_first_slash + 3]
390
456
        if base_drive != other_drive:
391
457
            return other
392
458
 
393
 
    base_path = base[base_first_slash+1:]
394
 
    other_path = other[other_first_slash+1:]
 
459
    base_path = base[base_first_slash + 1:]
 
460
    other_path = other[other_first_slash + 1:]
395
461
 
396
462
    if base_path.endswith('/'):
397
463
        base_path = base_path[:-1]
421
487
    """On win32 the drive letter needs to be added to the url base."""
422
488
    # Strip off the drive letter
423
489
    # path is currently /C:/foo
424
 
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
425
 
        raise errors.InvalidURL(url_base + path,
426
 
            'win32 file:/// paths need a drive letter')
427
 
    url_base += path[0:3] # file:// + /C:
428
 
    path = path[3:] # /foo
 
490
    if len(path) < 4 or path[2] not in ':|' or path[3] != '/':
 
491
        raise InvalidURL(url_base + path,
 
492
                         'win32 file:/// paths need a drive letter')
 
493
    url_base += path[0:3]  # file:// + /C:
 
494
    path = path[3:]  # /foo
429
495
    return url_base, path
430
496
 
431
497
 
436
502
    :param exclude_trailing_slash: Strip off a final '/' if it is part
437
503
        of the path (but not if it is part of the protocol specification)
438
504
 
439
 
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at
440
 
        the root.
 
505
    :return: (parent_url, child_dir).  child_dir may be the empty string if
 
506
        we're at the root.
441
507
    """
442
508
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
443
509
 
453
519
            return url, ''
454
520
 
455
521
    # We have a fully defined path
456
 
    url_base = url[:first_path_slash] # http://host, file://
457
 
    path = url[first_path_slash:] # /file/foo
 
522
    url_base = url[:first_path_slash]  # http://host, file://
 
523
    path = url[first_path_slash:]  # /file/foo
458
524
 
459
525
    if sys.platform == 'win32' and url.startswith('file:///'):
460
526
        # Strip off the drive letter
469
535
    return url_base + head, tail
470
536
 
471
537
 
 
538
def split_segment_parameters_raw(url):
 
539
    """Split the subsegment of the last segment of a URL.
 
540
 
 
541
    :param url: A relative or absolute URL
 
542
    :return: (url, subsegments)
 
543
    """
 
544
    # GZ 2011-11-18: Dodgy removing the terminal slash like this, function
 
545
    #                operates on urls not url+segments, and Transport classes
 
546
    #                should not be blindly adding slashes in the first place.
 
547
    lurl = strip_trailing_slash(url)
 
548
    # Segments begin at first comma after last forward slash, if one exists
 
549
    segment_start = lurl.find(",", lurl.rfind("/") + 1)
 
550
    if segment_start == -1:
 
551
        return (url, [])
 
552
    return (lurl[:segment_start],
 
553
            [str(s) for s in lurl[segment_start + 1:].split(",")])
 
554
 
 
555
 
 
556
def split_segment_parameters(url):
 
557
    """Split the segment parameters of the last segment of a URL.
 
558
 
 
559
    :param url: A relative or absolute URL
 
560
    :return: (url, segment_parameters)
 
561
    """
 
562
    (base_url, subsegments) = split_segment_parameters_raw(url)
 
563
    parameters = {}
 
564
    for subsegment in subsegments:
 
565
        try:
 
566
            (key, value) = subsegment.split("=", 1)
 
567
        except ValueError:
 
568
            raise InvalidURL(url, "missing = in subsegment")
 
569
        if not isinstance(key, str):
 
570
            raise TypeError(key)
 
571
        if not isinstance(value, str):
 
572
            raise TypeError(value)
 
573
        parameters[key] = value
 
574
    return (base_url, parameters)
 
575
 
 
576
 
 
577
def join_segment_parameters_raw(base, *subsegments):
 
578
    """Create a new URL by adding subsegments to an existing one.
 
579
 
 
580
    This adds the specified subsegments to the last path in the specified
 
581
    base URL. The subsegments should be bytestrings.
 
582
 
 
583
    :note: You probably want to use join_segment_parameters instead.
 
584
    """
 
585
    if not subsegments:
 
586
        return base
 
587
    for subsegment in subsegments:
 
588
        if not isinstance(subsegment, str):
 
589
            raise TypeError("Subsegment %r is not a bytestring" % subsegment)
 
590
        if "," in subsegment:
 
591
            raise InvalidURLJoin(", exists in subsegments",
 
592
                                 base, subsegments)
 
593
    return ",".join((base,) + subsegments)
 
594
 
 
595
 
 
596
def join_segment_parameters(url, parameters):
 
597
    """Create a new URL by adding segment parameters to an existing one.
 
598
 
 
599
    The parameters of the last segment in the URL will be updated; if a
 
600
    parameter with the same key already exists it will be overwritten.
 
601
 
 
602
    :param url: A URL, as string
 
603
    :param parameters: Dictionary of parameters, keys and values as bytestrings
 
604
    """
 
605
    (base, existing_parameters) = split_segment_parameters(url)
 
606
    new_parameters = {}
 
607
    new_parameters.update(existing_parameters)
 
608
    for key, value in parameters.items():
 
609
        if not isinstance(key, str):
 
610
            raise TypeError("parameter key %r is not a str" % key)
 
611
        if not isinstance(value, str):
 
612
            raise TypeError("parameter value %r for %r is not a str" %
 
613
                            (value, key))
 
614
        if "=" in key:
 
615
            raise InvalidURLJoin("= exists in parameter key", url,
 
616
                                 parameters)
 
617
        new_parameters[key] = value
 
618
    return join_segment_parameters_raw(
 
619
        base, *["%s=%s" % item for item in sorted(new_parameters.items())])
 
620
 
 
621
 
472
622
def _win32_strip_local_trailing_slash(url):
473
623
    """Strip slashes after the drive letter"""
474
624
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
510
660
        # so just chop off the last character
511
661
        return url[:-1]
512
662
 
513
 
    if first_path_slash is None or first_path_slash == len(url)-1:
 
663
    if first_path_slash is None or first_path_slash == len(url) - 1:
514
664
        # Don't chop off anything if the only slash is the path
515
665
        # separating slash
516
666
        return url
524
674
    This returns a Unicode path from a URL
525
675
    """
526
676
    # jam 20060427 URLs are supposed to be ASCII only strings
527
 
    #       If they are passed in as unicode, urllib.unquote
 
677
    #       If they are passed in as unicode, unquote
528
678
    #       will return a UNICODE string, which actually contains
529
679
    #       utf-8 bytes. So we have to ensure that they are
530
680
    #       plain ASCII strings, or the final .decode will
531
681
    #       try to encode the UNICODE => ASCII, and then decode
532
682
    #       it into utf-8.
533
 
    try:
534
 
        url = str(url)
535
 
    except UnicodeError, e:
536
 
        raise errors.InvalidURL(url, 'URL was not a plain ASCII url: %s' % (e,))
537
683
 
538
 
    unquoted = urllib.unquote(url)
539
 
    try:
540
 
        unicode_path = unquoted.decode('utf-8')
541
 
    except UnicodeError, e:
542
 
        raise errors.InvalidURL(url, 'Unable to encode the URL as utf-8: %s' % (e,))
543
 
    return unicode_path
 
684
    if PY3:
 
685
        if isinstance(url, text_type):
 
686
            try:
 
687
                url.encode("ascii")
 
688
            except UnicodeError as e:
 
689
                raise InvalidURL(
 
690
                    url, 'URL was not a plain ASCII url: %s' % (e,))
 
691
        return urlparse.unquote(url)
 
692
    else:
 
693
        if isinstance(url, text_type):
 
694
            try:
 
695
                url = url.encode("ascii")
 
696
            except UnicodeError as e:
 
697
                raise InvalidURL(
 
698
                    url, 'URL was not a plain ASCII url: %s' % (e,))
 
699
        unquoted = unquote(url)
 
700
        try:
 
701
            unicode_path = unquoted.decode('utf-8')
 
702
        except UnicodeError as e:
 
703
            raise InvalidURL(
 
704
                url, 'Unable to encode the URL as utf-8: %s' % (e,))
 
705
        return unicode_path
544
706
 
545
707
 
546
708
# These are characters that if escaped, should stay that way
547
709
_no_decode_chars = ';/?:@&=+$,#'
548
710
_no_decode_ords = [ord(c) for c in _no_decode_chars]
549
711
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
550
 
                + ['%02X' % o for o in _no_decode_ords])
551
 
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
552
 
                    + [('%02X' % o, chr(o)) for o in range(256)]))
553
 
#These entries get mapped to themselves
554
 
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
 
712
                  + ['%02X' % o for o in _no_decode_ords])
 
713
_hex_display_map = dict(([('%02x' % o, int2byte(o)) for o in range(256)]
 
714
                         + [('%02X' % o, int2byte(o)) for o in range(256)]))
 
715
# These entries get mapped to themselves
 
716
_hex_display_map.update((hex, b'%' + hex.encode('ascii'))
 
717
                        for hex in _no_decode_hex)
555
718
 
556
719
# These characters shouldn't be percent-encoded, and it's always safe to
557
720
# unencode them if they are.
558
721
_url_dont_escape_characters = set(
559
 
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
560
 
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
561
 
   "0123456789" # Numbers
562
 
   "-._~"  # Unreserved characters
 
722
    "abcdefghijklmnopqrstuvwxyz"  # Lowercase alpha
 
723
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"  # Uppercase alpha
 
724
    "0123456789"  # Numbers
 
725
    "-._~"  # Unreserved characters
563
726
)
564
727
 
565
728
# These characters should not be escaped
566
729
_url_safe_characters = set(
567
 
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
568
 
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
569
 
   "0123456789" # Numbers
570
 
   "_.-!~*'()"  # Unreserved characters
571
 
   "/;?:@&=+$," # Reserved characters
572
 
   "%#"         # Extra reserved characters
 
730
    "abcdefghijklmnopqrstuvwxyz"  # Lowercase alpha
 
731
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"  # Uppercase alpha
 
732
    "0123456789"  # Numbers
 
733
    "_.-!~*'()"  # Unreserved characters
 
734
    "/;?:@&=+$,"  # Reserved characters
 
735
    "%#"         # Extra reserved characters
573
736
)
574
737
 
 
738
 
 
739
def _unescape_segment_for_display(segment, encoding):
 
740
    """Unescape a segment for display.
 
741
 
 
742
    Helper for unescape_for_display
 
743
 
 
744
    :param url: A 7-bit ASCII URL
 
745
    :param encoding: The final output encoding
 
746
 
 
747
    :return: A unicode string which can be safely encoded into the
 
748
         specified encoding.
 
749
    """
 
750
    escaped_chunks = segment.split('%')
 
751
    escaped_chunks[0] = escaped_chunks[0].encode('utf-8')
 
752
    for j in range(1, len(escaped_chunks)):
 
753
        item = escaped_chunks[j]
 
754
        try:
 
755
            escaped_chunks[j] = _hex_display_map[item[:2]]
 
756
        except KeyError:
 
757
            # Put back the percent symbol
 
758
            escaped_chunks[j] = b'%' + \
 
759
                (item[:2].encode('utf-8') if PY3 else item[:2])
 
760
        except UnicodeDecodeError:
 
761
            escaped_chunks[j] = unichr(int(item[:2], 16)).encode('utf-8')
 
762
        escaped_chunks[j] += (item[2:].encode('utf-8') if PY3 else item[2:])
 
763
    unescaped = b''.join(escaped_chunks)
 
764
    try:
 
765
        decoded = unescaped.decode('utf-8')
 
766
    except UnicodeDecodeError:
 
767
        # If this path segment cannot be properly utf-8 decoded
 
768
        # after doing unescaping we will just leave it alone
 
769
        return segment
 
770
    else:
 
771
        try:
 
772
            decoded.encode(encoding)
 
773
        except UnicodeEncodeError:
 
774
            # If this chunk cannot be encoded in the local
 
775
            # encoding, then we should leave it alone
 
776
            return segment
 
777
        else:
 
778
            # Otherwise take the url decoded one
 
779
            return decoded
 
780
 
 
781
 
575
782
def unescape_for_display(url, encoding):
576
783
    """Decode what you can for a URL, so that we get a nice looking path.
577
784
 
599
806
 
600
807
    # Split into sections to try to decode utf-8
601
808
    res = url.split('/')
602
 
    for i in xrange(1, len(res)):
603
 
        escaped_chunks = res[i].split('%')
604
 
        for j in xrange(1, len(escaped_chunks)):
605
 
            item = escaped_chunks[j]
606
 
            try:
607
 
                escaped_chunks[j] = _hex_display_map[item[:2]] + item[2:]
608
 
            except KeyError:
609
 
                # Put back the percent symbol
610
 
                escaped_chunks[j] = '%' + item
611
 
            except UnicodeDecodeError:
612
 
                escaped_chunks[j] = unichr(int(item[:2], 16)) + item[2:]
613
 
        unescaped = ''.join(escaped_chunks)
614
 
        try:
615
 
            decoded = unescaped.decode('utf-8')
616
 
        except UnicodeDecodeError:
617
 
            # If this path segment cannot be properly utf-8 decoded
618
 
            # after doing unescaping we will just leave it alone
619
 
            pass
620
 
        else:
621
 
            try:
622
 
                decoded.encode(encoding)
623
 
            except UnicodeEncodeError:
624
 
                # If this chunk cannot be encoded in the local
625
 
                # encoding, then we should leave it alone
626
 
                pass
627
 
            else:
628
 
                # Otherwise take the url decoded one
629
 
                res[i] = decoded
 
809
    for i in range(1, len(res)):
 
810
        res[i] = _unescape_segment_for_display(res[i], encoding)
630
811
    return u'/'.join(res)
631
812
 
632
813
 
641
822
    is used without a path, e.g. c:foo-bar => foo-bar.
642
823
    If no /, path separator or : is found, the from_location is returned.
643
824
    """
 
825
    from_location, unused_params = split_segment_parameters(from_location)
644
826
    if from_location.find("/") >= 0 or from_location.find(os.sep) >= 0:
645
827
        return os.path.basename(from_location.rstrip("/\\"))
646
828
    else:
647
829
        sep = from_location.find(":")
648
830
        if sep > 0:
649
 
            return from_location[sep+1:]
 
831
            return from_location[sep + 1:]
650
832
        else:
651
833
            return from_location
652
834
 
669
851
    old_parsed = urlparse.urlparse(old_base)
670
852
    new_parsed = urlparse.urlparse(new_base)
671
853
    if (old_parsed[:2]) != (new_parsed[:2]):
672
 
        raise errors.InvalidRebaseURLs(old_base, new_base)
 
854
        raise InvalidRebaseURLs(old_base, new_base)
673
855
    return determine_relative_path(new_parsed[2],
674
856
                                   join(old_parsed[2], url))
675
857
 
680
862
    to_segments = osutils.splitpath(to_path)
681
863
    count = -1
682
864
    for count, (from_element, to_element) in enumerate(zip(from_segments,
683
 
                                                       to_segments)):
 
865
                                                           to_segments)):
684
866
        if from_element != to_element:
685
867
            break
686
868
    else:
693
875
    return osutils.pathjoin(*segments)
694
876
 
695
877
 
 
878
class URL(object):
 
879
    """Parsed URL."""
 
880
 
 
881
    def __init__(self, scheme, quoted_user, quoted_password, quoted_host,
 
882
                 port, quoted_path):
 
883
        self.scheme = scheme
 
884
        self.quoted_host = quoted_host
 
885
        self.host = unquote(self.quoted_host)
 
886
        self.quoted_user = quoted_user
 
887
        if self.quoted_user is not None:
 
888
            self.user = unquote(self.quoted_user)
 
889
        else:
 
890
            self.user = None
 
891
        self.quoted_password = quoted_password
 
892
        if self.quoted_password is not None:
 
893
            self.password = unquote(self.quoted_password)
 
894
        else:
 
895
            self.password = None
 
896
        self.port = port
 
897
        self.quoted_path = _url_hex_escapes_re.sub(
 
898
            _unescape_safe_chars, quoted_path)
 
899
        self.path = unquote(self.quoted_path)
 
900
 
 
901
    def __eq__(self, other):
 
902
        return (isinstance(other, self.__class__) and
 
903
                self.scheme == other.scheme and
 
904
                self.host == other.host and
 
905
                self.user == other.user and
 
906
                self.password == other.password and
 
907
                self.path == other.path)
 
908
 
 
909
    def __repr__(self):
 
910
        return "<%s(%r, %r, %r, %r, %r, %r)>" % (
 
911
            self.__class__.__name__,
 
912
            self.scheme, self.quoted_user, self.quoted_password,
 
913
            self.quoted_host, self.port, self.quoted_path)
 
914
 
 
915
    @classmethod
 
916
    def from_string(cls, url):
 
917
        """Create a URL object from a string.
 
918
 
 
919
        :param url: URL as bytestring
 
920
        """
 
921
        # GZ 2017-06-09: Actually validate ascii-ness
 
922
        # pad.lv/1696545: For the moment, accept both native strings and
 
923
        # unicode.
 
924
        if isinstance(url, str):
 
925
            pass
 
926
        elif isinstance(url, text_type):
 
927
            try:
 
928
                url = url.encode()
 
929
            except UnicodeEncodeError:
 
930
                raise InvalidURL(url)
 
931
        else:
 
932
            raise InvalidURL(url)
 
933
        (scheme, netloc, path, params,
 
934
         query, fragment) = urlparse.urlparse(url, allow_fragments=False)
 
935
        user = password = host = port = None
 
936
        if '@' in netloc:
 
937
            user, host = netloc.rsplit('@', 1)
 
938
            if ':' in user:
 
939
                user, password = user.split(':', 1)
 
940
        else:
 
941
            host = netloc
 
942
 
 
943
        if ':' in host and not (host[0] == '[' and host[-1] == ']'):
 
944
            # there *is* port
 
945
            host, port = host.rsplit(':', 1)
 
946
            if port:
 
947
                try:
 
948
                    port = int(port)
 
949
                except ValueError:
 
950
                    raise InvalidURL('invalid port number %s in url:\n%s' %
 
951
                                     (port, url))
 
952
            else:
 
953
                port = None
 
954
        if host != "" and host[0] == '[' and host[-1] == ']':  # IPv6
 
955
            host = host[1:-1]
 
956
 
 
957
        return cls(scheme, user, password, host, port, path)
 
958
 
 
959
    def __str__(self):
 
960
        netloc = self.quoted_host
 
961
        if ":" in netloc:
 
962
            netloc = "[%s]" % netloc
 
963
        if self.quoted_user is not None:
 
964
            # Note that we don't put the password back even if we
 
965
            # have one so that it doesn't get accidentally
 
966
            # exposed.
 
967
            netloc = '%s@%s' % (self.quoted_user, netloc)
 
968
        if self.port is not None:
 
969
            netloc = '%s:%d' % (netloc, self.port)
 
970
        return urlparse.urlunparse(
 
971
            (self.scheme, netloc, self.quoted_path, None, None, None))
 
972
 
 
973
    @staticmethod
 
974
    def _combine_paths(base_path, relpath):
 
975
        """Transform a Transport-relative path to a remote absolute path.
 
976
 
 
977
        This does not handle substitution of ~ but does handle '..' and '.'
 
978
        components.
 
979
 
 
980
        Examples::
 
981
 
 
982
            t._combine_paths('/home/sarah', 'project/foo')
 
983
                => '/home/sarah/project/foo'
 
984
            t._combine_paths('/home/sarah', '../../etc')
 
985
                => '/etc'
 
986
            t._combine_paths('/home/sarah', '/etc')
 
987
                => '/etc'
 
988
 
 
989
        :param base_path: base path
 
990
        :param relpath: relative url string for relative part of remote path.
 
991
        :return: urlencoded string for final path.
 
992
        """
 
993
        # pad.lv/1696545: For the moment, accept both native strings and
 
994
        # unicode.
 
995
        if isinstance(relpath, str):
 
996
            pass
 
997
        elif isinstance(relpath, text_type):
 
998
            try:
 
999
                relpath = relpath.encode()
 
1000
            except UnicodeEncodeError:
 
1001
                raise InvalidURL(relpath)
 
1002
        else:
 
1003
            raise InvalidURL(relpath)
 
1004
        relpath = _url_hex_escapes_re.sub(_unescape_safe_chars, relpath)
 
1005
        if relpath.startswith('/'):
 
1006
            base_parts = []
 
1007
        else:
 
1008
            base_parts = base_path.split('/')
 
1009
        if len(base_parts) > 0 and base_parts[-1] == '':
 
1010
            base_parts = base_parts[:-1]
 
1011
        for p in relpath.split('/'):
 
1012
            if p == '..':
 
1013
                if len(base_parts) == 0:
 
1014
                    # In most filesystems, a request for the parent
 
1015
                    # of root, just returns root.
 
1016
                    continue
 
1017
                base_parts.pop()
 
1018
            elif p == '.':
 
1019
                continue  # No-op
 
1020
            elif p != '':
 
1021
                base_parts.append(p)
 
1022
        path = '/'.join(base_parts)
 
1023
        if not path.startswith('/'):
 
1024
            path = '/' + path
 
1025
        return path
 
1026
 
 
1027
    def clone(self, offset=None):
 
1028
        """Return a new URL for a path relative to this URL.
 
1029
 
 
1030
        :param offset: A relative path, already urlencoded
 
1031
        :return: `URL` instance
 
1032
        """
 
1033
        if offset is not None:
 
1034
            relative = unescape(offset)
 
1035
            if sys.version_info[0] == 2:
 
1036
                relative = relative.encode('utf-8')
 
1037
            path = self._combine_paths(self.path, relative)
 
1038
            path = quote(path, safe="/~")
 
1039
        else:
 
1040
            path = self.quoted_path
 
1041
        return self.__class__(self.scheme, self.quoted_user,
 
1042
                              self.quoted_password, self.quoted_host, self.port,
 
1043
                              path)
 
1044
 
696
1045
 
697
1046
def parse_url(url):
698
1047
    """Extract the server address, the credentials and the path from the url.
701
1050
    chars.
702
1051
 
703
1052
    :param url: an quoted url
704
 
 
705
1053
    :return: (scheme, user, password, host, port, path) tuple, all fields
706
1054
        are unquoted.
707
1055
    """
708
 
    if isinstance(url, unicode):
709
 
        raise errors.InvalidURL('should be ascii:\n%r' % url)
710
 
    url = url.encode('utf-8')
711
 
    (scheme, netloc, path, params,
712
 
     query, fragment) = urlparse.urlparse(url, allow_fragments=False)
713
 
    user = password = host = port = None
714
 
    if '@' in netloc:
715
 
        user, host = netloc.rsplit('@', 1)
716
 
        if ':' in user:
717
 
            user, password = user.split(':', 1)
718
 
            password = urllib.unquote(password)
719
 
        user = urllib.unquote(user)
720
 
    else:
721
 
        host = netloc
722
 
 
723
 
    if ':' in host and not (host[0] == '[' and host[-1] == ']'): #there *is* port
724
 
        host, port = host.rsplit(':',1)
725
 
        try:
726
 
            port = int(port)
727
 
        except ValueError:
728
 
            raise errors.InvalidURL('invalid port number %s in url:\n%s' %
729
 
                                    (port, url))
730
 
    if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
731
 
        host = host[1:-1]
732
 
 
733
 
    host = urllib.unquote(host)
734
 
    path = urllib.unquote(path)
735
 
 
736
 
    return (scheme, user, password, host, port, path)
 
1056
    parsed_url = URL.from_string(url)
 
1057
    return (parsed_url.scheme, parsed_url.user, parsed_url.password,
 
1058
            parsed_url.host, parsed_url.port, parsed_url.path)