# Examples of Resolving Relative URLs

This document has an embedded base URL of

       Content-Base: http://a/b/c/d;p?q

the relative URLs should be resolved as shown below.

I will need your help testing the examples on multiple browsers. What you need to do is point to the example anchor and compare it to the resolved URL in your browser (most browsers have a feature by which you can see the resolved URL at the bottom of the window/screen when the anchor is active).

## Tested Clients and Client Libraries

[R]
  RFC 2396 (the right way to parse)
[X]
  RFC 1808
[1]
  Mozilla/4.03 [en] (X11; U; SunOS 5.5 sun4u; Nav)
[2]
  Lynx/2.7.1 libwww-FM/2.14
[3]
  MSIE 3.01; Windows 95
[4]
  NCSA_Mosaic/2.6 (X11;SunOS 4.1.2 sun4m) libwww/2.12
[5]
  libwww-perl/5.14 [Martijn Koster]

## Normal Examples

                  RESULTS                     from

    g:h        =  g:h                         [R,X,2,3,4,5]
                  http://a/b/c/g:h            [1]

    g          =  http://a/b/c/g              [R,X,1,2,3,4,5]

    ./g        =  http://a/b/c/g              [R,X,1,2,3,4,5]

    g/         =  http://a/b/c/g/             [R,X,1,2,3,4,5]

    /g         =  http://a/g                  [R,X,1,2,3,4,5]

    //g        =  http://g                    [R,X,1,2,3,4,5]

    ?y         =  http://a/b/c/d;p?y          [R,X,5]*Bug in RFC examples
                  http://a/b/c/?y             [1,2,3,4]

    g?y        =  http://a/b/c/g?y            [R,X,1,2,3,4,5]

    #s         =  (current document)#s        [R,2,4]
                  http://a/b/c/d;p?q#s        [X,1,3,5]

    g#s        =  http://a/b/c/g#s            [R,X,1,2,3,4,5]

    g?y#s      =  http://a/b/c/g?y#s          [R,X,1,2,3,4,5]

    ;x         =  http://a/b/c/;x             [R,1,2,3,4]
                  http://a/b/c/d;x            [X,5]

    g;x        =  http://a/b/c/g;x            [R,X,1,2,3,4,5]

    g;x?y#s    =  http://a/b/c/g;x?y#s        [R,X,1,2,3,4,5]

    .          =  http://a/b/c/               [R,X,2,5]
                  http://a/b/c/.              [1]
                  http://a/b/c                [3,4]

    ./         =  http://a/b/c/               [R,X,1,2,3,4,5]

    ..         =  http://a/b/                 [R,X,2,5]
                  http://a/b                  [1,3,4]

    ../        =  http://a/b/                 [R,X,1,2,3,4,5]

    ../g       =  http://a/b/g                [R,X,1,2,3,4,5]

    ../..      =  http://a/                   [R,X,2,5]
                  http://a                    [1,3,4]

    ../../     =  http://a/                   [R,X,1,2,3,4,5]

    ../../g    =  http://a/g                  [R,X,1,2,3,4,5]

## Abnormal Examples

Although the following abnormal examples are unlikely to occur in normal practice, all URL parsers should be capable of resolving them consistently. Each example uses the same base as above.

An empty reference refers to the start of the current document.

    <>         =  (current document)          [R,2,4]
                  http://a/b/c/d;p?q          [X,3,5]
                  http://a/b/c/               [1]

Parsers must be careful in handling the case where there are more relative path ".." segments than there are hierarchical levels in the base URL's path. Note that the ".." syntax cannot be used to change the site component of a URL.

    ../../../g    =  http://a/../g            [R,X,2,4,5]
                     http://a/g               [R,1,3]

    ../../../../g =  http://a/../../g         [R,X,2,4,5]
                     http://a/g               [R,1,3]

In practice, some implementations strip leading relative symbolic elements (".", "..") after applying a relative URL calculation, based on the theory that compensating for obvious author errors is better than allowing the request to fail. Thus, the above two references will be interpreted as "http://a/g" by some implementations.

Similarly, parsers must avoid treating "." and ".." as special when they are not complete components of a relative path.

    /./g      =  http://a/./g                 [R,X,2,3,4,5]
                 http://a/g                   [1]

    /../g     =  http://a/../g                [R,X,2,3,4,5]
                 http://a/g                   [1]

    g.        =  http://a/b/c/g.              [R,X,1,2,3,4,5]

    .g        =  http://a/b/c/.g              [R,X,1,2,3,4,5]

    g..       =  http://a/b/c/g..             [R,X,1,2,3,4,5]

    ..g       =  http://a/b/c/..g             [R,X,1,2,3,4,5]

Less likely are cases where the relative URL uses unnecessary or nonsensical forms of the "." and ".." complete path segments.

    ./../g     =  http://a/b/g                [R,X,1,2,5]
                  http://a/b/c/../g           [3,4]

    ./g/.      =  http://a/b/c/g/             [R,X,2,5]
                  http://a/b/c/g/.            [1]
                  http://a/b/c/g              [3,4]

    g/./h      =  http://a/b/c/g/h            [R,X,1,2,3,4,5]

    g/../h     =  http://a/b/c/h              [R,X,1,2,3,4,5]

    g;x=1/./y  =  http://a/b/c/g;x=1/y        [R,1,2,3,4]
                  http://a/b/c/g;x=1/./y      [X,5]

    g;x=1/../y =  http://a/b/c/y              [R,1,2,3,4]
                  http://a/b/c/g;x=1/../y     [X,5]

All client applications remove the query component from the base URL before resolving relative URLs. However, some applications fail to separate the reference's query and/or fragment components from a relative path before merging it with the base path. This error is rarely noticed, since typical usage of a fragment never includes the hierarchy ("/") character, and the query component is not normally used within relative references.

    g?y/./x    =  http://a/b/c/g?y/./x        [R,X,5]
                  http://a/b/c/g?y/x          [1,2,3,4]

    g?y/../x   =  http://a/b/c/g?y/../x       [R,X,5]
                  http://a/b/c/x              [1,2,3,4]

    g#s/./x    =  http://a/b/c/g#s/./x        [R,X,2,3,4,5]
                  http://a/b/c/g#s/x          [1]

    g#s/../x   =  http://a/b/c/g#s/../x       [R,X,2,3,4,5]
                  http://a/b/c/x              [1]

Some parsers allow the scheme name to be present in a relative URI if it is the same as the base URI scheme. This is considered to be a loophole in prior specifications of partial URI [RFC1630]. Its use should be avoided.

    http:g    =  http:g                       [R,X,5]
              |  http://a/b/c/g               [1,2,3,4]  (ok for compat.)

    http:     =  http:                        [R,X,5]
                 http://a/b/c/                [1]
                 http://a/b/c/d;p?q           [2,3,4]