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

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2008 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
16
16
 
17
17
"""A collection of function for handling URL operations."""
18
18
 
19
 
from __future__ import absolute_import
20
 
 
21
19
import os
22
20
import re
23
21
import sys
24
22
 
25
 
try:
26
 
    import urlparse
27
 
except ImportError:
28
 
    from urllib import parse as urlparse
 
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
29
28
 
30
 
from . import (
 
29
from bzrlib import (
31
30
    errors,
32
31
    osutils,
33
32
    )
34
 
 
35
 
from .lazy_import import lazy_import
36
 
lazy_import(globals(), """
37
 
from posixpath import split as _posix_split
38
33
""")
39
34
 
40
 
from .sixish import (
41
 
    PY3,
42
 
    text_type,
43
 
    )
44
 
 
45
 
 
46
 
class InvalidURL(errors.PathError):
47
 
 
48
 
    _fmt = 'Invalid url supplied to transport: "%(path)s"%(extra)s'
49
 
 
50
 
 
51
 
class InvalidURLJoin(errors.PathError):
52
 
 
53
 
    _fmt = "Invalid URL join request: %(reason)s: %(base)r + %(join_args)r"
54
 
 
55
 
    def __init__(self, reason, base, join_args):
56
 
        self.reason = reason
57
 
        self.base = base
58
 
        self.join_args = join_args
59
 
        errors.PathError.__init__(self, base, reason)
60
 
 
61
 
 
62
 
class InvalidRebaseURLs(errors.PathError):
63
 
 
64
 
    _fmt = "URLs differ by more than path: %(from_)r and %(to)r"
65
 
 
66
 
    def __init__(self, from_, to):
67
 
        self.from_ = from_
68
 
        self.to = to
69
 
        errors.PathError.__init__(self, from_, 'URLs differ by more than path.')
70
 
 
71
35
 
72
36
def basename(url, exclude_trailing_slash=True):
73
37
    """Return the last component of a URL.
96
60
    return split(url, exclude_trailing_slash=exclude_trailing_slash)[0]
97
61
 
98
62
 
99
 
# Private copies of quote and unquote, copied from Python's
100
 
# urllib module because urllib unconditionally imports socket, which imports
101
 
# ssl.
102
 
 
103
 
always_safe = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'
104
 
               'abcdefghijklmnopqrstuvwxyz'
105
 
               '0123456789' '_.-')
106
 
_safe_map = {}
107
 
for i, c in zip(range(256), ''.join(map(chr, range(256)))):
108
 
    _safe_map[c] = c if (i < 128 and c in always_safe) else '%{0:02X}'.format(i)
109
 
_safe_quoters = {}
110
 
 
111
 
 
112
 
def quote(s, safe='/'):
113
 
    """quote('abc def') -> 'abc%20def'
114
 
 
115
 
    Each part of a URL, e.g. the path info, the query, etc., has a
116
 
    different set of reserved characters that must be quoted.
117
 
 
118
 
    RFC 2396 Uniform Resource Identifiers (URI): Generic Syntax lists
119
 
    the following reserved characters.
120
 
 
121
 
    reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
122
 
                  "$" | ","
123
 
 
124
 
    Each of these characters is reserved in some component of a URL,
125
 
    but not necessarily in all of them.
126
 
 
127
 
    By default, the quote function is intended for quoting the path
128
 
    section of a URL.  Thus, it will not encode '/'.  This character
129
 
    is reserved, but in typical usage the quote function is being
130
 
    called on a path where the existing slash characters are used as
131
 
    reserved characters.
132
 
    """
133
 
    # fastpath
134
 
    if not s:
135
 
        if s is None:
136
 
            raise TypeError('None object cannot be quoted')
137
 
        return s
138
 
    cachekey = (safe, always_safe)
139
 
    try:
140
 
        (quoter, safe) = _safe_quoters[cachekey]
141
 
    except KeyError:
142
 
        safe_map = _safe_map.copy()
143
 
        safe_map.update([(c, c) for c in safe])
144
 
        quoter = safe_map.__getitem__
145
 
        safe = always_safe + safe
146
 
        _safe_quoters[cachekey] = (quoter, safe)
147
 
    if not s.rstrip(safe):
148
 
        return s
149
 
    return ''.join(map(quoter, s))
150
 
 
151
 
 
152
 
unquote = urlparse.unquote
153
 
 
154
 
 
155
63
def escape(relpath):
156
64
    """Escape relpath to be a valid url."""
157
 
    if not isinstance(relpath, str) and sys.version_info[0] == 2:
 
65
    if isinstance(relpath, unicode):
158
66
        relpath = relpath.encode('utf-8')
159
 
    return quote(relpath, safe='/~')
 
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='/~'))
160
70
 
161
71
 
162
72
def file_relpath(base, path):
168
78
        raise ValueError('Length of base (%r) must equal or'
169
79
            ' exceed the platform minimum url length (which is %d)' %
170
80
            (base, MIN_ABS_FILEURL_LENGTH))
171
 
    base = osutils.normpath(local_path_from_url(base))
172
 
    path = osutils.normpath(local_path_from_url(path))
 
81
    base = local_path_from_url(base)
 
82
    path = local_path_from_url(path)
173
83
    return escape(osutils.relpath(base, path))
174
84
 
175
85
 
191
101
    first_path_slash = path.find('/')
192
102
    if first_path_slash == -1:
193
103
        return len(scheme), None
194
 
    return len(scheme), first_path_slash+m.start('path')
195
 
 
196
 
 
197
 
def is_url(url):
198
 
    """Tests whether a URL is in actual fact a URL."""
199
 
    return _url_scheme_re.match(url) is not None
 
104
    return len(scheme), first_path_slash+len(scheme)+3
200
105
 
201
106
 
202
107
def join(base, *args):
213
118
    """
214
119
    if not args:
215
120
        return base
216
 
    scheme_end, path_start = _find_scheme_and_separator(base)
217
 
    if scheme_end is None and path_start is None:
218
 
        path_start = 0
219
 
    elif path_start is None:
220
 
        path_start = len(base)
221
 
    path = base[path_start:]
 
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
 
222
146
    for arg in args:
223
 
        arg_scheme_end, arg_path_start = _find_scheme_and_separator(arg)
224
 
        if arg_scheme_end is None and arg_path_start is None:
225
 
            arg_path_start = 0
226
 
        elif arg_path_start is None:
227
 
            arg_path_start = len(arg)
228
 
        if arg_scheme_end is not None:
229
 
            base = arg
230
 
            path = arg[arg_path_start:]
231
 
            scheme_end = arg_scheme_end
232
 
            path_start = arg_path_start
 
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 = []
233
166
        else:
 
167
            path = '/'.join(path)
234
168
            path = joinpath(path, arg)
235
 
    return base[:path_start] + path
 
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)
236
182
 
