1 2 3 4 5 6 7Network Working Group T. Berners-Lee 8Request for Comments: 2396 MIT/LCS 9Updates: 1808, 1738 R. Fielding 10Category: Standards Track U.C. Irvine 11 L. Masinter 12 Xerox Corporation 13 August 1998 14 15 16 Uniform Resource Identifiers (URI): Generic Syntax 17 18Status of this Memo 19 20 This document specifies an Internet standards track protocol for the 21 Internet community, and requests discussion and suggestions for 22 improvements. Please refer to the current edition of the "Internet 23 Official Protocol Standards" (STD 1) for the standardization state 24 and status of this protocol. Distribution of this memo is unlimited. 25 26Copyright Notice 27 28 Copyright (C) The Internet Society (1998). All Rights Reserved. 29 30IESG Note 31 32 This paper describes a "superset" of operations that can be applied 33 to URI. It consists of both a grammar and a description of basic 34 functionality for URI. To understand what is a valid URI, both the 35 grammar and the associated description have to be studied. Some of 36 the functionality described is not applicable to all URI schemes, and 37 some operations are only possible when certain media types are 38 retrieved using the URI, regardless of the scheme used. 39 40Abstract 41 42 A Uniform Resource Identifier (URI) is a compact string of characters 43 for identifying an abstract or physical resource. This document 44 defines the generic syntax of URI, including both absolute and 45 relative forms, and guidelines for their use; it revises and replaces 46 the generic definitions in RFC 1738 and RFC 1808. 47 48 This document defines a grammar that is a superset of all valid URI, 49 such that an implementation can parse the common components of a URI 50 reference without knowing the scheme-specific requirements of every 51 possible identifier type. This document does not define a generative 52 grammar for URI; that task will be performed by the individual 53 specifications of each URI scheme. 54 55 56 57 58Berners-Lee, et. al. Standards Track [Page 1] 59 60RFC 2396 URI Generic Syntax August 1998 61 62 631. Introduction 64 65 Uniform Resource Identifiers (URI) provide a simple and extensible 66 means for identifying a resource. This specification of URI syntax 67 and semantics is derived from concepts introduced by the World Wide 68 Web global information initiative, whose use of such objects dates 69 from 1990 and is described in "Universal Resource Identifiers in WWW" 70 [RFC1630]. The specification of URI is designed to meet the 71 recommendations laid out in "Functional Recommendations for Internet 72 Resource Locators" [RFC1736] and "Functional Requirements for Uniform 73 Resource Names" [RFC1737]. 74 75 This document updates and merges "Uniform Resource Locators" 76 [RFC1738] and "Relative Uniform Resource Locators" [RFC1808] in order 77 to define a single, generic syntax for all URI. It excludes those 78 portions of RFC 1738 that defined the specific syntax of individual 79 URL schemes; those portions will be updated as separate documents, as 80 will the process for registration of new URI schemes. This document 81 does not discuss the issues and recommendation for dealing with 82 characters outside of the US-ASCII character set [ASCII]; those 83 recommendations are discussed in a separate document. 84 85 All significant changes from the prior RFCs are noted in Appendix G. 86 871.1 Overview of URI 88 89 URI are characterized by the following definitions: 90 91 Uniform 92 Uniformity provides several benefits: it allows different types 93 of resource identifiers to be used in the same context, even 94 when the mechanisms used to access those resources may differ; 95 it allows uniform semantic interpretation of common syntactic 96 conventions across different types of resource identifiers; it 97 allows introduction of new types of resource identifiers 98 without interfering with the way that existing identifiers are 99 used; and, it allows the identifiers to be reused in many 100 different contexts, thus permitting new applications or 101 protocols to leverage a pre-existing, large, and widely-used 102 set of resource identifiers. 103 104 Resource 105 A resource can be anything that has identity. Familiar 106 examples include an electronic document, an image, a service 107 (e.g., "today's weather report for Los Angeles"), and a 108 collection of other resources. Not all resources are network 109 "retrievable"; e.g., human beings, corporations, and bound 110 books in a library can also be considered resources. 111 112 113 114Berners-Lee, et. al. Standards Track [Page 2] 115 116RFC 2396 URI Generic Syntax August 1998 117 118 119 The resource is the conceptual mapping to an entity or set of 120 entities, not necessarily the entity which corresponds to that 121 mapping at any particular instance in time. Thus, a resource 122 can remain constant even when its content---the entities to 123 which it currently corresponds---changes over time, provided 124 that the conceptual mapping is not changed in the process. 125 126 Identifier 127 An identifier is an object that can act as a reference to 128 something that has identity. In the case of URI, the object is 129 a sequence of characters with a restricted syntax. 130 131 Having identified a resource, a system may perform a variety of 132 operations on the resource, as might be characterized by such words 133 as `access', `update', `replace', or `find attributes'. 134 1351.2. URI, URL, and URN 136 137 A URI can be further classified as a locator, a name, or both. The 138 term "Uniform Resource Locator" (URL) refers to the subset of URI 139 that identify resources via a representation of their primary access 140 mechanism (e.g., their network "location"), rather than identifying 141 the resource by name or by some other attribute(s) of that resource. 142 The term "Uniform Resource Name" (URN) refers to the subset of URI 143 that are required to remain globally unique and persistent even when 144 the resource ceases to exist or becomes unavailable. 145 146 The URI scheme (Section 3.1) defines the namespace of the URI, and 147 thus may further restrict the syntax and semantics of identifiers 148 using that scheme. This specification defines those elements of the 149 URI syntax that are either required of all URI schemes or are common 150 to many URI schemes. It thus defines the syntax and semantics that 151 are needed to implement a scheme-independent parsing mechanism for 152 URI references, such that the scheme-dependent handling of a URI can 153 be postponed until the scheme-dependent semantics are needed. We use 154 the term URL below when describing syntax or semantics that only 155 apply to locators. 156 157 Although many URL schemes are named after protocols, this does not 158 imply that the only way to access the URL's resource is via the named 159 protocol. Gateways, proxies, caches, and name resolution services 160 might be used to access some resources, independent of the protocol 161 of their origin, and the resolution of some URL may require the use 162 of more than one protocol (e.g., both DNS and HTTP are typically used 163 to access an "http" URL's resource when it can't be found in a local 164 cache). 165 166 167 168 169 170Berners-Lee, et. al. Standards Track [Page 3] 171 172RFC 2396 URI Generic Syntax August 1998 173 174 175 A URN differs from a URL in that it's primary purpose is persistent 176 labeling of a resource with an identifier. That identifier is drawn 177 from one of a set of defined namespaces, each of which has its own 178 set name structure and assignment procedures. The "urn" scheme has 179 been reserved to establish the requirements for a standardized URN 180 namespace, as defined in "URN Syntax" [RFC2141] and its related 181 specifications. 182 183 Most of the examples in this specification demonstrate URL, since 184 they allow the most varied use of the syntax and often have a 185 hierarchical namespace. A parser of the URI syntax is capable of 186 parsing both URL and URN references as a generic URI; once the scheme 187 is determined, the scheme-specific parsing can be performed on the 188 generic URI components. In other words, the URI syntax is a superset 189 of the syntax of all URI schemes. 190 1911.3. Example URI 192 193 The following examples illustrate URI that are in common use. 194 195 ftp://ftp.is.co.za/rfc/rfc1808.txt 196 -- ftp scheme for File Transfer Protocol services 197 198 gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles 199 -- gopher scheme for Gopher and Gopher+ Protocol services 200 201 http://www.math.uio.no/faq/compression-faq/part1.html 202 -- http scheme for Hypertext Transfer Protocol services 203 204 mailto:mduerst@ifi.unizh.ch 205 -- mailto scheme for electronic mail addresses 206 207 news:comp.infosystems.www.servers.unix 208 -- news scheme for USENET news groups and articles 209 210 telnet://melvyl.ucop.edu/ 211 -- telnet scheme for interactive services via the TELNET Protocol 212 2131.4. Hierarchical URI and Relative Forms 214 215 An absolute identifier refers to a resource independent of the 216 context in which the identifier is used. In contrast, a relative 217 identifier refers to a resource by describing the difference within a 218 hierarchical namespace between the current context and an absolute 219 identifier of the resource. 220 221 222 223 224 225 226Berners-Lee, et. al. Standards Track [Page 4] 227 228RFC 2396 URI Generic Syntax August 1998 229 230 231 Some URI schemes support a hierarchical naming system, where the 232 hierarchy of the name is denoted by a "/" delimiter separating the 233 components in the scheme. This document defines a scheme-independent 234 `relative' form of URI reference that can be used in conjunction with 235 a `base' URI (of a hierarchical scheme) to produce another URI. The 236 syntax of hierarchical URI is described in Section 3; the relative 237 URI calculation is described in Section 5. 238 2391.5. URI Transcribability 240 241 The URI syntax was designed with global transcribability as one of 242 its main concerns. A URI is a sequence of characters from a very 243 limited set, i.e. the letters of the basic Latin alphabet, digits, 244 and a few special characters. A URI may be represented in a variety 245 of ways: e.g., ink on paper, pixels on a screen, or a sequence of 246 octets in a coded character set. The interpretation of a URI depends 247 only on the characters used and not how those characters are 248 represented in a network protocol. 249 250 The goal of transcribability can be described by a simple scenario. 251 Imagine two colleagues, Sam and Kim, sitting in a pub at an 252 international conference and exchanging research ideas. Sam asks Kim 253 for a location to get more information, so Kim writes the URI for the 254 research site on a napkin. Upon returning home, Sam takes out the 255 napkin and types the URI into a computer, which then retrieves the 256 information to which Kim referred. 257 258 There are several design concerns revealed by the scenario: 259 260 o A URI is a sequence of characters, which is not always 261 represented as a sequence of octets. 262 263 o A URI may be transcribed from a non-network source, and thus 264 should consist of characters that are most likely to be able to 265 be typed into a computer, within the constraints imposed by 266 keyboards (and related input devices) across languages and 267 locales. 268 269 o A URI often needs to be remembered by people, and it is easier 270 for people to remember a URI when it consists of meaningful 271 components. 272 273 These design concerns are not always in alignment. For example, it 274 is often the case that the most meaningful name for a URI component 275 would require characters that cannot be typed into some systems. The 276 ability to transcribe the resource identifier from one medium to 277 another was considered more important than having its URI consist of 278 the most meaningful of components. In local and regional contexts 279 280 281 282Berners-Lee, et. al. Standards Track [Page 5] 283 284RFC 2396 URI Generic Syntax August 1998 285 286 287 and with improving technology, users might benefit from being able to 288 use a wider range of characters; such use is not defined in this 289 document. 290 2911.6. Syntax Notation and Common Elements 292 293 This document uses two conventions to describe and define the syntax 294 for URI. The first, called the layout form, is a general description 295 of the order of components and component separators, as in 296 297 <first>/<second>;<third>?<fourth> 298 299 The component names are enclosed in angle-brackets and any characters 300 outside angle-brackets are literal separators. Whitespace should be 301 ignored. These descriptions are used informally and do not define 302 the syntax requirements. 303 304 The second convention is a BNF-like grammar, used to define the 305 formal URI syntax. The grammar is that of [RFC822], except that "|" 306 is used to designate alternatives. Briefly, rules are separated from 307 definitions by an equal "=", indentation is used to continue a rule 308 definition over more than one line, literals are quoted with "", 309 parentheses "(" and ")" are used to group elements, optional elements 310 are enclosed in "[" and "]" brackets, and elements may be preceded 311 with <n>* to designate n or more repetitions of the following 312 element; n defaults to 0. 313 314 Unlike many specifications that use a BNF-like grammar to define the 315 bytes (octets) allowed by a protocol, the URI grammar is defined in 316 terms of characters. Each literal in the grammar corresponds to the 317 character it represents, rather than to the octet encoding of that 318 character in any particular coded character set. How a URI is 319 represented in terms of bits and bytes on the wire is dependent upon 320 the character encoding of the protocol used to transport it, or the 321 charset of the document which contains it. 322 323 The following definitions are common to many elements: 324 325 alpha = lowalpha | upalpha 326 327 lowalpha = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | 328 "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | 329 "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" 330 331 upalpha = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | 332 "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | 333 "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" 334 335 336 337 338Berners-Lee, et. al. Standards Track [Page 6] 339 340RFC 2396 URI Generic Syntax August 1998 341 342 343 digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | 344 "8" | "9" 345 346 alphanum = alpha | digit 347 348 The complete URI syntax is collected in Appendix A. 349 3502. URI Characters and Escape Sequences 351 352 URI consist of a restricted set of characters, primarily chosen to 353 aid transcribability and usability both in computer systems and in 354 non-computer communications. Characters used conventionally as 355 delimiters around URI were excluded. The restricted set of 356 characters consists of digits, letters, and a few graphic symbols 357 were chosen from those common to most of the character encodings and 358 input facilities available to Internet users. 359 360 uric = reserved | unreserved | escaped 361 362 Within a URI, characters are either used as delimiters, or to 363 represent strings of data (octets) within the delimited portions. 364 Octets are either represented directly by a character (using the US- 365 ASCII character for that octet [ASCII]) or by an escape encoding. 366 This representation is elaborated below. 367 3682.1 URI and non-ASCII characters 369 370 The relationship between URI and characters has been a source of 371 confusion for characters that are not part of US-ASCII. To describe 372 the relationship, it is useful to distinguish between a "character" 373 (as a distinguishable semantic entity) and an "octet" (an 8-bit 374 byte). There are two mappings, one from URI characters to octets, and 375 a second from octets to original characters: 376 377 URI character sequence->octet sequence->original character sequence 378 379 A URI is represented as a sequence of characters, not as a sequence 380 of octets. That is because URI might be "transported" by means that 381 are not through a computer network, e.g., printed on paper, read over 382 the radio, etc. 383 384 A URI scheme may define a mapping from URI characters to octets; 385 whether this is done depends on the scheme. Commonly, within a 386 delimited component of a URI, a sequence of characters may be used to 387 represent a sequence of octets. For example, the character "a" 388 represents the octet 97 (decimal), while the character sequence "%", 389 "0", "a" represents the octet 10 (decimal). 390 391 392 393 394Berners-Lee, et. al. Standards Track [Page 7] 395 396RFC 2396 URI Generic Syntax August 1998 397 398 399 There is a second translation for some resources: the sequence of 400 octets defined by a component of the URI is subsequently used to 401 represent a sequence of characters. A 'charset' defines this mapping. 402 There are many charsets in use in Internet protocols. For example, 403 UTF-8 [UTF-8] defines a mapping from sequences of octets to sequences 404 of characters in the repertoire of ISO 10646. 405 406 In the simplest case, the original character sequence contains only 407 characters that are defined in US-ASCII, and the two levels of 408 mapping are simple and easily invertible: each 'original character' 409 is represented as the octet for the US-ASCII code for it, which is, 410 in turn, represented as either the US-ASCII character, or else the 411 "%" escape sequence for that octet. 412 413 For original character sequences that contain non-ASCII characters, 414 however, the situation is more difficult. Internet protocols that 415 transmit octet sequences intended to represent character sequences 416 are expected to provide some way of identifying the charset used, if 417 there might be more than one [RFC2277]. However, there is currently 418 no provision within the generic URI syntax to accomplish this 419 identification. An individual URI scheme may require a single 420 charset, define a default charset, or provide a way to indicate the 421 charset used. 422 423 It is expected that a systematic treatment of character encoding 424 within URI will be developed as a future modification of this 425 specification. 426 4272.2. Reserved Characters 428 429 Many URI include components consisting of or delimited by, certain 430 special characters. These characters are called "reserved", since 431 their usage within the URI component is limited to their reserved 432 purpose. If the data for a URI component would conflict with the 433 reserved purpose, then the conflicting data must be escaped before 434 forming the URI. 435 436 reserved = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | 437 "$" | "," 438 439 The "reserved" syntax class above refers to those characters that are 440 allowed within a URI, but which may not be allowed within a 441 particular component of the generic URI syntax; they are used as 442 delimiters of the components described in Section 3. 443 444 445 446 447 448 449 450Berners-Lee, et. al. Standards Track [Page 8] 451 452RFC 2396 URI Generic Syntax August 1998 453 454 455 Characters in the "reserved" set are not reserved in all contexts. 456 The set of characters actually reserved within any given URI 457 component is defined by that component. In general, a character is 458 reserved if the semantics of the URI changes if the character is 459 replaced with its escaped US-ASCII encoding. 460 4612.3. Unreserved Characters 462 463 Data characters that are allowed in a URI but do not have a reserved 464 purpose are called unreserved. These include upper and lower case 465 letters, decimal digits, and a limited set of punctuation marks and 466 symbols. 467 468 unreserved = alphanum | mark 469 470 mark = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")" 471 472 Unreserved characters can be escaped without changing the semantics 473 of the URI, but this should not be done unless the URI is being used 474 in a context that does not allow the unescaped character to appear. 475 4762.4. Escape Sequences 477 478 Data must be escaped if it does not have a representation using an 479 unreserved character; this includes data that does not correspond to 480 a printable character of the US-ASCII coded character set, or that 481 corresponds to any US-ASCII character that is disallowed, as 482 explained below. 483 4842.4.1. Escaped Encoding 485 486 An escaped octet is encoded as a character triplet, consisting of the 487 percent character "%" followed by the two hexadecimal digits 488 representing the octet code. For example, "%20" is the escaped 489 encoding for the US-ASCII space character. 490 491 escaped = "%" hex hex 492 hex = digit | "A" | "B" | "C" | "D" | "E" | "F" | 493 "a" | "b" | "c" | "d" | "e" | "f" 494 4952.4.2. When to Escape and Unescape 496 497 A URI is always in an "escaped" form, since escaping or unescaping a 498 completed URI might change its semantics. Normally, the only time 499 escape encodings can safely be made is when the URI is being created 500 from its component parts; each component may have its own set of 501 characters that are reserved, so only the mechanism responsible for 502 generating or interpreting that component can determine whether or 503 504 505 506Berners-Lee, et. al. Standards Track [Page 9] 507 508RFC 2396 URI Generic Syntax August 1998 509 510 511 not escaping a character will change its semantics. Likewise, a URI 512 must be separated into its components before the escaped characters 513 within those components can be safely decoded. 514 515 In some cases, data that could be represented by an unreserved 516 character may appear escaped; for example, some of the unreserved 517 "mark" characters are automatically escaped by some systems. If the 518 given URI scheme defines a canonicalization algorithm, then 519 unreserved characters may be unescaped according to that algorithm. 520 For example, "%7e" is sometimes used instead of "~" in an http URL 521 path, but the two are equivalent for an http URL. 522 523 Because the percent "%" character always has the reserved purpose of 524 being the escape indicator, it must be escaped as "%25" in order to 525 be used as data within a URI. Implementers should be careful not to 526 escape or unescape the same string more than once, since unescaping 527 an already unescaped string might lead to misinterpreting a percent 528 data character as another escaped character, or vice versa in the 529 case of escaping an already escaped string. 530 5312.4.3. Excluded US-ASCII Characters 532 533 Although they are disallowed within the URI syntax, we include here a 534 description of those US-ASCII characters that have been excluded and 535 the reasons for their exclusion. 536 537 The control characters in the US-ASCII coded character set are not 538 used within a URI, both because they are non-printable and because 539 they are likely to be misinterpreted by some control mechanisms. 540 541 control = <US-ASCII coded characters 00-1F and 7F hexadecimal> 542 543 The space character is excluded because significant spaces may 544 disappear and insignificant spaces may be introduced when URI are 545 transcribed or typeset or subjected to the treatment of word- 546 processing programs. Whitespace is also used to delimit URI in many 547 contexts. 548 549 space = <US-ASCII coded character 20 hexadecimal> 550 551 The angle-bracket "<" and ">" and double-quote (") characters are 552 excluded because they are often used as the delimiters around URI in 553 text documents and protocol fields. The character "#" is excluded 554 because it is used to delimit a URI from a fragment identifier in URI 555 references (Section 4). The percent character "%" is excluded because 556 it is used for the encoding of escaped characters. 557 558 delims = "<" | ">" | "#" | "%" | <"> 559 560 561 562Berners-Lee, et. al. Standards Track [Page 10] 563 564RFC 2396 URI Generic Syntax August 1998 565 566 567 Other characters are excluded because gateways and other transport 568 agents are known to sometimes modify such characters, or they are 569 used as delimiters. 570 571 unwise = "{" | "}" | "|" | "\" | "^" | "[" | "]" | "`" 572 573 Data corresponding to excluded characters must be escaped in order to 574 be properly represented within a URI. 575 5763. URI Syntactic Components 577 578 The URI syntax is dependent upon the scheme. In general, absolute 579 URI are written as follows: 580 581 <scheme>:<scheme-specific-part> 582 583 An absolute URI contains the name of the scheme being used (<scheme>) 584 followed by a colon (":") and then a string (the <scheme-specific- 585 part>) whose interpretation depends on the scheme. 586 587 The URI syntax does not require that the scheme-specific-part have 588 any general structure or set of semantics which is common among all 589 URI. However, a subset of URI do share a common syntax for 590 representing hierarchical relationships within the namespace. This 591 "generic URI" syntax consists of a sequence of four main components: 592 593 <scheme>://<authority><path>?<query> 594 595 each of which, except <scheme>, may be absent from a particular URI. 596 For example, some URI schemes do not allow an <authority> component, 597 and others do not use a <query> component. 598 599 absoluteURI = scheme ":" ( hier_part | opaque_part ) 600 601 URI that are hierarchical in nature use the slash "/" character for 602 separating hierarchical components. For some file systems, a "/" 603 character (used to denote the hierarchical structure of a URI) is the 604 delimiter used to construct a file name hierarchy, and thus the URI 605 path will look similar to a file pathname. This does NOT imply that 606 the resource is a file or that the URI maps to an actual filesystem 607 pathname. 608 609 hier_part = ( net_path | abs_path ) [ "?" query ] 610 611 net_path = "//" authority [ abs_path ] 612 613 abs_path = "/" path_segments 614 615 616 617 618Berners-Lee, et. al. Standards Track [Page 11] 619 620RFC 2396 URI Generic Syntax August 1998 621 622 623 URI that do not make use of the slash "/" character for separating 624 hierarchical components are considered opaque by the generic URI 625 parser. 626 627 opaque_part = uric_no_slash *uric 628 629 uric_no_slash = unreserved | escaped | ";" | "?" | ":" | "@" | 630 "&" | "=" | "+" | "$" | "," 631 632 We use the term <path> to refer to both the <abs_path> and 633 <opaque_part> constructs, since they are mutually exclusive for any 634 given URI and can be parsed as a single component. 635 6363.1. Scheme Component 637 638 Just as there are many different methods of access to resources, 639 there are a variety of schemes for identifying such resources. The 640 URI syntax consists of a sequence of components separated by reserved 641 characters, with the first component defining the semantics for the 642 remainder of the URI string. 643 644 Scheme names consist of a sequence of characters beginning with a 645 lower case letter and followed by any combination of lower case 646 letters, digits, plus ("+"), period ("."), or hyphen ("-"). For 647 resiliency, programs interpreting URI should treat upper case letters 648 as equivalent to lower case in scheme names (e.g., allow "HTTP" as 649 well as "http"). 650 651 scheme = alpha *( alpha | digit | "+" | "-" | "." ) 652 653 Relative URI references are distinguished from absolute URI in that 654 they do not begin with a scheme name. Instead, the scheme is 655 inherited from the base URI, as described in Section 5.2. 656 6573.2. Authority Component 658 659 Many URI schemes include a top hierarchical element for a naming 660 authority, such that the namespace defined by the remainder of the 661 URI is governed by that authority. This authority component is 662 typically defined by an Internet-based server or a scheme-specific 663 registry of naming authorities. 664 665 authority = server | reg_name 666 667 The authority component is preceded by a double slash "//" and is 668 terminated by the next slash "/", question-mark "?", or by the end of 669 the URI. Within the authority component, the characters ";", ":", 670 "@", "?", and "/" are reserved. 671 672 673 674Berners-Lee, et. al. Standards Track [Page 12] 675 676RFC 2396 URI Generic Syntax August 1998 677 678 679 An authority component is not required for a URI scheme to make use 680 of relative references. A base URI without an authority component 681 implies that any relative reference will also be without an authority 682 component. 683 6843.2.1. Registry-based Naming Authority 685 686 The structure of a registry-based naming authority is specific to the 687 URI scheme, but constrained to the allowed characters for an 688 authority component. 689 690 reg_name = 1*( unreserved | escaped | "$" | "," | 691 ";" | ":" | "@" | "&" | "=" | "+" ) 692 6933.2.2. Server-based Naming Authority 694 695 URL schemes that involve the direct use of an IP-based protocol to a 696 specified server on the Internet use a common syntax for the server 697 component of the URI's scheme-specific data: 698 699 <userinfo>@<host>:<port> 700 701 where <userinfo> may consist of a user name and, optionally, scheme- 702 specific information about how to gain authorization to access the 703 server. The parts "<userinfo>@" and ":<port>" may be omitted. 704 705 server = [ [ userinfo "@" ] hostport ] 706 707 The user information, if present, is followed by a commercial at-sign 708 "@". 709 710 userinfo = *( unreserved | escaped | 711 ";" | ":" | "&" | "=" | "+" | "$" | "," ) 712 713 Some URL schemes use the format "user:password" in the userinfo 714 field. This practice is NOT RECOMMENDED, because the passing of 715 authentication information in clear text (such as URI) has proven to 716 be a security risk in almost every case where it has been used. 717 718 The host is a domain name of a network host, or its IPv4 address as a 719 set of four decimal digit groups separated by ".". Literal IPv6 720 addresses are not supported. 721 722 hostport = host [ ":" port ] 723 host = hostname | IPv4address 724 hostname = *( domainlabel "." ) toplabel [ "." ] 725 domainlabel = alphanum | alphanum *( alphanum | "-" ) alphanum 726 toplabel = alpha | alpha *( alphanum | "-" ) alphanum 727 728 729 730Berners-Lee, et. al. Standards Track [Page 13] 731 732RFC 2396 URI Generic Syntax August 1998 733 734 735 IPv4address = 1*digit "." 1*digit "." 1*digit "." 1*digit 736 port = *digit 737 738 Hostnames take the form described in Section 3 of [RFC1034] and 739 Section 2.1 of [RFC1123]: a sequence of domain labels separated by 740 ".", each domain label starting and ending with an alphanumeric 741 character and possibly also containing "-" characters. The rightmost 742 domain label of a fully qualified domain name will never start with a 743 digit, thus syntactically distinguishing domain names from IPv4 744 addresses, and may be followed by a single "." if it is necessary to 745 distinguish between the complete domain name and any local domain. 746 To actually be "Uniform" as a resource locator, a URL hostname should 747 be a fully qualified domain name. In practice, however, the host 748 component may be a local domain literal. 749 750 Note: A suitable representation for including a literal IPv6 751 address as the host part of a URL is desired, but has not yet been 752 determined or implemented in practice. 753 754 The port is the network port number for the server. Most schemes 755 designate protocols that have a default port number. Another port 756 number may optionally be supplied, in decimal, separated from the 757 host by a colon. If the port is omitted, the default port number is 758 assumed. 759 7603.3. Path Component 761 762 The path component contains data, specific to the authority (or the 763 scheme if there is no authority component), identifying the resource 764 within the scope of that scheme and authority. 765 766 path = [ abs_path | opaque_part ] 767 768 path_segments = segment *( "/" segment ) 769 segment = *pchar *( ";" param ) 770 param = *pchar 771 772 pchar = unreserved | escaped | 773 ":" | "@" | "&" | "=" | "+" | "$" | "," 774 775 The path may consist of a sequence of path segments separated by a 776 single slash "/" character. Within a path segment, the characters 777 "/", ";", "=", and "?" are reserved. Each path segment may include a 778 sequence of parameters, indicated by the semicolon ";" character. 779 The parameters are not significant to the parsing of relative 780 references. 781 782 783 784 785 786Berners-Lee, et. al. Standards Track [Page 14] 787 788RFC 2396 URI Generic Syntax August 1998 789 790 7913.4. Query Component 792 793 The query component is a string of information to be interpreted by 794 the resource. 795 796 query = *uric 797 798 Within a query component, the characters ";", "/", "?", ":", "@", 799 "&", "=", "+", ",", and "$" are reserved. 800 8014. URI References 802 803 The term "URI-reference" is used here to denote the common usage of a 804 resource identifier. A URI reference may be absolute or relative, 805 and may have additional information attached in the form of a 806 fragment identifier. However, "the URI" that results from such a 807 reference includes only the absolute URI after the fragment 808 identifier (if any) is removed and after any relative URI is resolved 809 to its absolute form. Although it is possible to limit the 810 discussion of URI syntax and semantics to that of the absolute 811 result, most usage of URI is within general URI references, and it is 812 impossible to obtain the URI from such a reference without also 813 parsing the fragment and resolving the relative form. 814 815 URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ] 816 817 The syntax for relative URI is a shortened form of that for absolute 818 URI, where some prefix of the URI is missing and certain path 819 components ("." and "..") have a special meaning when, and only when, 820 interpreting a relative path. The relative URI syntax is defined in 821 Section 5. 822 8234.1. Fragment Identifier 824 825 When a URI reference is used to perform a retrieval action on the 826 identified resource, the optional fragment identifier, separated from 827 the URI by a crosshatch ("#") character, consists of additional 828 reference information to be interpreted by the user agent after the 829 retrieval action has been successfully completed. As such, it is not 830 part of a URI, but is often used in conjunction with a URI. 831 832 fragment = *uric 833 834 The semantics of a fragment identifier is a property of the data 835 resulting from a retrieval action, regardless of the type of URI used 836 in the reference. Therefore, the format and interpretation of 837 fragment identifiers is dependent on the media type [RFC2046] of the 838 retrieval result. The character restrictions described in Section 2 839 840 841 842Berners-Lee, et. al. Standards Track [Page 15] 843 844RFC 2396 URI Generic Syntax August 1998 845 846 847 for URI also apply to the fragment in a URI-reference. Individual 848 media types may define additional restrictions or structure within 849 the fragment for specifying different types of "partial views" that 850 can be identified within that media type. 851 852 A fragment identifier is only meaningful when a URI reference is 853 intended for retrieval and the result of that retrieval is a document 854 for which the identified fragment is consistently defined. 855 8564.2. Same-document References 857 858 A URI reference that does not contain a URI is a reference to the 859 current document. In other words, an empty URI reference within a 860 document is interpreted as a reference to the start of that document, 861 and a reference containing only a fragment identifier is a reference 862 to the identified fragment of that document. Traversal of such a 863 reference should not result in an additional retrieval action. 864 However, if the URI reference occurs in a context that is always 865 intended to result in a new request, as in the case of HTML's FORM 866 element, then an empty URI reference represents the base URI of the 867 current document and should be replaced by that URI when transformed 868 into a request. 869 8704.3. Parsing a URI Reference 871 872 A URI reference is typically parsed according to the four main 873 components and fragment identifier in order to determine what 874 components are present and whether the reference is relative or 875 absolute. The individual components are then parsed for their 876 subparts and, if not opaque, to verify their validity. 877 878 Although the BNF defines what is allowed in each component, it is 879 ambiguous in terms of differentiating between an authority component 880 and a path component that begins with two slash characters. The 881 greedy algorithm is used for disambiguation: the left-most matching 882 rule soaks up as much of the URI reference string as it is capable of 883 matching. In other words, the authority component wins. 884 885 Readers familiar with regular expressions should see Appendix B for a 886 concrete parsing example and test oracle. 887 8885. Relative URI References 889 890 It is often the case that a group or "tree" of documents has been 891 constructed to serve a common purpose; the vast majority of URI in 892 these documents point to resources within the tree rather than 893 894 895 896 897 898Berners-Lee, et. al. Standards Track [Page 16] 899 900RFC 2396 URI Generic Syntax August 1998 901 902 903 outside of it. Similarly, documents located at a particular site are 904 much more likely to refer to other resources at that site than to 905 resources at remote sites. 906 907 Relative addressing of URI allows document trees to be partially 908 independent of their location and access scheme. For instance, it is 909 possible for a single set of hypertext documents to be simultaneously 910 accessible and traversable via each of the "file", "http", and "ftp" 911 schemes if the documents refer to each other using relative URI. 912 Furthermore, such document trees can be moved, as a whole, without 913 changing any of the relative references. Experience within the WWW 914 has demonstrated that the ability to perform relative referencing is 915 necessary for the long-term usability of embedded URI. 916 917 The syntax for relative URI takes advantage of the <hier_part> syntax 918 of <absoluteURI> (Section 3) in order to express a reference that is 919 relative to the namespace of another hierarchical URI. 920 921 relativeURI = ( net_path | abs_path | rel_path ) [ "?" query ] 922 923 A relative reference beginning with two slash characters is termed a 924 network-path reference, as defined by <net_path> in Section 3. Such 925 references are rarely used. 926 927 A relative reference beginning with a single slash character is 928 termed an absolute-path reference, as defined by <abs_path> in 929 Section 3. 930 931 A relative reference that does not begin with a scheme name or a 932 slash character is termed a relative-path reference. 933 934 rel_path = rel_segment [ abs_path ] 935 936 rel_segment = 1*( unreserved | escaped | 937 ";" | "@" | "&" | "=" | "+" | "$" | "," ) 938 939 Within a relative-path reference, the complete path segments "." and 940 ".." have special meanings: "the current hierarchy level" and "the 941 level above this hierarchy level", respectively. Although this is 942 very similar to their use within Unix-based filesystems to indicate 943 directory levels, these path components are only considered special 944 when resolving a relative-path reference to its absolute form 945 (Section 5.2). 946 947 Authors should be aware that a path segment which contains a colon 948 character cannot be used as the first segment of a relative URI path 949 (e.g., "this:that"), because it would be mistaken for a scheme name. 950 951 952 953 954Berners-Lee, et. al. Standards Track [Page 17] 955 956RFC 2396 URI Generic Syntax August 1998 957 958 959 It is therefore necessary to precede such segments with other 960 segments (e.g., "./this:that") in order for them to be referenced as 961 a relative path. 962 963 It is not necessary for all URI within a given scheme to be 964 restricted to the <hier_part> syntax, since the hierarchical 965 properties of that syntax are only necessary when relative URI are 966 used within a particular document. Documents can only make use of 967 relative URI when their base URI fits within the <hier_part> syntax. 968 It is assumed that any document which contains a relative reference 969 will also have a base URI that obeys the syntax. In other words, 970 relative URI cannot be used within a document that has an unsuitable 971 base URI. 972 973 Some URI schemes do not allow a hierarchical syntax matching the 974 <hier_part> syntax, and thus cannot use relative references. 975 9765.1. Establishing a Base URI 977 978 The term "relative URI" implies that there exists some absolute "base 979 URI" against which the relative reference is applied. Indeed, the 980 base URI is necessary to define the semantics of any relative URI 981 reference; without it, a relative reference is meaningless. In order 982 for relative URI to be usable within a document, the base URI of that 983 document must be known to the parser. 984 985 The base URI of a document can be established in one of four ways, 986 listed below in order of precedence. The order of precedence can be 987 thought of in terms of layers, where the innermost defined base URI 988 has the highest precedence. This can be visualized graphically as: 989 990 .----------------------------------------------------------. 991 | .----------------------------------------------------. | 992 | | .----------------------------------------------. | | 993 | | | .----------------------------------------. | | | 994 | | | | .----------------------------------. | | | | 995 | | | | | <relative_reference> | | | | | 996 | | | | `----------------------------------' | | | | 997 | | | | (5.1.1) Base URI embedded in the | | | | 998 | | | | document's content | | | | 999 | | | `----------------------------------------' | | | 1000 | | | (5.1.2) Base URI of the encapsulating entity | | | 1001 | | | (message, document, or none). | | | 1002 | | `----------------------------------------------' | | 1003 | | (5.1.3) URI used to retrieve the entity | | 1004 | `----------------------------------------------------' | 1005 | (5.1.4) Default Base URI is application-dependent | 1006 `----------------------------------------------------------' 1007 1008 1009 1010Berners-Lee, et. al. Standards Track [Page 18] 1011 1012RFC 2396 URI Generic Syntax August 1998 1013 1014 10155.1.1. Base URI within Document Content 1016 1017 Within certain document media types, the base URI of the document can 1018 be embedded within the content itself such that it can be readily 1019 obtained by a parser. This can be useful for descriptive documents, 1020 such as tables of content, which may be transmitted to others through 1021 protocols other than their usual retrieval context (e.g., E-Mail or 1022 USENET news). 1023 1024 It is beyond the scope of this document to specify how, for each 1025 media type, the base URI can be embedded. It is assumed that user 1026 agents manipulating such media types will be able to obtain the 1027 appropriate syntax from that media type's specification. An example 1028 of how the base URI can be embedded in the Hypertext Markup Language 1029 (HTML) [RFC1866] is provided in Appendix D. 1030 1031 A mechanism for embedding the base URI within MIME container types 1032 (e.g., the message and multipart types) is defined by MHTML 1033 [RFC2110]. Protocols that do not use the MIME message header syntax, 1034 but which do allow some form of tagged metainformation to be included 1035 within messages, may define their own syntax for defining the base 1036 URI as part of a message. 1037 10385.1.2. Base URI from the Encapsulating Entity 1039 1040 If no base URI is embedded, the base URI of a document is defined by 1041 the document's retrieval context. For a document that is enclosed 1042 within another entity (such as a message or another document), the 1043 retrieval context is that entity; thus, the default base URI of the 1044 document is the base URI of the entity in which the document is 1045 encapsulated. 1046 10475.1.3. Base URI from the Retrieval URI 1048 1049 If no base URI is embedded and the document is not encapsulated 1050 within some other entity (e.g., the top level of a composite entity), 1051 then, if a URI was used to retrieve the base document, that URI shall 1052 be considered the base URI. Note that if the retrieval was the 1053 result of a redirected request, the last URI used (i.e., that which 1054 resulted in the actual retrieval of the document) is the base URI. 1055 10565.1.4. Default Base URI 1057 1058 If none of the conditions described in Sections 5.1.1--5.1.3 apply, 1059 then the base URI is defined by the context of the application. 1060 Since this definition is necessarily application-dependent, failing 1061 1062 1063 1064 1065 1066Berners-Lee, et. al. Standards Track [Page 19] 1067 1068RFC 2396 URI Generic Syntax August 1998 1069 1070 1071 to define the base URI using one of the other methods may result in 1072 the same content being interpreted differently by different types of 1073 application. 1074 1075 It is the responsibility of the distributor(s) of a document 1076 containing relative URI to ensure that the base URI for that document 1077 can be established. It must be emphasized that relative URI cannot 1078 be used reliably in situations where the document's base URI is not 1079 well-defined. 1080 10815.2. Resolving Relative References to Absolute Form 1082 1083 This section describes an example algorithm for resolving URI 1084 references that might be relative to a given base URI. 1085 1086 The base URI is established according to the rules of Section 5.1 and 1087 parsed into the four main components as described in Section 3. Note 1088 that only the scheme component is required to be present in the base 1089 URI; the other components may be empty or undefined. A component is 1090 undefined if its preceding separator does not appear in the URI 1091 reference; the path component is never undefined, though it may be 1092 empty. The base URI's query component is not used by the resolution 1093 algorithm and may be discarded. 1094 1095 For each URI reference, the following steps are performed in order: 1096 1097 1) The URI reference is parsed into the potential four components and 1098 fragment identifier, as described in Section 4.3. 1099 1100 2) If the path component is empty and the scheme, authority, and 1101 query components are undefined, then it is a reference to the 1102 current document and we are done. Otherwise, the reference URI's 1103 query and fragment components are defined as found (or not found) 1104 within the URI reference and not inherited from the base URI. 1105 1106 3) If the scheme component is defined, indicating that the reference 1107 starts with a scheme name, then the reference is interpreted as an 1108 absolute URI and we are done. Otherwise, the reference URI's 1109 scheme is inherited from the base URI's scheme component. 1110 1111 Due to a loophole in prior specifications [RFC1630], some parsers 1112 allow the scheme name to be present in a relative URI if it is the 1113 same as the base URI scheme. Unfortunately, this can conflict 1114 with the correct parsing of non-hierarchical URI. For backwards 1115 compatibility, an implementation may work around such references 1116 by removing the scheme if it matches that of the base URI and the 1117 scheme is known to always use the <hier_part> syntax. The parser 1118 1119 1120 1121 1122Berners-Lee, et. al. Standards Track [Page 20] 1123 1124RFC 2396 URI Generic Syntax August 1998 1125 1126 1127 can then continue with the steps below for the remainder of the 1128 reference components. Validating parsers should mark such a 1129 misformed relative reference as an error. 1130 1131 4) If the authority component is defined, then the reference is a 1132 network-path and we skip to step 7. Otherwise, the reference 1133 URI's authority is inherited from the base URI's authority 1134 component, which will also be undefined if the URI scheme does not 1135 use an authority component. 1136 1137 5) If the path component begins with a slash character ("/"), then 1138 the reference is an absolute-path and we skip to step 7. 1139 1140 6) If this step is reached, then we are resolving a relative-path 1141 reference. The relative path needs to be merged with the base 1142 URI's path. Although there are many ways to do this, we will 1143 describe a simple method using a separate string buffer. 1144 1145 a) All but the last segment of the base URI's path component is 1146 copied to the buffer. In other words, any characters after the 1147 last (right-most) slash character, if any, are excluded. 1148 1149 b) The reference's path component is appended to the buffer 1150 string. 1151 1152 c) All occurrences of "./", where "." is a complete path segment, 1153 are removed from the buffer string. 1154 1155 d) If the buffer string ends with "." as a complete path segment, 1156 that "." is removed. 1157 1158 e) All occurrences of "<segment>/../", where <segment> is a 1159 complete path segment not equal to "..", are removed from the 1160 buffer string. Removal of these path segments is performed 1161 iteratively, removing the leftmost matching pattern on each 1162 iteration, until no matching pattern remains. 1163 1164 f) If the buffer string ends with "<segment>/..", where <segment> 1165 is a complete path segment not equal to "..", that 1166 "<segment>/.." is removed. 1167 1168 g) If the resulting buffer string still begins with one or more 1169 complete path segments of "..", then the reference is 1170 considered to be in error. Implementations may handle this 1171 error by retaining these components in the resolved path (i.e., 1172 treating them as part of the final URI), by removing them from 1173 the resolved path (i.e., discarding relative levels above the 1174 root), or by avoiding traversal of the reference. 1175 1176 1177 1178Berners-Lee, et. al. Standards Track [Page 21] 1179 1180RFC 2396 URI Generic Syntax August 1998 1181 1182 1183 h) The remaining buffer string is the reference URI's new path 1184 component. 1185 1186 7) The resulting URI components, including any inherited from the 1187 base URI, are recombined to give the absolute form of the URI 1188 reference. Using pseudocode, this would be 1189 1190 result = "" 1191 1192 if scheme is defined then 1193 append scheme to result 1194 append ":" to result 1195 1196 if authority is defined then 1197 append "//" to result 1198 append authority to result 1199 1200 append path to result 1201 1202 if query is defined then 1203 append "?" to result 1204 append query to result 1205 1206 if fragment is defined then 1207 append "#" to result 1208 append fragment to result 1209 1210 return result 1211 1212 Note that we must be careful to preserve the distinction between a 1213 component that is undefined, meaning that its separator was not 1214 present in the reference, and a component that is empty, meaning 1215 that the separator was present and was immediately followed by the 1216 next component separator or the end of the reference. 1217 1218 The above algorithm is intended to provide an example by which the 1219 output of implementations can be tested -- implementation of the 1220 algorithm itself is not required. For example, some systems may find 1221 it more efficient to implement step 6 as a pair of segment stacks 1222 being merged, rather than as a series of string pattern replacements. 1223 1224 Note: Some WWW client applications will fail to separate the 1225 reference's query component from its path component before merging 1226 the base and reference paths in step 6 above. This may result in 1227 a loss of information if the query component contains the strings 1228 "/../" or "/./". 1229 1230 Resolution examples are provided in Appendix C. 1231 1232 1233 1234Berners-Lee, et. al. Standards Track [Page 22] 1235 1236RFC 2396 URI Generic Syntax August 1998 1237 1238 12396. URI Normalization and Equivalence 1240 1241 In many cases, different URI strings may actually identify the 1242 identical resource. For example, the host names used in URL are 1243 actually case insensitive, and the URL <http://www.XEROX.com> is 1244 equivalent to <http://www.xerox.com>. In general, the rules for 1245 equivalence and definition of a normal form, if any, are scheme 1246 dependent. When a scheme uses elements of the common syntax, it will 1247 also use the common syntax equivalence rules, namely that the scheme 1248 and hostname are case insensitive and a URL with an explicit ":port", 1249 where the port is the default for the scheme, is equivalent to one 1250 where the port is elided. 1251 12527. Security Considerations 1253 1254 A URI does not in itself pose a security threat. Users should beware 1255 that there is no general guarantee that a URL, which at one time 1256 located a given resource, will continue to do so. Nor is there any 1257 guarantee that a URL will not locate a different resource at some 1258 later point in time, due to the lack of any constraint on how a given 1259 authority apportions its namespace. Such a guarantee can only be 1260 obtained from the person(s) controlling that namespace and the 1261 resource in question. A specific URI scheme may include additional 1262 semantics, such as name persistence, if those semantics are required 1263 of all naming authorities for that scheme. 1264 1265 It is sometimes possible to construct a URL such that an attempt to 1266 perform a seemingly harmless, idempotent operation, such as the 1267 retrieval of an entity associated with the resource, will in fact 1268 cause a possibly damaging remote operation to occur. The unsafe URL 1269 is typically constructed by specifying a port number other than that 1270 reserved for the network protocol in question. The client 1271 unwittingly contacts a site that is in fact running a different 1272 protocol. The content of the URL contains instructions that, when 1273 interpreted according to this other protocol, cause an unexpected 1274 operation. An example has been the use of a gopher URL to cause an 1275 unintended or impersonating message to be sent via a SMTP server. 1276 1277 Caution should be used when using any URL that specifies a port 1278 number other than the default for the protocol, especially when it is 1279 a number within the reserved space. 1280 1281 Care should be taken when a URL contains escaped delimiters for a 1282 given protocol (for example, CR and LF characters for telnet 1283 protocols) that these are not unescaped before transmission. This 1284 might violate the protocol, but avoids the potential for such 1285 1286 1287 1288 1289 1290Berners-Lee, et. al. Standards Track [Page 23] 1291 1292RFC 2396 URI Generic Syntax August 1998 1293 1294 1295 characters to be used to simulate an extra operation or parameter in 1296 that protocol, which might lead to an unexpected and possibly harmful 1297 remote operation to be performed. 1298 1299 It is clearly unwise to use a URL that contains a password which is 1300 intended to be secret. In particular, the use of a password within 1301 the 'userinfo' component of a URL is strongly disrecommended except 1302 in those rare cases where the 'password' parameter is intended to be 1303 public. 1304 13058. Acknowledgements 1306 1307 This document was derived from RFC 1738 [RFC1738] and RFC 1808 1308 [RFC1808]; the acknowledgements in those specifications still apply. 1309 In addition, contributions by Gisle Aas, Martin Beet, Martin Duerst, 1310 Jim Gettys, Martijn Koster, Dave Kristol, Daniel LaLiberte, Foteos 1311 Macrides, James Marshall, Ryan Moats, Keith Moore, and Lauren Wood 1312 are gratefully acknowledged. 1313 13149. References 1315 1316 [RFC2277] Alvestrand, H., "IETF Policy on Character Sets and 1317 Languages", BCP 18, RFC 2277, January 1998. 1318 1319 [RFC1630] Berners-Lee, T., "Universal Resource Identifiers in WWW: A 1320 Unifying Syntax for the Expression of Names and Addresses 1321 of Objects on the Network as used in the World-Wide Web", 1322 RFC 1630, June 1994. 1323 1324 [RFC1738] Berners-Lee, T., Masinter, L., and M. McCahill, Editors, 1325 "Uniform Resource Locators (URL)", RFC 1738, December 1994. 1326 1327 [RFC1866] Berners-Lee T., and D. Connolly, "HyperText Markup Language 1328 Specification -- 2.0", RFC 1866, November 1995. 1329 1330 [RFC1123] Braden, R., Editor, "Requirements for Internet Hosts -- 1331 Application and Support", STD 3, RFC 1123, October 1989. 1332 1333 [RFC822] Crocker, D., "Standard for the Format of ARPA Internet Text 1334 Messages", STD 11, RFC 822, August 1982. 1335 1336 [RFC1808] Fielding, R., "Relative Uniform Resource Locators", RFC 1337 1808, June 1995. 1338 1339 [RFC2046] Freed, N., and N. Borenstein, "Multipurpose Internet Mail 1340 Extensions (MIME) Part Two: Media Types", RFC 2046, 1341 November 1996. 1342 1343 1344 1345 1346Berners-Lee, et. al. Standards Track [Page 24] 1347 1348RFC 2396 URI Generic Syntax August 1998 1349 1350 1351 [RFC1736] Kunze, J., "Functional Recommendations for Internet 1352 Resource Locators", RFC 1736, February 1995. 1353 1354 [RFC2141] Moats, R., "URN Syntax", RFC 2141, May 1997. 1355 1356 [RFC1034] Mockapetris, P., "Domain Names - Concepts and Facilities", 1357 STD 13, RFC 1034, November 1987. 1358 1359 [RFC2110] Palme, J., and A. Hopmann, "MIME E-mail Encapsulation of 1360 Aggregate Documents, such as HTML (MHTML)", RFC 2110, March 1361 1997. 1362 1363 [RFC1737] Sollins, K., and L. Masinter, "Functional Requirements for 1364 Uniform Resource Names", RFC 1737, December 1994. 1365 1366 [ASCII] US-ASCII. "Coded Character Set -- 7-bit American Standard 1367 Code for Information Interchange", ANSI X3.4-1986. 1368 1369 [UTF-8] Yergeau, F., "UTF-8, a transformation format of ISO 10646", 1370 RFC 2279, January 1998. 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402Berners-Lee, et. al. Standards Track [Page 25] 1403 1404RFC 2396 URI Generic Syntax August 1998 1405 1406 140710. Authors' Addresses 1408 1409 Tim Berners-Lee 1410 World Wide Web Consortium 1411 MIT Laboratory for Computer Science, NE43-356 1412 545 Technology Square 1413 Cambridge, MA 02139 1414 1415 Fax: +1(617)258-8682 1416 EMail: timbl@w3.org 1417 1418 1419 Roy T. Fielding 1420 Department of Information and Computer Science 1421 University of California, Irvine 1422 Irvine, CA 92697-3425 1423 1424 Fax: +1(949)824-1715 1425 EMail: fielding@ics.uci.edu 1426 1427 1428 Larry Masinter 1429 Xerox PARC 1430 3333 Coyote Hill Road 1431 Palo Alto, CA 94034 1432 1433 Fax: +1(415)812-4333 1434 EMail: masinter@parc.xerox.com 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458Berners-Lee, et. al. Standards Track [Page 26] 1459 1460RFC 2396 URI Generic Syntax August 1998 1461 1462 1463A. Collected BNF for URI 1464 1465 URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ] 1466 absoluteURI = scheme ":" ( hier_part | opaque_part ) 1467 relativeURI = ( net_path | abs_path | rel_path ) [ "?" query ] 1468 1469 hier_part = ( net_path | abs_path ) [ "?" query ] 1470 opaque_part = uric_no_slash *uric 1471 1472 uric_no_slash = unreserved | escaped | ";" | "?" | ":" | "@" | 1473 "&" | "=" | "+" | "$" | "," 1474 1475 net_path = "//" authority [ abs_path ] 1476 abs_path = "/" path_segments 1477 rel_path = rel_segment [ abs_path ] 1478 1479 rel_segment = 1*( unreserved | escaped | 1480 ";" | "@" | "&" | "=" | "+" | "$" | "," ) 1481 1482 scheme = alpha *( alpha | digit | "+" | "-" | "." ) 1483 1484 authority = server | reg_name 1485 1486 reg_name = 1*( unreserved | escaped | "$" | "," | 1487 ";" | ":" | "@" | "&" | "=" | "+" ) 1488 1489 server = [ [ userinfo "@" ] hostport ] 1490 userinfo = *( unreserved | escaped | 1491 ";" | ":" | "&" | "=" | "+" | "$" | "," ) 1492 1493 hostport = host [ ":" port ] 1494 host = hostname | IPv4address 1495 hostname = *( domainlabel "." ) toplabel [ "." ] 1496 domainlabel = alphanum | alphanum *( alphanum | "-" ) alphanum 1497 toplabel = alpha | alpha *( alphanum | "-" ) alphanum 1498 IPv4address = 1*digit "." 1*digit "." 1*digit "." 1*digit 1499 port = *digit 1500 1501 path = [ abs_path | opaque_part ] 1502 path_segments = segment *( "/" segment ) 1503 segment = *pchar *( ";" param ) 1504 param = *pchar 1505 pchar = unreserved | escaped | 1506 ":" | "@" | "&" | "=" | "+" | "$" | "," 1507 1508 query = *uric 1509 1510 fragment = *uric 1511 1512 1513 1514Berners-Lee, et. al. Standards Track [Page 27] 1515 1516RFC 2396 URI Generic Syntax August 1998 1517 1518 1519 uric = reserved | unreserved | escaped 1520 reserved = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | 1521 "$" | "," 1522 unreserved = alphanum | mark 1523 mark = "-" | "_" | "." | "!" | "~" | "*" | "'" | 1524 "(" | ")" 1525 1526 escaped = "%" hex hex 1527 hex = digit | "A" | "B" | "C" | "D" | "E" | "F" | 1528 "a" | "b" | "c" | "d" | "e" | "f" 1529 1530 alphanum = alpha | digit 1531 alpha = lowalpha | upalpha 1532 1533 lowalpha = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | 1534 "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | 1535 "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" 1536 upalpha = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | 1537 "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | 1538 "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" 1539 digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | 1540 "8" | "9" 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570Berners-Lee, et. al. Standards Track [Page 28] 1571 1572RFC 2396 URI Generic Syntax August 1998 1573 1574 1575B. Parsing a URI Reference with a Regular Expression 1576 1577 As described in Section 4.3, the generic URI syntax is not sufficient 1578 to disambiguate the components of some forms of URI. Since the 1579 "greedy algorithm" described in that section is identical to the 1580 disambiguation method used by POSIX regular expressions, it is 1581 natural and commonplace to use a regular expression for parsing the 1582 potential four components and fragment identifier of a URI reference. 1583 1584 The following line is the regular expression for breaking-down a URI 1585 reference into its components. 1586 1587 ^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))? 1588 12 3 4 5 6 7 8 9 1589 1590 The numbers in the second line above are only to assist readability; 1591 they indicate the reference points for each subexpression (i.e., each 1592 paired parenthesis). We refer to the value matched for subexpression 1593 <n> as $<n>. For example, matching the above expression to 1594 1595 http://www.ics.uci.edu/pub/ietf/uri/#Related 1596 1597 results in the following subexpression matches: 1598 1599 $1 = http: 1600 $2 = http 1601 $3 = //www.ics.uci.edu 1602 $4 = www.ics.uci.edu 1603 $5 = /pub/ietf/uri/ 1604 $6 = <undefined> 1605 $7 = <undefined> 1606 $8 = #Related 1607 $9 = Related 1608 1609 where <undefined> indicates that the component is not present, as is 1610 the case for the query component in the above example. Therefore, we 1611 can determine the value of the four components and fragment as 1612 1613 scheme = $2 1614 authority = $4 1615 path = $5 1616 query = $7 1617 fragment = $9 1618 1619 and, going in the opposite direction, we can recreate a URI reference 1620 from its components using the algorithm in step 7 of Section 5.2. 1621 1622 1623 1624 1625 1626Berners-Lee, et. al. Standards Track [Page 29] 1627 1628RFC 2396 URI Generic Syntax August 1998 1629 1630 1631C. Examples of Resolving Relative URI References 1632 1633 Within an object with a well-defined base URI of 1634 1635 http://a/b/c/d;p?q 1636 1637 the relative URI would be resolved as follows: 1638 1639C.1. Normal Examples 1640 1641 g:h = g:h 1642 g = http://a/b/c/g 1643 ./g = http://a/b/c/g 1644 g/ = http://a/b/c/g/ 1645 /g = http://a/g 1646 //g = http://g 1647 ?y = http://a/b/c/?y 1648 g?y = http://a/b/c/g?y 1649 #s = (current document)#s 1650 g#s = http://a/b/c/g#s 1651 g?y#s = http://a/b/c/g?y#s 1652 ;x = http://a/b/c/;x 1653 g;x = http://a/b/c/g;x 1654 g;x?y#s = http://a/b/c/g;x?y#s 1655 . = http://a/b/c/ 1656 ./ = http://a/b/c/ 1657 .. = http://a/b/ 1658 ../ = http://a/b/ 1659 ../g = http://a/b/g 1660 ../.. = http://a/ 1661 ../../ = http://a/ 1662 ../../g = http://a/g 1663 1664C.2. Abnormal Examples 1665 1666 Although the following abnormal examples are unlikely to occur in 1667 normal practice, all URI parsers should be capable of resolving them 1668 consistently. Each example uses the same base as above. 1669 1670 An empty reference refers to the start of the current document. 1671 1672 <> = (current document) 1673 1674 Parsers must be careful in handling the case where there are more 1675 relative path ".." segments than there are hierarchical levels in the 1676 base URI's path. Note that the ".." syntax cannot be used to change 1677 the authority component of a URI. 1678 1679 1680 1681 1682Berners-Lee, et. al. Standards Track [Page 30] 1683 1684RFC 2396 URI Generic Syntax August 1998 1685 1686 1687 ../../../g = http://a/../g 1688 ../../../../g = http://a/../../g 1689 1690 In practice, some implementations strip leading relative symbolic 1691 elements (".", "..") after applying a relative URI calculation, based 1692 on the theory that compensating for obvious author errors is better 1693 than allowing the request to fail. Thus, the above two references 1694 will be interpreted as "http://a/g" by some implementations. 1695 1696 Similarly, parsers must avoid treating "." and ".." as special when 1697 they are not complete components of a relative path. 1698 1699 /./g = http://a/./g 1700 /../g = http://a/../g 1701 g. = http://a/b/c/g. 1702 .g = http://a/b/c/.g 1703 g.. = http://a/b/c/g.. 1704 ..g = http://a/b/c/..g 1705 1706 Less likely are cases where the relative URI uses unnecessary or 1707 nonsensical forms of the "." and ".." complete path segments. 1708 1709 ./../g = http://a/b/g 1710 ./g/. = http://a/b/c/g/ 1711 g/./h = http://a/b/c/g/h 1712 g/../h = http://a/b/c/h 1713 g;x=1/./y = http://a/b/c/g;x=1/y 1714 g;x=1/../y = http://a/b/c/y 1715 1716 All client applications remove the query component from the base URI 1717 before resolving relative URI. However, some applications fail to 1718 separate the reference's query and/or fragment components from a 1719 relative path before merging it with the base path. This error is 1720 rarely noticed, since typical usage of a fragment never includes the 1721 hierarchy ("/") character, and the query component is not normally 1722 used within relative references. 1723 1724 g?y/./x = http://a/b/c/g?y/./x 1725 g?y/../x = http://a/b/c/g?y/../x 1726 g#s/./x = http://a/b/c/g#s/./x 1727 g#s/../x = http://a/b/c/g#s/../x 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738Berners-Lee, et. al. Standards Track [Page 31] 1739 1740RFC 2396 URI Generic Syntax August 1998 1741 1742 1743 Some parsers allow the scheme name to be present in a relative URI if 1744 it is the same as the base URI scheme. This is considered to be a 1745 loophole in prior specifications of partial URI [RFC1630]. Its use 1746 should be avoided. 1747 1748 http:g = http:g ; for validating parsers 1749 | http://a/b/c/g ; for backwards compatibility 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794Berners-Lee, et. al. Standards Track [Page 32] 1795 1796RFC 2396 URI Generic Syntax August 1998 1797 1798 1799D. Embedding the Base URI in HTML documents 1800 1801 It is useful to consider an example of how the base URI of a document 1802 can be embedded within the document's content. In this appendix, we 1803 describe how documents written in the Hypertext Markup Language 1804 (HTML) [RFC1866] can include an embedded base URI. This appendix 1805 does not form a part of the URI specification and should not be 1806 considered as anything more than a descriptive example. 1807 1808 HTML defines a special element "BASE" which, when present in the 1809 "HEAD" portion of a document, signals that the parser should use the 1810 BASE element's "HREF" attribute as the base URI for resolving any 1811 relative URI. The "HREF" attribute must be an absolute URI. Note 1812 that, in HTML, element and attribute names are case-insensitive. For 1813 example: 1814 1815 <!doctype html public "-//IETF//DTD HTML//EN"> 1816 <HTML><HEAD> 1817 <TITLE>An example HTML document</TITLE> 1818 <BASE href="http://www.ics.uci.edu/Test/a/b/c"> 1819 </HEAD><BODY> 1820 ... <A href="../x">a hypertext anchor</A> ... 1821 </BODY></HTML> 1822 1823 A parser reading the example document should interpret the given 1824 relative URI "../x" as representing the absolute URI 1825 1826 <http://www.ics.uci.edu/Test/a/x> 1827 1828 regardless of the context in which the example document was obtained. 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850Berners-Lee, et. al. Standards Track [Page 33] 1851 1852RFC 2396 URI Generic Syntax August 1998 1853 1854 1855E. Recommendations for Delimiting URI in Context 1856 1857 URI are often transmitted through formats that do not provide a clear 1858 context for their interpretation. For example, there are many 1859 occasions when URI are included in plain text; examples include text 1860 sent in electronic mail, USENET news messages, and, most importantly, 1861 printed on paper. In such cases, it is important to be able to 1862 delimit the URI from the rest of the text, and in particular from 1863 punctuation marks that might be mistaken for part of the URI. 1864 1865 In practice, URI are delimited in a variety of ways, but usually 1866 within double-quotes "http://test.com/", angle brackets 1867 <http://test.com/>, or just using whitespace 1868 1869 http://test.com/ 1870 1871 These wrappers do not form part of the URI. 1872 1873 In the case where a fragment identifier is associated with a URI 1874 reference, the fragment would be placed within the brackets as well 1875 (separated from the URI with a "#" character). 1876 1877 In some cases, extra whitespace (spaces, linebreaks, tabs, etc.) may 1878 need to be added to break long URI across lines. The whitespace 1879 should be ignored when extracting the URI. 1880 1881 No whitespace should be introduced after a hyphen ("-") character. 1882 Because some typesetters and printers may (erroneously) introduce a 1883 hyphen at the end of line when breaking a line, the interpreter of a 1884 URI containing a line break immediately after a hyphen should ignore 1885 all unescaped whitespace around the line break, and should be aware 1886 that the hyphen may or may not actually be part of the URI. 1887 1888 Using <> angle brackets around each URI is especially recommended as 1889 a delimiting style for URI that contain whitespace. 1890 1891 The prefix "URL:" (with or without a trailing space) was recommended 1892 as a way to used to help distinguish a URL from other bracketed 1893 designators, although this is not common in practice. 1894 1895 For robustness, software that accepts user-typed URI should attempt 1896 to recognize and strip both delimiters and embedded whitespace. 1897 1898 For example, the text: 1899 1900 1901 1902 1903 1904 1905 1906Berners-Lee, et. al. Standards Track [Page 34] 1907 1908RFC 2396 URI Generic Syntax August 1998 1909 1910 1911 Yes, Jim, I found it under "http://www.w3.org/Addressing/", 1912 but you can probably pick it up from <ftp://ds.internic. 1913 net/rfc/>. Note the warning in <http://www.ics.uci.edu/pub/ 1914 ietf/uri/historical.html#WARNING>. 1915 1916 contains the URI references 1917 1918 http://www.w3.org/Addressing/ 1919 ftp://ds.internic.net/rfc/ 1920 http://www.ics.uci.edu/pub/ietf/uri/historical.html#WARNING 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962Berners-Lee, et. al. Standards Track [Page 35] 1963 1964RFC 2396 URI Generic Syntax August 1998 1965 1966 1967F. Abbreviated URLs 1968 1969 The URL syntax was designed for unambiguous reference to network 1970 resources and extensibility via the URL scheme. However, as URL 1971 identification and usage have become commonplace, traditional media 1972 (television, radio, newspapers, billboards, etc.) have increasingly 1973 used abbreviated URL references. That is, a reference consisting of 1974 only the authority and path portions of the identified resource, such 1975 as 1976 1977 www.w3.org/Addressing/ 1978 1979 or simply the DNS hostname on its own. Such references are primarily 1980 intended for human interpretation rather than machine, with the 1981 assumption that context-based heuristics are sufficient to complete 1982 the URL (e.g., most hostnames beginning with "www" are likely to have 1983 a URL prefix of "http://"). Although there is no standard set of 1984 heuristics for disambiguating abbreviated URL references, many client 1985 implementations allow them to be entered by the user and 1986 heuristically resolved. It should be noted that such heuristics may 1987 change over time, particularly when new URL schemes are introduced. 1988 1989 Since an abbreviated URL has the same syntax as a relative URL path, 1990 abbreviated URL references cannot be used in contexts where relative 1991 URLs are expected. This limits the use of abbreviated URLs to places 1992 where there is no defined base URL, such as dialog boxes and off-line 1993 advertisements. 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018Berners-Lee, et. al. Standards Track [Page 36] 2019 2020RFC 2396 URI Generic Syntax August 1998 2021 2022 2023G. Summary of Non-editorial Changes 2024 2025G.1. Additions 2026 2027 Section 4 (URI References) was added to stem the confusion regarding 2028 "what is a URI" and how to describe fragment identifiers given that 2029 they are not part of the URI, but are part of the URI syntax and 2030 parsing concerns. In addition, it provides a reference definition 2031 for use by other IETF specifications (HTML, HTTP, etc.) that have 2032 previously attempted to redefine the URI syntax in order to account 2033 for the presence of fragment identifiers in URI references. 2034 2035 Section 2.4 was rewritten to clarify a number of misinterpretations 2036 and to leave room for fully internationalized URI. 2037 2038 Appendix F on abbreviated URLs was added to describe the shortened 2039 references often seen on television and magazine advertisements and 2040 explain why they are not used in other contexts. 2041 2042G.2. Modifications from both RFC 1738 and RFC 1808 2043 2044 Changed to URI syntax instead of just URL. 2045 2046 Confusion regarding the terms "character encoding", the URI 2047 "character set", and the escaping of characters with %<hex><hex> 2048 equivalents has (hopefully) been reduced. Many of the BNF rule names 2049 regarding the character sets have been changed to more accurately 2050 describe their purpose and to encompass all "characters" rather than 2051 just US-ASCII octets. Unless otherwise noted here, these 2052 modifications do not affect the URI syntax. 2053 2054 Both RFC 1738 and RFC 1808 refer to the "reserved" set of characters 2055 as if URI-interpreting software were limited to a single set of 2056 characters with a reserved purpose (i.e., as meaning something other 2057 than the data to which the characters correspond), and that this set 2058 was fixed by the URI scheme. However, this has not been true in 2059 practice; any character that is interpreted differently when it is 2060 escaped is, in effect, reserved. Furthermore, the interpreting 2061 engine on a HTTP server is often dependent on the resource, not just 2062 the URI scheme. The description of reserved characters has been 2063 changed accordingly. 2064 2065 The plus "+", dollar "$", and comma "," characters have been added to 2066 those in the "reserved" set, since they are treated as reserved 2067 within the query component. 2068 2069 2070 2071 2072 2073 2074Berners-Lee, et. al. Standards Track [Page 37] 2075 2076RFC 2396 URI Generic Syntax August 1998 2077 2078 2079 The tilde "~" character was added to those in the "unreserved" set, 2080 since it is extensively used on the Internet in spite of the 2081 difficulty to transcribe it with some keyboards. 2082 2083 The syntax for URI scheme has been changed to require that all 2084 schemes begin with an alpha character. 2085 2086 The "user:password" form in the previous BNF was changed to a 2087 "userinfo" token, and the possibility that it might be 2088 "user:password" made scheme specific. In particular, the use of 2089 passwords in the clear is not even suggested by the syntax. 2090 2091 The question-mark "?" character was removed from the set of allowed 2092 characters for the userinfo in the authority component, since testing 2093 showed that many applications treat it as reserved for separating the 2094 query component from the rest of the URI. 2095 2096 The semicolon ";" character was added to those stated as being 2097 reserved within the authority component, since several new schemes 2098 are using it as a separator within userinfo to indicate the type of 2099 user authentication. 2100 2101 RFC 1738 specified that the path was separated from the authority 2102 portion of a URI by a slash. RFC 1808 followed suit, but with a 2103 fudge of carrying around the separator as a "prefix" in order to 2104 describe the parsing algorithm. RFC 1630 never had this problem, 2105 since it considered the slash to be part of the path. In writing 2106 this specification, it was found to be impossible to accurately 2107 describe and retain the difference between the two URI 2108 <foo:/bar> and <foo:bar> 2109 without either considering the slash to be part of the path (as 2110 corresponds to actual practice) or creating a separate component just 2111 to hold that slash. We chose the former. 2112 2113G.3. Modifications from RFC 1738 2114 2115 The definition of specific URL schemes and their scheme-specific 2116 syntax and semantics has been moved to separate documents. 2117 2118 The URL host was defined as a fully-qualified domain name. However, 2119 many URLs are used without fully-qualified domain names (in contexts 2120 for which the full qualification is not necessary), without any host 2121 (as in some file URLs), or with a host of "localhost". 2122 2123 The URL port is now *digit instead of 1*digit, since systems are 2124 expected to handle the case where the ":" separator between host and 2125 port is supplied without a port. 2126 2127 2128 2129 2130Berners-Lee, et. al. Standards Track [Page 38] 2131 2132RFC 2396 URI Generic Syntax August 1998 2133 2134 2135 The recommendations for delimiting URI in context (Appendix E) have 2136 been adjusted to reflect current practice. 2137 2138G.4. Modifications from RFC 1808 2139 2140 RFC 1808 (Section 4) defined an empty URL reference (a reference 2141 containing nothing aside from the fragment identifier) as being a 2142 reference to the base URL. Unfortunately, that definition could be 2143 interpreted, upon selection of such a reference, as a new retrieval 2144 action on that resource. Since the normal intent of such references 2145 is for the user agent to change its view of the current document to 2146 the beginning of the specified fragment within that document, not to 2147 make an additional request of the resource, a description of how to 2148 correctly interpret an empty reference has been added in Section 4. 2149 2150 The description of the mythical Base header field has been replaced 2151 with a reference to the Content-Location header field defined by 2152 MHTML [RFC2110]. 2153 2154 RFC 1808 described various schemes as either having or not having the 2155 properties of the generic URI syntax. However, the only requirement 2156 is that the particular document containing the relative references 2157 have a base URI that abides by the generic URI syntax, regardless of 2158 the URI scheme, so the associated description has been updated to 2159 reflect that. 2160 2161 The BNF term <net_loc> has been replaced with <authority>, since the 2162 latter more accurately describes its use and purpose. Likewise, the 2163 authority is no longer restricted to the IP server syntax. 2164 2165 Extensive testing of current client applications demonstrated that 2166 the majority of deployed systems do not use the ";" character to 2167 indicate trailing parameter information, and that the presence of a 2168 semicolon in a path segment does not affect the relative parsing of 2169 that segment. Therefore, parameters have been removed as a separate 2170 component and may now appear in any path segment. Their influence 2171 has been removed from the algorithm for resolving a relative URI 2172 reference. The resolution examples in Appendix C have been modified 2173 to reflect this change. 2174 2175 Implementations are now allowed to work around misformed relative 2176 references that are prefixed by the same scheme as the base URI, but 2177 only for schemes known to use the <hier_part> syntax. 2178 2179 2180 2181 2182 2183 2184 2185 2186Berners-Lee, et. al. Standards Track [Page 39] 2187 2188RFC 2396 URI Generic Syntax August 1998 2189 2190 2191H. Full Copyright Statement 2192 2193 Copyright (C) The Internet Society (1998). All Rights Reserved. 2194 2195 This document and translations of it may be copied and furnished to 2196 others, and derivative works that comment on or otherwise explain it 2197 or assist in its implementation may be prepared, copied, published 2198 and distributed, in whole or in part, without restriction of any 2199 kind, provided that the above copyright notice and this paragraph are 2200 included on all such copies and derivative works. However, this 2201 document itself may not be modified in any way, such as by removing 2202 the copyright notice or references to the Internet Society or other 2203 Internet organizations, except as needed for the purpose of 2204 developing Internet standards in which case the procedures for 2205 copyrights defined in the Internet Standards process must be 2206 followed, or as required to translate it into languages other than 2207 English. 2208 2209 The limited permissions granted above are perpetual and will not be 2210 revoked by the Internet Society or its successors or assigns. 2211 2212 This document and the information contained herein is provided on an 2213 "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING 2214 TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING 2215 BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION 2216 HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF 2217 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242Berners-Lee, et. al. Standards Track [Page 40] 2243 2244