237
183
 
238
184
def joinpath(base, *args):
257
203
                continue
258
204
            elif chunk == '..':
259
205
                if path == ['']:
260
 
                    raise InvalidURLJoin('Cannot go above root',
 
206
                    raise errors.InvalidURLJoin('Cannot go above root',
261
207
                            base, args)
262
208
                path.pop()
263
209
            else:
271
217
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
272
218
def _posix_local_path_from_url(url):
273
219
    """Convert a url like file:///path/to/foo into /path/to/foo"""
274
 
    url = split_segment_parameters_raw(url)[0]
275
 
    file_localhost_prefix = 'file://localhost/'
276
 
    if url.startswith(file_localhost_prefix):
277
 
        path = url[len(file_localhost_prefix) - 1:]
278
 
    elif not url.startswith('file:///'):
279
 
        raise InvalidURL(
280
 
            url, 'local urls must start with file:/// or file://localhost/')
281
 
    else:
282
 
        path = url[len('file://'):]
 
220
    if not url.startswith('file:///'):
 
221
        raise errors.InvalidURL(url, 'local urls must start with file:///')
283
222
    # We only strip off 2 slashes
284
 
    return unescape(path)
 
223
    return unescape(url[len('file://'):])
285
224
 
286
225
 
287
226
def _posix_local_path_to_url(path):
291
230
    """
292
231
    # importing directly from posixpath allows us to test this
293
232
    # on non-posix platforms
294
 
    return 'file://' + escape(osutils._posix_abspath(path))
 
233
    return 'file://' + escape(_posix_normpath(
 
234
        osutils._posix_abspath(path)))
295
235
 
296
236
 
297
237
def _win32_local_path_from_url(url):
298
238
    """Convert a url like file:///C:/path/to/foo into C:/path/to/foo"""
299
239
    if not url.startswith('file://'):
300
 
        raise InvalidURL(url, 'local urls must start with file:///, '
 
240
        raise errors.InvalidURL(url, 'local urls must start with file:///, '
301
241
                                     'UNC path urls must start with file://')
302
 
    url = split_segment_parameters_raw(url)[0]
303
242
    # We strip off all 3 slashes
304
243
    win32_url = url[len('file:'):]
305
244
    # check for UNC path: //HOST/path
306
245
    if not win32_url.startswith('///'):
307
246
        if (win32_url[2] == '/'
308
247
            or win32_url[3] in '|:'):
309
 
            raise InvalidURL(url, 'Win32 UNC path urls'
 
248
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
310
249
                ' have form file://HOST/path')
311
250
        return unescape(win32_url)
312
251
 
315
254
        return '/'
316
255
 
317
256
    # usual local path with drive letter
318
 
    if (len(win32_url) < 6
319
 
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
320
 
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
257
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
258
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
321
259
        or win32_url[4] not in  '|:'
322
260
        or win32_url[5] != '/'):
323
 
        raise InvalidURL(url, 'Win32 file urls start with'
 
261
        raise errors.InvalidURL(url, 'Win32 file urls start with'
324
262
                ' file:///x:/, where x is a valid drive letter')
325
263
    return win32_url[3].upper() + u':' + unescape(win32_url[5:])
326
264
 
334
272
    # on non-win32 platform
335
273
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
336
274
    #       which actually strips trailing space characters.
337
 
    #       The worst part is that on linux ntpath.abspath has different
 
275
    #       The worst part is that under linux ntpath.abspath has different
338
276
    #       semantics, since 'nt' is not an available module.
339
277
    if path == '/':
340
278
        return 'file:///'
359
297
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
360
298
 
361
299
 
362
 
_url_scheme_re = re.compile('^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
363
 
_url_hex_escapes_re = re.compile('(%[0-9a-fA-F]{2})')
 
300
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
 
301
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
364
302
 
365
303
 
366
304
def _unescape_safe_chars(matchobj):
395
333
    :param url: Either a hybrid URL or a local path
396
334
    :return: A normalized URL which only includes 7-bit ASCII characters.
397
335
    """
398
 
    scheme_end, path_start = _find_scheme_and_separator(url)
399
 
    if scheme_end is None:
 
336
    m = _url_scheme_re.match(url)
 
337
    if not m:
400
338
        return local_path_to_url(url)
401
 
    prefix = url[:path_start]
402
 
    path = url[path_start:]
403
 
    if not isinstance(url, text_type):
 
339
    scheme = m.group('scheme')
 
340
    path = m.group('path')
 
341
    if not isinstance(url, unicode):
404
342
        for c in url:
405
343
            if c not in _url_safe_characters:
406
 
                raise InvalidURL(url, 'URLs can only contain specific'
 
344
                raise errors.InvalidURL(url, 'URLs can only contain specific'
407
345
                                            ' safe characters (not %r)' % c)
408
346
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
409
 
        return str(prefix + ''.join(path))
 
347
        return str(scheme + '://' + ''.join(path))
410
348
 
411
349
    # We have a unicode (hybrid) url
412
350
    path_chars = list(path)
413
351
 
414
 
    for i in range(len(path_chars)):
 
352
    for i in xrange(len(path_chars)):
415
353
        if path_chars[i] not in _url_safe_characters:
416
354
            chars = path_chars[i].encode('utf-8')
417
355
            path_chars[i] = ''.join(
418
356
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
419
357
    path = ''.join(path_chars)
420
358
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
421
 
    return str(prefix + path)
 
359
    return str(scheme + '://' + path)
422
360
 
423
361
 
424
362
def relative_url(base, other):
477
415
    """On win32 the drive letter needs to be added to the url base."""
478
416
    # Strip off the drive letter
479
417
    # path is currently /C:/foo
480
 
    if len(path) < 4 or path[2] not in ':|' or path[3] != '/':
481
 
        raise InvalidURL(url_base + path,
 
418
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
 
419
        raise errors.InvalidURL(url_base + path,
482
420
            'win32 file:/// paths need a drive letter')
483
421
    url_base += path[0:3] # file:// + /C:
484
422
    path = path[3:] # /foo
525
463
    return url_base + head, tail
526
464
 
527
465
 
528
 
def split_segment_parameters_raw(url):
529
 
    """Split the subsegment of the last segment of a URL.
530
 
 
531
 
    :param url: A relative or absolute URL
532
 
    :return: (url, subsegments)
533
 
    """
534
 
    # GZ 2011-11-18: Dodgy removing the terminal slash like this, function
535
 
    #                operates on urls not url+segments, and Transport classes
536
 
    #                should not be blindly adding slashes in the first place. 
537
 
    lurl = strip_trailing_slash(url)
538
 
    # Segments begin at first comma after last forward slash, if one exists
539
 
    segment_start = lurl.find(",", lurl.rfind("/")+1)
540
 
    if segment_start == -1:
541
 
        return (url, [])
542
 
    return (lurl[:segment_start], [str(s) for s in lurl[segment_start+1:].split(",")])
543
 
 
544
 
 
545
 
def split_segment_parameters(url):
546
 
    """Split the segment parameters of the last segment of a URL.
547
 
 
548
 
    :param url: A relative or absolute URL
549
 
    :return: (url, segment_parameters)
550
 
    """
551
 
    (base_url, subsegments) = split_segment_parameters_raw(url)
552
 
    parameters = {}
553
 
    for subsegment in subsegments:
554
 
        (key, value) = subsegment.split("=", 1)
555
 
        if not isinstance(key, str):
556
 
            raise TypeError(key)
557
 
        if not isinstance(value, str):
558
 
            raise TypeError(value)
559
 
        parameters[key] = value
560
 
    return (base_url, parameters)
561
 
 
562
 
 
563
 
def join_segment_parameters_raw(base, *subsegments):
564
 
    """Create a new URL by adding subsegments to an existing one. 
565
 
 
566
 
    This adds the specified subsegments to the last path in the specified
567
 
    base URL. The subsegments should be bytestrings.
568
 
 
569
 
    :note: You probably want to use join_segment_parameters instead.
570
 
    """
571
 
    if not subsegments:
572
 
        return base
573
 
    for subsegment in subsegments:
574
 
        if not isinstance(subsegment, str):
575
 
            raise TypeError("Subsegment %r is not a bytestring" % subsegment)
576
 
        if "," in subsegment:
577
 
            raise InvalidURLJoin(", exists in subsegments",
578
 
                                        base, subsegments)
579
 
    return ",".join((base,) + subsegments)
580
 
 
581
 
 
582
 
def join_segment_parameters(url, parameters):
583
 
    """Create a new URL by adding segment parameters to an existing one.
584
 
 
585
 
    The parameters of the last segment in the URL will be updated; if a
586
 
    parameter with the same key already exists it will be overwritten.
587
 
 
588
 
    :param url: A URL, as string
589
 
    :param parameters: Dictionary of parameters, keys and values as bytestrings
590
 
    """
591
 
    (base, existing_parameters) = split_segment_parameters(url)
592
 
    new_parameters = {}
593
 
    new_parameters.update(existing_parameters)
594
 
    for key, value in parameters.items():
595
 
        if not isinstance(key, str):
596
 
            raise TypeError("parameter key %r is not a str" % key)
597
 
        if not isinstance(value, str):
598
 
            raise TypeError("parameter value %r for %s is not a str" %
599
 
                (key, value))
600
 
        if "=" in key:
601
 
            raise InvalidURLJoin("= exists in parameter key", url,
602
 
                parameters)
603
 
        new_parameters[key] = value
604
 
    return join_segment_parameters_raw(base,
605
 
        *["%s=%s" % item for item in sorted(new_parameters.items())])
606
 
 
607
 
 
608
466
def _win32_strip_local_trailing_slash(url):
609
467
    """Strip slashes after the drive letter"""
610
468
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
660
518
    This returns a Unicode path from a URL
661
519
    """
662
520
    # jam 20060427 URLs are supposed to be ASCII only strings
663
 
    #       If they are passed in as unicode, unquote
 
521
    #       If they are passed in as unicode, urllib.unquote
664
522
    #       will return a UNICODE string, which actually contains
665
523
    #       utf-8 bytes. So we have to ensure that they are
666
524
    #       plain ASCII strings, or the final .decode will
667
525
    #       try to encode the UNICODE => ASCII, and then decode
668
526
    #       it into utf-8.
669
 
    if isinstance(url, text_type):
670
 
        try:
671
 
            url = url.encode("ascii")
672
 
        except UnicodeError as e:
673
 
            raise InvalidURL(url, 'URL was not a plain ASCII url: %s' % (e,))
674
 
    if PY3:
675
 
        unquoted = urlparse.unquote_to_bytes(url)
676
 
    else:
677
 
        unquoted = unquote(url)
 
527
    try:
 
528
        url = str(url)
 
529
    except UnicodeError, e:
 
530
        raise errors.InvalidURL(url, 'URL was not a plain ASCII url: %s' % (e,))
 
531
 
 
532
    unquoted = urllib.unquote(url)
678
533
    try:
679
534
        unicode_path = unquoted.decode('utf-8')
680
 
    except UnicodeError as e:
681
 
        raise InvalidURL(url, 'Unable to encode the URL as utf-8: %s' % (e,))
 
535
    except UnicodeError, e:
 
536
        raise errors.InvalidURL(url, 'Unable to encode the URL as utf-8: %s' % (e,))
682
537
    return unicode_path
683
538
 
684
539
 
690
545
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
691
546
                    + [('%02X' % o, chr(o)) for o in range(256)]))
692
547
#These entries get mapped to themselves
693
 
_hex_display_map.update((hex, '%'+hex) for hex in _no_decode_hex)
 
548
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
694
549
 
695
550
# These characters shouldn't be percent-encoded, and it's always safe to
696
551
# unencode them if they are.
738
593
 
739
594
    # Split into sections to try to decode utf-8
740
595
    res = url.split('/')
741
 
    for i in range(1, len(res)):
 
596
    for i in xrange(1, len(res)):
742
597
        escaped_chunks = res[i].split('%')
743
 
        for j in range(1, len(escaped_chunks)):
 
598
        for j in xrange(1, len(escaped_chunks)):
744
599
            item = escaped_chunks[j]
745
600
            try:
746
601
                escaped_chunks[j] = _hex_display_map[item[:2]] + item[2:]
750
605
            except UnicodeDecodeError:
751
606
                escaped_chunks[j] = unichr(int(item[:2], 16)) + item[2:]
752
607
        unescaped = ''.join(escaped_chunks)
753
 
        if sys.version_info[0] == 2:
 
608
        try:
 
609
            decoded = unescaped.decode('utf-8')
 
610
        except UnicodeDecodeError:
 
611
            # If this path segment cannot be properly utf-8 decoded
 
612
            # after doing unescaping we will just leave it alone
 
613
            pass
 
614
        else:
754
615
            try:
755
 
                decoded = unescaped.decode('utf-8')
756
 
            except UnicodeDecodeError:
757
 
                # If this path segment cannot be properly utf-8 decoded
758
 
                # after doing unescaping we will just leave it alone
 
616
                decoded.encode(encoding)
 
617
            except UnicodeEncodeError:
 
618
                # If this chunk cannot be encoded in the local
 
619
                # encoding, then we should leave it alone
759
620
                pass
760
621
            else:
761
 
                try:
762
 
                    decoded.encode(encoding)
763
 
                except UnicodeEncodeError:
764
 
                    # If this chunk cannot be encoded in the local
765
 
                    # encoding, then we should leave it alone
766
 
                    pass
767
 
                else:
768
 
                    # Otherwise take the url decoded one
769
 
                    res[i] = decoded
770
 
        else:
771
 
            res[i] = unescaped
 
622
                # Otherwise take the url decoded one
 
623
                res[i] = decoded
772
624
    return u'/'.join(res)
773
625
 
774
626
 
811
663
    old_parsed = urlparse.urlparse(old_base)
812
664
    new_parsed = urlparse.urlparse(new_base)
813
665
    if (old_parsed[:2]) != (new_parsed[:2]):
814
 
        raise InvalidRebaseURLs(old_base, new_base)
 
666
        raise errors.InvalidRebaseURLs(old_base, new_base)
815
667
    return determine_relative_path(new_parsed[2],
816
668
                                   join(old_parsed[2], url))
817
669
 
835
687
    return osutils.pathjoin(*segments)
836
688
 
837
689
 
838
 
class URL(object):
839
 
    """Parsed URL."""
840
 
 
841
 
    def __init__(self, scheme, quoted_user, quoted_password, quoted_host,
842
 
            port, quoted_path):
843
 
        self.scheme = scheme
844
 
        self.quoted_host = quoted_host
845
 
        self.host = unquote(self.quoted_host)
846
 
        self.quoted_user = quoted_user
847
 
        if self.quoted_user is not None:
848
 
            self.user = unquote(self.quoted_user)
849
 
        else:
850
 
            self.user = None
851
 
        self.quoted_password = quoted_password
852
 
        if self.quoted_password is not None:
853
 
            self.password = unquote(self.quoted_password)
854
 
        else:
855
 
            self.password = None
856
 
        self.port = port
857
 
        self.quoted_path = _url_hex_escapes_re.sub(_unescape_safe_chars, quoted_path)
858
 
        self.path = unquote(self.quoted_path)
859
 
 
860
 
    def __eq__(self, other):
861
 
        return (isinstance(other, self.__class__) and
862
 
                self.scheme == other.scheme and
863
 
                self.host == other.host and
864
 
                self.user == other.user and
865
 
                self.password == other.password and
866
 
                self.path == other.path)
867
 
 
868
 
    def __repr__(self):
869
 
        return "<%s(%r, %r, %r, %r, %r, %r)>" % (
870
 
            self.__class__.__name__,
871
 
            self.scheme, self.quoted_user, self.quoted_password,
872
 
            self.quoted_host, self.port, self.quoted_path)
873
 
 
874
 
    @classmethod
875
 
    def from_string(cls, url):
876
 
        """Create a URL object from a string.
877
 
 
878
 
        :param url: URL as bytestring
879
 
        """
880
 
        # GZ 2017-06-09: Actually validate ascii-ness
881
 
        # pad.lv/1696545: For the moment, accept both native strings and unicode.
882
 
        if isinstance(url, str):
883
 
            pass
884
 
        elif isinstance(url, text_type):
885
 
            try:
886
 
                url = url.encode()
887
 
            except UnicodeEncodeError:
888
 
                raise InvalidURL(url)
889
 
        else:
890
 
            raise InvalidURL(url)
891
 
        (scheme, netloc, path, params,
892
 
         query, fragment) = urlparse.urlparse(url, allow_fragments=False)
893
 
        user = password = host = port = None
894
 
        if '@' in netloc:
895
 
            user, host = netloc.rsplit('@', 1)
896
 
            if ':' in user:
897
 
                user, password = user.split(':', 1)
898
 
        else:
899
 
            host = netloc
900
 
 
901
 
        if ':' in host and not (host[0] == '[' and host[-1] == ']'):
902
 
            # there *is* port
903
 
            host, port = host.rsplit(':', 1)
904
 
            try:
905
 
                port = int(port)
906
 
            except ValueError:
907
 
                raise InvalidURL('invalid port number %s in url:\n%s' %
908
 
                                 (port, url))
909
 
        if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
910
 
            host = host[1:-1]
911
 
 
912
 
        return cls(scheme, user, password, host, port, path)
913
 
 
914
 
    def __str__(self):
915
 
        netloc = self.quoted_host
916
 
        if ":" in netloc:
917
 
            netloc = "[%s]" % netloc
918
 
        if self.quoted_user is not None:
919
 
            # Note that we don't put the password back even if we
920
 
            # have one so that it doesn't get accidentally
921
 
            # exposed.
922
 
            netloc = '%s@%s' % (self.quoted_user, netloc)
923
 
        if self.port is not None:
924
 
            netloc = '%s:%d' % (netloc, self.port)
925
 
        return urlparse.urlunparse(
926
 
            (self.scheme, netloc, self.quoted_path, None, None, None))
927
 
 
928
 
    @staticmethod
929
 
    def _combine_paths(base_path, relpath):
930
 
        """Transform a Transport-relative path to a remote absolute path.
931
 
 
932
 
        This does not handle substitution of ~ but does handle '..' and '.'
933
 
        components.
934
 
 
935
 
        Examples::
936
 
 
937
 
            t._combine_paths('/home/sarah', 'project/foo')
938
 
                => '/home/sarah/project/foo'
939
 
            t._combine_paths('/home/sarah', '../../etc')
940
 
                => '/etc'
941
 
            t._combine_paths('/home/sarah', '/etc')
942
 
                => '/etc'
943
 
 
944
 
        :param base_path: base path
945
 
        :param relpath: relative url string for relative part of remote path.
946
 
        :return: urlencoded string for final path.
947
 
        """
948
 
        # pad.lv/1696545: For the moment, accept both native strings and unicode.
949
 
        if isinstance(relpath, str):
950
 
            pass
951
 
        elif isinstance(relpath, text_type):
952
 
            try:
953
 
                relpath = relpath.encode()
954
 
            except UnicodeEncodeError:
955
 
                raise InvalidURL(relpath)
956
 
        else:
957
 
            raise InvalidURL(relpath)
958
 
        relpath = _url_hex_escapes_re.sub(_unescape_safe_chars, relpath)
959
 
        if relpath.startswith('/'):
960
 
            base_parts = []
961
 
        else:
962
 
            base_parts = base_path.split('/')
963
 
        if len(base_parts) > 0 and base_parts[-1] == '':
964
 
            base_parts = base_parts[:-1]
965
 
        for p in relpath.split('/'):
966
 
            if p == '..':
967
 
                if len(base_parts) == 0:
968
 
                    # In most filesystems, a request for the parent
969
 
                    # of root, just returns root.
970
 
                    continue
971
 
                base_parts.pop()
972
 
            elif p == '.':
973
 
                continue # No-op
974
 
            elif p != '':
975
 
                base_parts.append(p)
976
 
        path = '/'.join(base_parts)
977
 
        if not path.startswith('/'):
978
 
            path = '/' + path
979
 
        return path
980
 
 
981
 
    def clone(self, offset=None):
982
 
        """Return a new URL for a path relative to this URL.
983
 
 
984
 
        :param offset: A relative path, already urlencoded
985
 
        :return: `URL` instance
986
 
        """
987
 
        if offset is not None:
988
 
            relative = unescape(offset)
989
 
            if sys.version_info[0] == 2:
990
 
                relative = relative.encode('utf-8')
991
 
            path = self._combine_paths(self.path, relative)
992
 
            path = quote(path, safe="/~")
993
 
        else:
994
 
            path = self.quoted_path
995
 
        return self.__class__(self.scheme, self.quoted_user,
996
 
                self.quoted_password, self.quoted_host, self.port,
997
 
                path)
998
 
 
999
690
 
1000
691
def parse_url(url):
1001
692
    """Extract the server address, the credentials and the path from the url.
1004
695
    chars.
1005
696
 
1006
697
    :param url: an quoted url
 
698
 
1007
699
    :return: (scheme, user, password, host, port, path) tuple, all fields
1008
700
        are unquoted.
1009
701
    """
1010
 
    parsed_url = URL.from_string(url)
1011
 
    return (parsed_url.scheme, parsed_url.user, parsed_url.password,
1012
 
        parsed_url.host, parsed_url.port, parsed_url.path)
 
702
    if isinstance(url, unicode):
 
703
        raise errors.InvalidURL('should be ascii:\n%r' % url)
 
704
    url = url.encode('utf-8')
 
705
    (scheme, netloc, path, params,
 
706
     query, fragment) = urlparse.urlparse(url, allow_fragments=False)
 
707
    user = password = host = port = None
 
708
    if '@' in netloc:
 
709
        user, host = netloc.rsplit('@', 1)
 
710
        if ':' in user:
 
711
            user, password = user.split(':', 1)
 
712
            password = urllib.unquote(password)
 
713
        user = urllib.unquote(user)
 
714
    else:
 
715
        host = netloc
 
716
 
 
717
    if ':' in host and not (host[0] == '[' and host[-1] == ']'): #there *is* port
 
718
        host, port = host.rsplit(':',1)
 
719
        try:
 
720
            port = int(port)
 
721
        except ValueError:
 
722
            raise errors.InvalidURL('invalid port number %s in url:\n%s' %
 
723
                                    (port, url))
 
724
    if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
 
725
        host = host[1:-1]
 
726
 
 
727
    host = urllib.unquote(host)
 
728
    path = urllib.unquote(path)
 
729
 
 
730
    return (scheme, user, password, host, port, path)