Subject: [URN] WG last call: URN Namespace Definition Mechanisms

From: Leslie Daigle <[email-masked]>
Date: Thu, 8 Oct 1998 15:11:27 -0400 (EDT)

Howdy,

Attached is a revised draft of

	URN Namespace Definition Mechanisms

which attempts to address the specific issues brought up in August re.
description of character sets/character encoding equivalences, etc.
It has been submitted to the I-D editor.

Other minor changes include:

	. ALL two letter NIDs are reserved for country codes
	. addition of version information for the registration
	. clarification of process for FORMAL namespace documents

I hereby declare this document open for "Working Group Last Call" -- if
there are any issues with the changes that have been made, please let me
know by 5pm EST October 19, 1998.  

Thanks,
Leslie.

----------------------------------------------------------------------------

    If cats had bumper stickers:                  Leslie Daigle
                                             
      "I wake for food."                          Bunyip Information Systems
                -- ThinkingCat                    (514) 875-8611
                                                  [email-masked]
----------------------------------------------------------------------------

Internet Draft                               Leslie L. Daigle
October 8, 1998                              Bunyip Information Systems
draft-ietf-urn-nid-req-06.txt                Dirk-Willem van Gulik
                                             ISIS/CEO, JRC Ispra
                                             Renato Iannella
                                             DSTC Pty Ltd
                                             Patrik Faltstrom
                                             Tele2/Swipnet

      URN Namespace Definition Mechanisms

Status of this Document

     This document is an Internet-Draft.  Internet-Drafts are working  
     documents of the Internet Engineering Task Force (IETF), its
     areas, and its working groups.  Note that other groups may also  
     distribute working documents as Internet-Drafts. 

     Internet-Drafts are draft documents valid for a maximum of six
     months and may be updated, replaced, or obsoleted by other
     documents at any time.  It is inappropriate to use Internet-
     Drafts as reference material or to cite them other than as 
     "work in progress."

     To view the entire list of current Internet-Drafts, please check
     the "1id-abstracts.txt" listing contained in the Internet-Drafts
     Shadow Directories on ftp.is.co.za (Africa), ftp.nordu.net
     (Europe), munnari.oz.au (Pacific Rim), ds.internic.net (US East
     Coast), or ftp.isi.edu (US West Coast).

0.0 Abstract

The URN WG has defined a syntax for Uniform Resource Names
(URNs) [RFC2141], as well as some proposed mechanisms for their
resolution and use in Internet applications ([RFC2168, RFC2169]).    
The whole rests on the concept of individual "namespaces" within the
URN structure.  Apart from  proof-of-concept namespaces, the use
of existing identifiers in URNs has been discussed ([RFC2288]),
and this document lays out general definitions of and 
mechanisms for establishing URN "namespaces". 

1.0 Introduction

Uniform Resource Names (URNs) are resource identifiers with the
specific requirements for enabling location independent
identification of a resource, as well as longevity of reference.
There are 2 assumptions that are key to this document:

Assumption #1:

   Assignment of a URN is a managed process.

   I.e., not all strings that conform to URN syntax are necessarily
   valid URNs.  A URN is assigned according to the rules of a 
   particular namespace (in terms of syntax, semantics, and process).

Assumption #2:

   The space of URN namespaces is managed.
   
   I.e., not all syntactically correct URN namespaces (per the URN
   syntax definition)  are valid URN namespaces.  A URN namespace
   must have a recognized definition in order to be valid.

The purpose of this document is to outline a mechanism and provide a
template for explicit namespace definition, along with the mechanism
for associating an identifier (called a "Namespace ID", or NID) which
is registered with the Internet Assigned Number Authority, IANA.

Note that this document restricts itself to the description of
processes for the creation of URN namespaces.  If "resolution" of any
so-created URN identifiers is desired, a separate process of
registration in a global NID directory, such as that provided by the
NAPTR system [RFC2168], is necessary.  See [NAPTR-REG] for information
on obtaining registration in the NAPTR global NID directory.

2.0 What is a URN Namespace?

For the purposes of URNs, a "namespace" is a collection of
uniquely-assigned identifiers.  A URN namespace itself has an
identifier in order to

	. ensure global uniqueness of URNs
	. (where desired) provide a cue for the structure of the
	  identifier

For example, ISBNs and ISSNs are both collections of identifiers used
in the traditional publishing world; while there may some number (or
numbers) that is both a valid ISBN identifier and ISSN identifier,
using different designators for the two collections ensures that no
two URNs will be the same for different resources.

The development of an identifier structure, and thereby a collection
of identifiers, is a process that is inherently dependent on the 
requirements of the community defining the identifier, how they will 
be assigned, and the uses to which they will be put.  All of these 
issues are specific to the individual community seeking to define a 
namespace (e.g., publishing community, association of booksellers, 
protocol developers, etc); they are beyond the scope of the IETF 
URN work.

This document outlines the processes by which a collection of
identifiers satisfying certain constraints (uniqueness of assignment,
etc) can become a bona fide URN namespace by obtaining a NID.  In a
nutshell, a template for the definition of the namespace is completed
for deposit with IANA, and a NID is assigned.  The details of the
process and possibilities for NID strings are outlined below; first, a
template for the definition is provided.

3.0 URN Namespace Definition Template

Definition of a URN namespace is accomplished by completing the
following information template.  Apart from providing a mechanism
for disclosing structure of the URN namespace, this information
is designed to be useful for

	. entities seeking to have a URN assigned in a namespace
	  (if applicable)
        . entities seeking to provide URN resolvers for a namespace 
	  (if applicable)

This is particularly important for communities evaluating the
possibility of using a portion of an existing URN namespace rather 
than creating their own.

Information in the template is as follows:

Namespace ID:
	
	Assigned by IANA.  In some contexts, a particular one
	may be requested (see below).

Registration Information:

	This is information to identify the particular version of
	registration information:

	. registration version number: starting with 1, incrementing by 1
		with each new version
	. registration date: date submitted to the IANA, using
		the format 
			YYYY-MM-DD
		as outlined in [ISO8601].

Declared registrant of the namespace:  

	Required: Name and e-mail address.
	Recommended:  Affiliation, address, etc.

Declaration of syntactic structure:

	This section should outline any structural features of
	identifiers in this namespace.  At the very least, this
	description may be used to introduce terminology used in
	other sections.  This structure may also be used for
	determining realistic caching/shortcuts approaches; suitable 
	caveats should be provided.  If there are any specific
	character encoding rules (e.g., which character should
	always be used for single-quotes), these should be listed
	here.

	Answers might include, but are not limited to:

	. the structure is opaque (no exposition)
	. a regular expression for parsing the identifier into
	  components, including naming authorities

Relevant ancillary documentation:

	This section should list any RFCs, standards, or other published
	documentation that defines or explains all or part of the
	namespace structure.

	Answers might include, but are not limited to:
	
	. RFCs outlining syntax of the namespace
	. Other of the defining community's (e.g., ISO) documents 
	  outlining syntax of the identifiers in the namespace
	. Explanatory material introducing the namespace

Identifier uniqueness considerations:
	
	This section should address the requirement that 
	URN identifiers be assigned uniquely -- they are assigned
	to at most one resource, and are not reassigned.

	(Note that the definition of "resource" is fairly
	broad; for example, information on "Today's Weather" might 
	be considered a single resource, although the content is
	dynamic.)

	Possible answers include, but are not limited to:

	. exposition of the structure of the identifiers, and
	  partitioning of the space of identifiers amongst 
	  assignment authorities which are individually responsible
	  for respecting uniqueness rules
	. identifiers are assigned sequentially
	. information is withheld; the namespace is opaque

Identifier persistence considerations:

	Although non-reassignment of URN identifiers ensures
	that a URN will persist in identifying a particular
	resource even after the "lifetime of the resource", 
	some consideration should be given to the persistence
	of the usability of the URN.  This is particularly
	important in the case of URN namespaces providing 
	global resolution.

	Possible answers include, but are not limited to:

	. quality of service considerations

Process of identifier assignment:

	This section should detail the mechanisms and/or authorities
	for assigning URNs to resources.  It should make clear whether
	assignment is completely open, or if limited, how
	to become an assigner of identifiers, and/or get one
	assigned by existing assignment authorities.  Answers
	could include, but are not limited to:

	. assignment is completely open, following a particular
	  algorithm
	. assignment is delegated to authorities recognized by
	  a particular organization (e.g., the Digital Object
	  Identifier Foundation controls the DOI assignment space and 
	  its delegation)
	. assignment is completely closed (e.g., for a private
	  organization)

Process for identifier resolution:

	If a namespace is intended to be accessible for global
	resolution, it must be registerd in an RDS (Resolution
	Discovery System, see [RFC2276]) such as NAPTR.  Resolution
	then proceeds according to standard URI resolution processes,
	and the mechanisms of the RDS.  What this section should
	outline is the requirements for becoming a recognized resolver 
	of URNs in this namespace (and being so-listed in the RDS
	registry).

	Answers may include, but are not limited to:

	. the namespace is not listed with an RDS; this is not
	  relevant
	. resolution mirroring is completely open, with a mechanism
	  for updating an appropriate RDS
	. resolution is controlled by entities to which assignment
	  has been delegated

Rules for Lexical Equivalence:

	If there are particular algorithms for determining
	equivalence between two identifiers in the underlying
	namespace (hence, in the URN string itself), rules can 
	be provided here.  

	Some examples include:
	
	. equivalence between hyphenated and non-hyphenated
	  groupings in the identifier string
	. equivalence between single-quotes and double-quotes
	. Namespace-defined equivalences between specific 
	  characters, such as "character X with or without
	  diacritic marks".

	Note that these are not normative statements for any kind of 
	best practice for handling equivalences between characters; 
	they are statements limited to reflecting the namespace's 
	own rules.

Conformance with URN Syntax:

	This section should outline any special considerations
	required for conforming with the URN syntax.  This is
	particularly applicable in the case of legacy naming
	systems that are used in the context of URNs.

	For example, if a namespace is used in contexts other 
	than URNs, it may make use of characters that are reserved
	in the URN syntax.  This section should flag any such
	characters, and outline necessary mappings to conform to 
	URN syntax.  Normally, this will be handled by hex encoding
	the symbol.

	For example, see the section on SICIs in [RFC2288].

Validation mechanism:

	Apart from attempting resolution of a URN, a URN namespace
	may provide mechanism for "validating" a URN -- i.e., 
	determining whether a given string is currently a
	validly-assigned URN.  For example, even if an ISBN
	URN namespace is created, it is not clear that
	all ISBNs will translate directly into "assigned URNs".

	A validation mechanims might be:

	. a syntax grammar
	. an on-line service
	. an off-line service

Scope:
	
	This section should outline the scope of the use of the
	identifiers in this namespace.  Apart from considerations
	of private vs. public namespaces, this section is critical
	in evaluating the applicability of a requested NID.  For
	example, a namespace claiming to deal in "social security
	numbers" should have a global scope and address all 
	social security number structures (unlikely).  On the
	other hand, at a national level, it is reasonable to
	posit a URN namespace for "this nation's social security
	numbers".

4.0 URN Namespace Registration, Update,  and NID Assignment Process

Different levels of disclosure are expected/defined for namespaces.
According to the level of open-forum  discussion surrounding
the disclosure, a URN namespace may be assigned or may request a
particular identifier.  The [IANA-CONSIDERATIONS] document suggests
the need to specify update mechanisms for registrations -- who 
is given the authority to do so, from time to time, and what are
the processes.  Since URNs are meant to be persistently useful, few
(if any) changes should be made to the structural interpretation of
URN strings (e.g., adding or removing rules for lexical equivalence that
might affect the interpretation of URN IDs already assigned).  However, it 
may be important to introduce clarifications, expand the list of
authorized URN assigners, etc, over the natural course of a namespace's
lifetime.  Specific processes are outlined below.

There are 3 categories of URN namespaces defined here, distinguished
by expected level of service and required procedures for registration.
Furthermore, registration maintenance procedures vary slightly from
one category to another.

	  I. Experimental: These are not explicitly registered with IANA. They
	        take the form

		x-<NID>

		No provision is made for avoiding collision of experimental
	 	NIDs; they are intended for use within internal or limited 
		experimental contexts.

		As there is no registration, no registration maintenance
		procedures are needed.

	 II. Informal:  These are registered with IANA and are assigned a 
		number sequence as an identifier, in the format:
		
			"iana-" <number>

		where <number> is chosen by the IANA on a First Come First
	 	Served basis (see [IANA-CONSIDERATIONS]).

		Registrants should send a copy of the registration
	  	template (see section 3.0), duly completed, to the 

			[email-masked]

		mailing and allow for a 2 week discussion period for
		clarifying the expression of the registration information
		and suggestions for improvements to the namespace proposal.  
		
		After suggestions for clarification of the registration 
		information have been incorporated, the template may be 
		submitted to:
	 	
			[email-masked] 

		for assignment of a NID.

	 	The only restrictions on <number> are that it consist
		strictly of digits and that it not cause the NID to exceed
		length limitations outlined in the URN syntax ([RFC2168]).

		Registrations may be updated by the original registrant,
		or an entity designated by the registrant, by updating
		the registration template, submitting it to the discussion
		list for a further 2 week discussion period, and finally
		resubmitting it to IANA, as described above.

        III. Formal:  These are processed through an RFC review
                process.  The RFC need not be standards-track.  The
                template defined in section 3.0 may be included as part
                of an RFC defining some other aspect of the namespace,
                or it may be put forward as an RFC in its own right.
                The proposed template should be sent to the

                        [email-masked]

                mailing list to allow for a 2 week discussion period  for
                clarifying the expression of the registration information,
		before the IESG progresses the document to RFC status.

		A particular NID string is requested, and is assigned by IETF
		consensus (as defined in [IANA-CONSIDERATIONS]), with
		the additional constraints that the NID string must 
		not start with "x-" (see Type I above) or "iana-" (see Type II 
		above), is not already a registered NID, and is more
		than 2 letters long.

		ALL two-letter combinations are reserved for use
		as country code NIDs for eventual national registrations of
	 	URN namespaces.  

		Registrations may be updated by updating the RFC through 
		standard IETF RFC update mechanisms.  Thus, proposals for 
		updates may be made by the original authors, other IETF 
		participants, or the IESG.  In any case, the proposed 
		updated template must be circulated on the urn-nid 
		discussion list, allowing for a 2 week review period. 

URN namespace registrations will be posted in the anonymous FTP directory
"ftp://ftp.isi.edu/in-notes/iana/assignments/URN-namespaces/".

5.0 Example

The following example is provided for the purposes of illustration of
the URN NID template described in section 3.0.  Although it is based on
a posited "generic Internet namespace" that has been discussed informally
within the URN WG, there are still technical and infrastructural issues
that would have to be resolved before such a namespace could be properly
and completely described.  

Namespace ID:
	
	To be assigned

Registration Information:

	Version 1
	Date: <when submitted>

Declared registrant of the namespace:

        Required: Name and e-mail address.
        Recommended:  Affiliation, address, etc.

Declared registrant of the namespace:  

	Name:		T. Cat
	E-mail:		[email-masked]
	Affiliation:	Thinking Cat Enterprises
	Address:	1 ThinkingCat Way
			Trupville, NewCountry

Declaration of structure:

	The identifier structure is as follows:
	
	URN:<assigned number>:<FQDN>:<assigned US-ASCII string>

	where FQDN is a fully-qualified domain name, and the
	assigned string is conformant to URN syntax requirements.

Relevant ancillary documentation:

	Definition of domain names, found in:

	P. Mockapetris, "DOMAIN NAMES - IMPLEMENTATION AND SPECIFICATION", 
	RFC1035, November 1987.

Identifier uniqueness considerations:
	
	Uniqueness is guaranteed as long as the assigned
	string is never reassigned for a given FQDN, and that the FQDN
	is never reassigned.	
	
	N.B.:  operationally, there is nothing that prevents a domain
	name from being reassigned;  indeed, it is not an uncommon 
	occurrence.  This is one of the reasons that this example
	makes a poor URN namespace in practice, and is therefore not
	seriously being proposed as it stands.

Identifier persistence considerations:

	Persistence of identifiers is dependent upon suitable
	delegation of resolution at the level of "FQDN"s, and persistence
	of FQDN assignment.
	
	Same note as above.

Process of identifier assignment:

	Assignment of these URNs delegated to individual domain
	name holders (for FQDNs).  The holder of the FQDN registration
	is required to maintain an entry (or delegate it) in the
	NAPTR RDS.  Within each of these delegated name partitions,
	the string may be assigned per local requirements.

	e.g.  urn:<assigned number>:thinkingcat.com:001203

Process for identifier resolution:

	Domain name holders are responsible for operating or
	delegating resolution servers for the FQDN in which they
	have assigned URNs.

Rules for Lexical Equivalence:

	FQDNs are case-insensitive.  Thus, the portion of the URN

		urn:<assigned number>:<FQDN>:

	is case-insenstive for matches.  The remainder of the identifier
	must be considered case-sensitve.

Conformance with URN Syntax:

	No special considerations.

Validation mechanism:

	None specified.

Scope:
	
	Global.

6.0 Security Considerations

This document largely focuses on providing mechanisms for the
declaration of public information.  Nominally, these declarations
should be of relatively low security profile, however there is
always the danger of "spoofing" and providing mis-information.
Information in these declarations should be taken as advisory.

7.0 References

[RFC2168] Ron Daniel & Michael Mealling, "Resolution of Uniform 
    Resource Identifiers using the Domain Name System", RFC 2168,
    June 1997.

[RFC2169] Ron Daniel, "A Trivial Convention for using HTTP in URN 
    Resolution", RFC 2169, June 1997.

[ISO8601] ISO 8601 : 1988 (E), "Data elements and interchange formats - 
    Information interchange - Representation of dates and times"

[RFC2288] C. Lynch, C. Preston & R. Daniel, "Using Existing 
    Bibliographic Identifiers as Uniform Resource Names", RFC 2288,
    February 1998.

[NAPTR-REG] M. Mealling, "Assignment Procedures for the URI Resolution 
    using DNS (RFC2168)", draft-ietf-urn-net-procedures-00.txt.

[RFC2141] Ryan Moats, "URN Syntax", RFC 2141, May 1997.

[IANA-CONSIDERATIONS] T. Narten and H. Alvestrand, "Guidelines for
    Writing an IANA Considerations Section in RFCs", 
    draft-iesg-iana-considerations-06.txt.

[RFC1737] Karen R Sollins & Larry Masinter, "Functional Requirements 
    for Uniform Resource Names", RFC1737, December 1994

[RFC2276] K. Sollins, "Architectural Principles of Uniform Resource 
    Name Resolution", RFC 2276, January 1998.

8.0 Authors' Addresses

Leslie L. Daigle
Bunyip Information Systems Inc
310 Ste. Catherine St. W
Suite 300
Montreal, Quebec, CANADA
H2X 2A1
voice: +1 514 875-8611
fax:   +1 514 875-8134
email:  [email-masked]

Dirk-Willem van Gulik
ISIS/STA/CEO - TP 270
Joint Research Centre Ispra
21020 Ispra (Va)
Italy.
voice: +39 332 78 9549 or 5044  
fax:   +39 332 78 9185
email:  [email-masked]

Renato Iannella
DSTC Pty Ltd
Gehrmann Labs, The Uni of Queensland
AUSTRALIA, 4072
voice:  +61 7 3365 4310
fax:    +61 7 3365 4311
email:  [email-masked]

Patrik Faltstrom
Tele2/Swipnet
Borgarfjordsgatan 16
P.O. Box 62
S-164 94 Kista
SWEDEN
voice:  +46-5626 4000
fax:    +46-5626 4200
email:  [email-masked]

---

From: "Larry Masinter" <[email-masked]>
Date: Thu, 8 Oct 1998 18:55:30 PDT

I must have missed the discussion, and I can't find any mention of
it in my archives of the mailing list. What was the source of the
requirement for reserving two-letter NIDs for country codes?

Do you really expect every country to have a different namespace?
Should Martinique have a different namespace from France? Are the
namespaces only for official government documents?

In general, it would seem like a bad idea for each country to have
a namespace, whether or not the namespace is defined with a two-letter
NID. Should the NS for a document space change when there are
political upheavals? There seem to be more changes to the set of
country codes annually than are reasonable for a system that is
supposed to be assigning 'permanent' IDs. What happens to the URNs
of documents originally registered by the Soviet Union, East
Germany, etc.

This is an area where for top-level domains the issues are politically
sensitive. Why should URNs encourage a similar mess? Especially
without discussion or requirements.

Larry

---

From: Patrik Fältström <[email-masked]>
Date: Fri, 9 Oct 1998 13:37:43 +0200

At 18.55 -0700 98-10-08, Larry Masinter wrote:
>What was the source of the

It was output from my discussions on namespaces held with the policy 
oversight committee, when I was appointed by IAB there.

I.e. from some countries (not few), there are "questions" wether the 
2-letter countrycode according to ISO can be allocated within each gTLD. 
This was later expanded to the URN namespaces for for example social 
security numbers and other series of names which are unique within each 
country -- like car license plates in some countries.

So, the input is from the gTLD debate, and the result solves some problems 
on what to do with geopolitical bounded namespaces. I.e. each country have 
to handle their namespaces the way they find it the easiest.

 paf
------------------------------------------------------------------
Senior Researcher                             Email: [email-masked]
Tele2 AB                                        URL: http://paf.se
Borgarfjordsgatan 16, Kista, Sweden      PGP Key ID: 0xBD236602

   In theory there is no difference between theory and practice,
   but in practice, there is.

---

From: Leslie Daigle <[email-masked]>
Date: Fri, 9 Oct 1998 09:44:42 -0400 (EDT)

Howdy,

Patrik has spoken to the meat of your comments, but I'd also like to
point out that the two-letter country code proposal has been in
the draft if not from the _first_ version of it, something pretty
close to it -- i.e., through 5 or 6 versions, anyway.

Let me just reiterate that the only thing that has changed in this
draft on that subject is that instead of it saying "the two letter country 
codes are reserved", it says "all two letter combinations are reserved for
country codes".

Leslie.

---

From: Leslie Daigle <[email-masked]>
Date: Fri, 9 Oct 1998 11:30:37 -0400 (EDT)

Howdy,

On Fri, 9 Oct 1998, Ryan Moats wrote:
> I have updated the "ietf" space draft to match it.  It's attached here (and

Great!

> Does anybody know when [email-masked] is open for business?

It should be up now -- Keith set it up months ago, when it first appeared
in the document; I assume it still works...

Leslie.

---

From: "Ryan Moats" <[email-masked]>
Date: Fri, 9 Oct 1998 10:28:06 -0500

Hi all-

Having read through the WG last call, I don't have any comments on that
document, but
I have updated the "ietf" space draft to match it.  It's attached here (and
is
being sent to the i-d editor under separate cover).

Ryan

======cut here

Internet-Draft                                                Ryan Moats
draft-ietf-urn-ietf-07.txt                                          AT&T
Expires in six months                                       October 1998

                   A URN Namespace for IETF Documents
                  Filename: draft-ietf-urn-ietf-07.txt

Status of This Memo

      Internet-Drafts are draft documents valid for a maximum of six
      months and may be updated, replaced, or obsoleted by other
      documents at any time.  It is inappropriate to use Internet-
      Drafts as reference material or to cite them other than as ``work
      in progress.''

      To learn the current status of any Internet-Draft, please check
      the ``1id-abstracts.txt'' listing contained in the Internet-
      Drafts Shadow Directories on ftp.is.co.za (Africa), nic.nordu.net
      (Europe), munnari.oz.au (Pacific Rim), ds.internic.net (US East
      Coast), or ftp.isi.edu (US West Coast).

Abstract

   A system for Uniform Resource Names (URNs) must be capable of
   supporting new naming systems.  As an example of proposing a new
   namespace, this document proposes the "ietf" namespace.  This
   namespace consists of the RFC family of documents (RFCs, STDs, FYIs,
   and BCPs) developed by the IETF and published by the RFC Editor, the
   minutes of working groups (WG) and birds of a feather (BOF) meetings
   that occur during IETF conferences, and the Internet Drafts published
   by the Internet Drafts Editor.  Both the current URN framework and
   URN syntax support this namespace.

0.1 Changes from -02

   This document has been restructured to use the template proposed in
   draft-ietf-urn-nid-req-03.txt.  Example Perl scripts for resolving
   this namespace have been supplied in an Appendix.

Expires 4/30/99                                                 [Page 1]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

0.2 Changes from -03

   Text was added to the template clarifying persistence and uniqueness.
   Support for the BCP document series added to the examples and the
   ABNF.

0.3 Changes from -04

   More clarifications for the persistence section.  In addition,
   cleaned up some typos and ensured that the Appendix examples are
   functional

0.4 Changes from -05

   Based on a number of requests, i-ds have been added to the structure
   and resolvers. In addition, some examples have been added.

0.4 Changes from -06

   Some changes of the template to conform with draft-ietf-urn-nid-req-
   06.txt.  Minor editing of some of the sections for more clarity.

1. Introduction

   This document proposes the "ietf" namespace, which consists of the
   RFC family of documents (RFCs, STDs, FYIs, and BCPs) developed by the
   IETF and published by the RFC editor and the minutes of working
   groups (WG) and birds of a feather (BOF) meetings that occur during
   IETF conferences.

   The namespace specification is for a formal namespace.

2. Specification Template

        Namespace ID:

                "ietf" requested.

                Registration version number: 1
                Registration date: 1998-10-09

                Ryan Moats
                [email-masked]

Expires 4/30/99                                                 [Page 2]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

                The identifier has the following ABNF [2] specification:

                NSS = (family ":" number) / ("mtg-" number "-" wgbofname)
                      ( "id:" name)
                family = "rfc" / "std" / "fyi" / "bcp"
                number = 1*DIGIT
                wgbofname = 1*LETDIGIT
                name =  id draft name beginning with "draft-" and trailing
                        type removed (e.g. ietf-urn-ietf-06)
                LETDIGIT = DIGIT / %x41-%x5a / %x61-%x7a
                DIGIT = %x30-%x39

                If the IESG (or it successor) adds a new document
                series, this ABNF specification will need to be
                updated.  Further, if a working group or BOF is
                created that used characters outside the range of this
                ABNF specification, this specification will need to be
                updated.  Any system intended to resolve names for
                this namespace should be written with the awareness
                that this could occur at any time.

                Because the rfc-editor assigns the RFC number uniquely
                these URNs are unique.  Since the mapping between RFCs
                and other rfc-editor document series (STDs, FYIs or
                BCPs) is not necessarily one-to-one, uniqueness of
                STDs, FYIs and BCPs are defined based on the document
                mappings maintained by the RFC Editor (the index files
                "rfc-index.txt", "fyi-index.txt", "bcp-index.txt",
                "std-index.txt") are defined to be the definitive
                statement of the assignment of RFC Family URNs in this
                namespace.  The meeting minutes portion of the
                namespace is guaranteed unique because the URN
                includes the sequence number of the IETF conference.
                The document mapping maintained by the Internet Drafts
                editor ("1id-abstracts.txt") is defined as the
                definitive statement of the assignment of URNs for
                the internet draft portion of this namespace.

                Persistence of the URNs of this namespace is
                independent of the mutability of the underlying
                documents.  A URN once assigned will never be
                reassigned to a different resource; the assignment is

Expires 4/30/99                                                 [Page 3]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

                persistent and immutable.  Distinct from this, the
                resources identified as RFCs are immutable, whereas
                the other sorts of documents, STDs, FYIs, and BCPs are
                not.  They may be composites of one or more RFCs and
                the set of RFCs that includes them may change with
                time.  It is important to note that this mutability of
                some resources is independent of the immutability of
                URN assignment to a resource.

                Assignment of URNs from this namespace occurs in three
                ways.  The first is through publication of a new RFC,
                FYI, STD or BCP is by the RFC Editor. This new document
                will have a new series number and will therefore define
                a new URN.  The document mappings maintained by the
                RFC Editor (the index files "rfc-index.txt",
                "fyi-index.txt", "bcp-index.txt" and "std-index.txt")
                are defined to be the definitive statement of the
                assignment of RFC Family URNs in this namespace.

                The second way a URN is assigned is through the filing
                of meeting minutes by a working group or birds of a
                feather as part of an IETF conference.  The list of
                minutes maintained by the IETF for each working group
                and conference in the subtree pointed at by the URL
                ftp://ietf.org/ietf/ is considered the definitive
                assignment of URNs for working group or birds of a
                feather minutes.

                The third way a URN is assigned is through the
                publication of a new internet-draft by the Internet
                Draft Editor.  This draft will have a distinct name
                (and version number) and therefore defined a new URN.
                The document mapping maintained by the Internet Drafts
                editor ("1id-abstracts.txt") is defined as the
                definitive statement of the assignment of URNs for
                this portion of the namespace.

        Process of identifier resolution:

                A mirrored copy of the underlying documentation is
                required to resolve these URNs.  Resolution via
                HTTP is done by a set of simple Perl cgi-bin
                scripts presented in Appendix A.

Expires 4/30/99                                                 [Page 4]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

                The entire URN is case-insensitive.

                There are no additional characters reserved.

        Validation mechanism:

                None specified.

        Scope:

                Global.

3. Examples

   The following are examples of URNs that a resolver for this namespace
   can resolve:

           urn:ietf:rfc:2141
           urn:ietf:std:50
           urn:ietf:id:ietf-urn-ietf-06.txt
           urn:ietf:mtg-41-urn

4. Security Considerations

   Because this namespace defines no additional reserved characters, it
   does not add any security considerations beyond those inherent from
   the existence of the reserved characters from [1].  Further, none of
   the reserved characters from [1] are used in the definition of the
   NSS. This means that resolvers for this namespace may be considered
   "secure" in the sense that any escaping of characters in the NSS MUST
   result in the resolver indicating that the URN has incorrect syntax.

5. Acknowledgments

   Thanks to various members of the URN working group for comments on
   earlier drafts of this document.  The work described in this document
   is partially supported by the National Science Foundation,
   Cooperative Agreement NCR-9218179.

6. References

   Request For Comments (RFC) and Internet Draft documents are available
   from <URL:ftp://ftp.internic.net> and numerous mirror sites.

         [1]         R. Moats, "URN Syntax," RFC 2141, May 5, 1997.

Expires 4/30/99                                                 [Page 5]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

         [2]         D. Crocker, P. Overell, "Augmented BNF for Syntax
                     Specifications: ABNF," RFC 2234, November 1997.

7. Author's Address

   Ryan Moats
   AT&T
   15621 Drexel Circle
   Omaha, NE 68135-2358
   USA

   Phone:  +1 402 894-9456
   EMail:  [email-masked]

Appendix A.  Example Resolution Scripts

   The following scripts are examples that can be used for resolving
   URNs in this namespace.

A.1 I2C

#!/usr/local/bin/perl

use strict;

#
# this is a URN 2 URC resolver for the ietf namespace
#

my(%cite) = (
  bcp => "/ftp/rfc/bcp-index.txt",
  fyi => "/ftp/fyi/fyi-index.txt",
  id => "/ftp/internet-drafts/1id-abstracts.txt",
  rfc => "/ftp/rfc/rfc-index.txt",
  std => "/ftp/std/std-index.txt"
);
my(%number2date) = (
  41 => "98apr",
  40 => "97dec", 39 => "97aug", 38 => "97apr",
  37 => "96dec", 36 => "96jun", 35 => "96mar",
  34 => "95dec", 33 => "95jul", 32 => "95apr",
  31 => "94dec", 30 => "94jul", 29 => "94mar",
  28 => "93nov", 27 => "93jul", 26 => "93mar",
  25 => "92nov", 24 => "92jul", 23 => "92mar",
  22 => "91nov", 21 => "91jul", 20 => "91mar",
  19 => "90dec" );

my($wgpath) = "/ftp/ietf";

Expires 4/30/99                                                 [Page 6]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

my($urn) = $ENV{'QUERY_STRING'};
my($host) = $ENV{'SERVER_NAME'}; #get my host name for ftp: URLs
my($accept) = $ENV{'HTTP_ACCEPT'}; #this is the "Accept:" HTTP header

(&resolveid($1), exit) if ($urn =~ /urn:ietf:id:(i);
(&resolverfc($1, $2), exit) if ($urn =~ /urn:ietf:(72)/i);
(&resolvemtg($1, $2), exit) if ($urn =~ /urn:ietf:mtg-(9*)-(
120&urn_error("400 Bad Request0);

sub resolvemtg {
  my($ietfnum, $sesnam) = @_;
  &urn_error("404 Not Found0) if (!defined $number2date{$ietfnum});
  my($date)=$number2date{$ietfnum};
  my($link)="$wgpath/$sesnam/$sesnam-minutes-$date.txt";
  if (-f $link) {
    print "Status:  200 OK70;
    print "Content-type: text/html70;
    print "<HTML>0TITLE>Citation for $urn</TITLE>0;
    print "<BODY>0;
    print "<H1><A HREF=
    print "Minutes of the $sesnam working group from the " . &end($ietfnum)
. " IETF";
    print "</BODY>0/HTML>0;
    return;
  }
  my($link)="$wgpath/$date/$sesnam-minutes-$date.txt";
  if (-f $link) {
    print "Status:  200 OK70;
    print "Content-type: text/html70;
    print "<HTML>0TITLE>Citation for $urn</TITLE>0;
    print "<BODY>0;
    print "<H1><A HREF=
    print "Minutes of the $sesnam working group from the " . &end($ietfnum)
. " IETF";
    print "</BODY>0/HTML>0;
    return;
  }
  &urn_error("404 Not Found0);
}

sub end {
  my($inarg)=@_;
  return $inarg . "st" if ($inarg =~ /1$/);
  return $inarg . "nd" if ($inarg =~ /2$/);
  return $inarg . "rd" if ($inarg =~ /3$/);
  return $inarg . "th";
}

sub resolverfc {
  my($flag,@bib,$i,$k,$j,$done,@ref);

Expires 4/30/99                                                 [Page 7]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

  my($l,$link);
  my($scheme, $value) = @_;
  $scheme =~ tr/A-Z/a-z/;
  if (!defined $cite{$scheme}) {
    &urn_error("404 Not Found0);
  }

  $flag = 0;
  open(INPUT, "$cite{$scheme}");
  while (<INPUT>) {
    $flag = 1 if (/^0*$value /);
    if ($flag == 1) {
      last if (/^$/);
      chop;
      push @bib,$_;
    }
  }

  if ($scheme ne "rfc") {
    print "Status:  200 OK70;
    print "Content-type: text/html70;
    $bib[0] =~ s/^[0-9]*/<B>/;
    for ($i=0; $i<=$#bib; $i+=1) {
      last if ($bib[$i] =~ s/./.</B>/);
    }
    for ($i=0;$i<=$#bib;$i+=1) {
      $k=$bib[$i];
      while ($k =~ /(fyi|std|rfc|bcp)([0-9]+)(.*)/i) {
        push @ref,"$1$2";
        $k=$3;
      }
      $done="";
      foreach $j (@ref) {
        next if ($done =~ $j);
        $done .= "$j ";
        $l = $j;
        $l =~ tr/A-Z/a-z/;
        $link=&make_link("$l");
        $bib[$i] =~ s/$j/<A HREF="$link">$j</A>/g;
      }
    }
    print "<HTML>0TITLE>Citation for $urn</TITLE>0;
    print "<BODY>0;
    $link=&make_link("$scheme$value");
    print "<H1><A HREF=
    foreach $i (@bib) {
      print "$i0;
    }

Expires 4/30/99                                                 [Page 8]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

    print "</BODY>0/HTML>0;
  } else {
    print "Status:  200 OK70;
    print "Content-type: text/html70;
    $bib[0] =~ s/^[0-9]*//;
    $j=0;
    for ($i=0; $i<=$#bib; $i+=1) {
      $j += ($bib[$i] =~ s/, "/, <B>"/);
      $j += ($bib[$i] =~ s/",/"</B>,/);
    }
    for ($i=0;$i<=$#bib;$i+=1) {
      $k=$bib[$i];
      while ($k =~ /(fyistdrfc|bcp)([0-9]+)(.*)/i) {
        push @ref,"$1$2";
        $k=$3;
      }
      $done="";
      foreach $j (@ref) {
        next if ($done =~ $j);
        $done .= "$j ";
        $l = $j;
        $l =~ s//g;
        $l =~ tr/A-Z/a-z/;
        $link=&make_link("$l");
        $bib[$i] =~ s/$j/<A HREF="$link">$j</A>/g;
      }
    }
    print "<HTML>0TITLE>Citation for $urn</TITLE>0;
    print "<BODY>0;
    $link=&make_link("$scheme$value");
    print "<H1><A HREF=
    foreach $i (@bib) {
      print "$i0;
    }
    print "</BODY>0/HTML>0;
  }
}

sub make_link {
  my($sc);
  my($inarg)=@_;
  ($sc=$1) if ($inarg =~ /([a-z]*)/);
  return "/$sc/$inarg.ps" if (-e "/ftp/$sc/$inarg.ps");
  return "/$sc/$inarg.html" if (-e "/ftp/$sc/$inarg.html");
  return "/$sc/$inarg.txt";
}

sub urn_error {

Expires 4/30/99                                                 [Page 9]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

  my($code) = @_; #store failure code here...

  print "Status:  $code";
  print "Content-type: text/html0HTML>0;
  print "<head><title>URN Resolution: I2C $code</title></head>0;
  print "<BODY>0;
  print "<h1>URN to URC resolution failed for the URN:</h1>0;
  print "<hr><h3>$urn</h3>0;
  print "</body>0;
  print "</html>0;
  exit;
};

sub resolveid {
  my($flag,@bib,$i,$k,$j,$count,@ref);
  my($l,$link, $hdr, $done);
  my($value) = @_;
  my($scheme) = "id";

  open(INPUT, "$cite{$scheme}");
  while (<INPUT>) {
#
# capture record
#
    if ($flag == 1 || /^
      push @bib,$_;
      ($hdr = -1, $count = 0, $flag = 1) if (/^
      $count++ if (/^/);
    }
    if ($count == 1) {
      $hdr = $#bib if ($hdr == -1);
    }
    if ($count == 2) {
      for ($i=0; $i<=$hdr; $i+=1) {
            if ($bib[$i] =~ /<(.*)>/) {
              $l = $1;
              if ($l eq "draft-$value.txt" || $l eq "draft-$value.ps") {
                print "Status:  200 OK70;
                print "Content-type: text/html70;
                print "<HTML>0TITLE>Citation for $urn</TITLE>0;
                print "<BODY>0;
                print "<a href=
                print "<pre>0;
                foreach $i (@bib) {
                  print "$i";
                }
                print "</pre>0;
                print "</BODY>0/HTML>0;

Expires 4/30/99                                                [Page 10]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

                exit;
              }
            }
      }
      $flag = 0;
      @bib = ();
    }
  }
  &urn_error("404 Not Found0);
}

A.2 I2L

#!/usr/local/bin/perl

use strict;

#
# this is a URN 2 URL resolver for the ietf namespace
#

my(%pathbase) = (
  rfc => "rfc/rfc",
  fyi => "fyi/fyi",
  std => "std/std",
  bcp => "bcp/bcp",
  id => "internet-drafts/draft-",
);

my(%number2date) = (
  41 => "98apr",
  40 => "97dec", 39 => "97aug", 38 => "97apr",
  37 => "96dec", 36 => "96jun", 35 => "96mar",
  34 => "95dec", 33 => "95jul", 32 => "95apr",
  31 => "94dec", 30 => "94jul", 29 => "94mar",
  28 => "93nov", 27 => "93jul", 26 => "93mar",
  25 => "92nov", 24 => "92jul", 23 => "92mar",
  22 => "91nov", 21 => "91jul", 20 => "91mar",
  19 => "90dec" );

my($wgpath) = "/ftp/ietf";
my($urn) = $ENV{'QUERY_STRING'};
my($host) = $ENV{'SERVER_NAME'}; #get my host name for ftp: URLs
my($accept) = $ENV{'HTTP_ACCEPT'}; #this is the "Accept:" HTTP header

(&resolveid($1), exit) if ($urn =~ /urn:ietf:id:(i);
(&resolverfc($1, $2), exit) if ($urn =~ /urn:ietf:(72)/i);
(&resolvemtg($1, $2), exit) if ($urn =~ /urn:ietf:mtg-(9*)-(

Expires 4/30/99                                                [Page 11]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

120&urn_error("400 Bad Request0);

sub resolvemtg {
  my($ietfnum, $sesnam) = @_;
  &urn_error("404 Not Found0) if (!defined $number2date{$ietfnum});
  my($date)=$number2date{$ietfnum};
  my($link)="$wgpath/$sesnam/$sesnam-minutes-$date.txt";
  if (-f $link) {
    print "Status:  302 Moved temporarily0;
    print "Location: $link0;
    return;
  }
  my($link)="$wgpath/$date/$sesnam-minutes-$date.txt";
  if (-f $link) {
    print "Status:  302 Moved temporarily0;
    print "Location: $link0;
    return;
  }
  &urn_error("404 Not Found0);
}

sub end {
  my($inarg)=@_;
  return $inarg . "st" if ($inarg =~ /1$/);
  return $inarg . "nd" if ($inarg =~ /2$/);
  return $inarg . "rd" if ($inarg =~ /3$/);
  return $inarg . "th";
}

sub resolverfc {
  my($flag,@bib,$i,$k,$j,$done,@ref);
  my($l,$link);
  my($scheme, $value) = @_;
  $scheme =~ tr/A-Z/a-z/;
  &urn_error("404 Not Found0)if (!defined $pathbase{$scheme});
  my($txttry)="/ftp/$pathbase{$scheme}$value.txt";
  my($pstry)="/ftp/$pathbase{$scheme}$value.ps";
  my($htmltry)="/ftp/$pathbase{$scheme}$value.html";
MIME_SWITCH: {
    if ($accept =~ /application/postscript/ && -f $pstry) {
      print "Status:  302 Moved temporarily0;
      print "Location: http://$host/$pathbase{$scheme}$value.ps0;
      last MIME_SWITCH;
    }
    if ($accept =~ /text/html/ && -f $htmltry) {
      print "Status:  302 Moved temporarily0;
      print "Location: http://$host/$pathbase{$scheme}$value.html0;
      last MIME_SWITCH;

Expires 4/30/99                                                [Page 12]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

    }
    if ($accept =~ /text/plain/ && -f $txttry) {
      print "Status:  302 Moved temporarily0;
      print "Location: http://$host/$pathbase{$scheme}$value.txt0;
      last MIME_SWITCH;
    }
    &urn_error("404 Not Found0);
  }
}

sub urn_error {
  my($code) = @_; #store failure code here...

  print "Status:  $code";
  print "Content-type: text/html0HTML>0;
  print "<head><title>URN Resolution: I2L $code</title></head>0;
  print "<BODY>0;
  print "<h1>URN to URL resolution failed for the URN:</h1>0;
  print "<hr><h3>$urn</h3>0;
  print "</body>0;
  print "</html>0;
  exit;
}

sub resolveid {
  my($flag,@bib,$i,$k,$j,$done,@ref);
  my($l,$link);
  my($scheme) = "id";
  my($value) = @_;
  $scheme =~ tr/A-Z/a-z/;
  &urn_error("404 Not Found0)if (!defined $pathbase{$scheme});
  my($txttry)="/ftp/$pathbase{$scheme}$value.txt";
  my($pstry)="/ftp/$pathbase{$scheme}$value.ps";
  my($htmltry)="/ftp/$pathbase{$scheme}$value.html";
MIME_SWITCH: {
    if ($accept =~ /application/postscript/ && -f $pstry) {
      print "Status:  302 Moved temporarily0;
      print "Location: http://$host/$pathbase{$scheme}$value.ps0;
      last MIME_SWITCH;
    }
    if ($accept =~ /text/html/ && -f $htmltry) {
      print "Status:  302 Moved temporarily0;
      print "Location: http://$host/$pathbase{$scheme}$value.html0;
      last MIME_SWITCH;
    }
    if ($accept =~ /text/plain/ && -f $txttry) {
      print "Status:  302 Moved temporarily0;
      print "Location: http://$host/$pathbase{$scheme}$value.txt0;

Expires 4/30/99                                                [Page 13]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

      last MIME_SWITCH;
    }
    &urn_error("404 Not Found0);
  }
}

A.3 I2Ls

#!/usr/local/bin/perl

use strict;

#
# this is a URN 2 URLs resolver for the ietf namespace
#

my(@urls);

my(%pathbase) = (
  rfc => "rfc/rfc",
  fyi => "fyi/fyi",
  std => "std/std",
  bcp => "bcp/bcp",
             id => "internet-drafts/draft-"
);

my(%number2date) = (
  41 => "98apr",
  40 => "97dec", 39 => "97aug", 38 => "97apr",
  37 => "96dec", 36 => "96jun", 35 => "96mar",
  34 => "95dec", 33 => "95jul", 32 => "95apr",
  31 => "94dec", 30 => "94jul", 29 => "94mar",
  28 => "93nov", 27 => "93jul", 26 => "93mar",
  25 => "92nov", 24 => "92jul", 23 => "92mar",
  22 => "91nov", 21 => "91jul", 20 => "91mar",
  19 => "90dec" );

my($wgpath) = "/ftp/ietf";
my($urn) = $ENV{'QUERY_STRING'};
my($host) = $ENV{'SERVER_NAME'}; #get my host name for ftp: URLs
my($accept) = $ENV{'HTTP_ACCEPT'}; #this is the "Accept:" HTTP header

(&resolveid($1), exit) if ($urn =~ /urn:ietf:id:(i);
(&resolve1($1, $2), exit) if ($urn =~ /urn:ietf:(72)/i);
(&resolve2($1, $2), exit) if ($urn =~ /urn:ietf:mtg-(9*)-(
120&urn_error("400 Bad Request0);

sub resolve2 {

Expires 4/30/99                                                [Page 14]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

  my($ietfnum, $sesnam) = @_;
  &urn_error("404 Not Found0) if (!defined $number2date{$ietfnum});
  my($date)=$number2date{$ietfnum};
  my($link)="$wgpath/$sesnam/$sesnam-minutes-$date.txt";
  if (-f $link) {
    $link=~s/^/ftp///;
    my($ftplink)="ftp://$host/$link";
    my($httplink)="http://$host/$link";
    my($glink)="gopher://$host:70/0/$link";
    if ($accept =~ /text/uri-list/) { #look for text/uri-list, otherwise
text/html
      print "Status: 200 OK0;
      print "Content-type: text/uri-list0;
      print "#$urn0;
      print "$ftplink0;
      print "$httplink0;
      print "$glink0;
    }
    if ($accept =~ /text/html/) {
      print "Status: 200 OK0;
      print "Content-type: text/html0HTML>0;
      print "<head><title>URN Resolution: I2Ls</title></head>0;
      print "<BODY>0;
      print "<h1>URN $urn resolves to the following URLs:</h1>0;
      print "<hr><ul>0;
      print "<a href=
      print "<a href=
      print "<a href=
      print "</UL>0/body>0/HTML>0;
    }
    return;
  }
  my($link)="$wgpath/$date/$sesnam-minutes-$date.txt";
  if (-f $link) {
    $link=~s/^/ftp///;
    my($ftplink)="ftp://$host/$link";
    my($httplink)="http://$host/$link";
    my($glink)="gopher://$host:70/0/$link";
    if ($accept =~ /text/uri-list/) { #look for text/uri-list, otherwise
text/html
      print "Status: 200 OK0;
      print "Content-type: text/uri-list0;
      print "#$urn0;
      print "$ftplink0;
      print "$httplink0;
      print "$glink0;
    }
    if ($accept =~ /text/html/) {
      print "Status: 200 OK0;
      print "Content-type: text/html0HTML>0;

Expires 4/30/99                                                [Page 15]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

      print "<head><title>URN Resolution: I2Ls</title></head>0;
      print "<BODY>0;
      print "<h1>URN $urn resolves to the following URLs:</h1>0;
      print "<hr><ul>0;
      print "<a href=
      print "<a href=
      print "<a href=
      print "</UL>0/body>0/HTML>0;
    }
    return;
  }
  &urn_error("404 Not Found0);
}

sub resolve1 {
  my($flag,@bib,$i,$k,$j,$done,@ref);
  my($l,$link);
  my($scheme, $value) = @_;
  $scheme =~ tr/A-Z/a-z/;
  &urn_error("404 Not Found0)if (!defined $pathbase{$scheme});
  my($try)="/ftp/$pathbase{$scheme}$value.txt";
  if (-f $try) {
    push(@urls, "http://$host/$pathbase{$scheme}$value.txt");
    push(@urls, "ftp://$host/$pathbase{$scheme}$value.txt");
    push(@urls, "gopher://$host:70/0/$pathbase{$scheme}$value.txt");
  }
  $try="/ftp/$pathbase{$scheme}$value.ps";
  if (-f $try) {
    push(@urls, "http://$host/$pathbase{$scheme}$value.ps");
    push(@urls, "ftp://$host/$pathbase{$scheme}$value.ps");
    push(@urls, "gopher://$host:70/0/$pathbase{$scheme}$value.ps");
  }
  $try="/ftp/$pathbase{$scheme}$value.html";
  if (-f $try) {
    push(@urls, "http://$host/$pathbase{$scheme}$value.html");
    push(@urls, "ftp://$host/$pathbase{$scheme}$value.html");
  }

  &urn_error("404 Not Found0) if ($#urls == -1);

MIME_SWITCH: {
    if ($accept =~ /text/uri-list/) { #look for text/uri-list, otherwise
text/html
      print "Status: 200 OK0;
      print "Content-type: text/uri-list0;
      print "#$urn0;
      foreach $i (@urls) {
        print "$i0;
      }

Expires 4/30/99                                                [Page 16]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

      last MIME_SWITCH;
    }
    if ($accept =~ /text/html/) {
      print "Status: 200 OK0;
      print "Content-type: text/html0HTML>0;
      print "<head><title>URN Resolution: I2Ls</title></head>0;
      print "<BODY>0;
      print "<h1>URN $urn resolves to the following URLs:</h1>0;
      print "<hr><ul>0;
      foreach $i (@urls) {
        print "<LI><A HREF=
      }
      print "</UL>0/body>0/HTML>0;
      last MIME_SWITCH;
    }
  }
}

sub urn_error {
  my($code) = @_; #store failure code here...

  print "Status: $code";
  print "Content-type: text/html0HTML>0;
  print "<head><title>URN Resolution: I2L $code</title></head>0;
  print "<BODY>0;
  print "<h1>URN to URL resolution failed for the URN:</h1>0;
  print "<hr><h3>$urn</h3>0;
  print "</body>0;
  print "</html>0;
  exit;
}

sub resolveid {
  my($flag,@bib,$i,$k,$j,$done,@ref);
  my($l,$link);
  my($value) = @_;
  my($scheme) = "id";
  $scheme =~ tr/A-Z/a-z/;
  &urn_error("404 Not Found0)if (!defined $pathbase{$scheme});
  my($try)="/ftp/$pathbase{$scheme}$value.txt";
  if (-f $try) {
    push(@urls, "http://$host/$pathbase{$scheme}$value.txt");
    push(@urls, "ftp://$host/$pathbase{$scheme}$value.txt");
    push(@urls, "gopher://$host:70/0/$pathbase{$scheme}$value.txt");
  }
  $try="/ftp/$pathbase{$scheme}$value.ps";
  if (-f $try) {
    push(@urls, "http://$host/$pathbase{$scheme}$value.ps");

Expires 4/30/99                                                [Page 17]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

    push(@urls, "ftp://$host/$pathbase{$scheme}$value.ps");
    push(@urls, "gopher://$host:70/0/$pathbase{$scheme}$value.ps");
  }
  $try="/ftp/$pathbase{$scheme}$value.html";
  if (-f $try) {
    push(@urls, "http://$host/$pathbase{$scheme}$value.html");
    push(@urls, "ftp://$host/$pathbase{$scheme}$value.html");
  }

  &urn_error("404 Not Found0) if ($#urls == -1);

MIME_SWITCH: {
    if ($accept =~ /text/uri-list/) { #look for text/uri-list, otherwise
text/html
      print "Status: 200 OK0;
      print "Content-type: text/uri-list0;
      print "#$urn0;
      foreach $i (@urls) {
        print "$i0;
      }
      last MIME_SWITCH;
    }
    if ($accept =~ /text/html/) {
      print "Status: 200 OK0;
      print "Content-type: text/html0HTML>0;
      print "<head><title>URN Resolution: I2Ls</title></head>0;
      print "<BODY>0;
      print "<h1>URN $urn resolves to the following URLs:</h1>0;
      print "<hr><ul>0;
      foreach $i (@urls) {
        print "<LI><A HREF=
      }
      print "</UL>0/body>0/HTML>0;
      last MIME_SWITCH;
    }
  }
}

A.4 I2Ns

#!/usr/local/bin/perl

use strict;

#
# this is a URN 2 URNs resolver for the ietf namespace
#

my(%cite) = (

Expires 4/30/99                                                [Page 18]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

  rfc => "/ftp/rfc/rfc-index.txt",
  fyi => "/ftp/fyi/fyi-index.txt",
  std => "/ftp/std/std-index.txt",
  bcp => "/ftp/rfc/bcp-index.txt"
);

my(%number2date) = (
  41 => "98apr",
  40 => "97dec", 39 => "97aug", 38 => "97apr",
  37 => "96dec", 36 => "96jun", 35 => "96mar",
  34 => "95dec", 33 => "95jul", 32 => "95apr",
  31 => "94dec", 30 => "94jul", 29 => "94mar",
  28 => "93nov", 27 => "93jul", 26 => "93mar",
  25 => "92nov", 24 => "92jul", 23 => "92mar",
  22 => "91nov", 21 => "91jul", 20 => "91mar",
  19 => "90dec" );

my($wgpath) = "/ftp/ietf";
my($urn) = $ENV{'QUERY_STRING'};
my($host) = $ENV{'SERVER_NAME'}; #get my host name for ftp: URLs
my($port) = $ENV{'SERVER_PORT'};
my($accept) = $ENV{'HTTP_ACCEPT'}; #this is the "Accept:" HTTP header

(&resolve1("id", $1), exit) if ($urn =~ /urn:ietf:id:(/i);
(&resolve1($1, $2), exit) if ($urn =~ /urn:ietf:(72)/i);
(&resolve2($1, $2), exit) if ($urn =~ /urn:ietf:mtg-(9*)-(
120&urn_error("400 Bad Request0);

sub resolve2 {
  my($ietfnum, $sesnam) = @_;
  &urn_error("404 Not Found0) if (!defined $number2date{$ietfnum});
  my($date)=$number2date{$ietfnum};
  my($link)="$wgpath/$sesnam/$sesnam-minutes-$date.txt";
  if (-f $link) {
    if ($accept =~ /text/uri-list/) {
        print "Status: 200 OK0;
        print "Content-type: text/uri-list0;
        print "#$urn0;
        return;
    }
    if ($accept =~ /text/html/) {
      print "Status: 200 OK0;
      print "Content-type: text/html0HTML>0;
      print "<head><title>URN Resolution: I2Ns</title></head>0;
      print "<BODY>0;
      print "<h1>URN $urn resolves to the following URNs:</h1>0;
      print "<hr><ul>0;
      print "</UL>0/body>0/HTML>0;

Expires 4/30/99                                                [Page 19]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

      return;
    }
  }
  my($link)="$wgpath/$date/$sesnam-minutes-$date.txt";
  if (-f $link) {
    if ($accept =~ /text/uri-list/) {
        print "Status: 200 OK0;
        print "Content-type: text/uri-list0;
        print "#$urn0;
        return;
    }
    if ($accept =~ /text/html/) {
        print "Status: 200 OK0;
        print "Content-type: text/html0HTML>0;
        print "<head><title>URN Resolution: I2Ns</title></head>0;
        print "<BODY>0;
        print "<h1>URN $urn resolves to the following URNs:</h1>0;
        print "<hr><ul>0;
        print "</UL>0/body>0/HTML>0;
        return;
    }
  }
  &urn_error("404 Not Found0);
}

sub end {
  my($inarg)=@_;
  return $inarg . "st" if ($inarg =~ /1$/);
  return $inarg . "nd" if ($inarg =~ /2$/);
  return $inarg . "rd" if ($inarg =~ /3$/);
  return $inarg . "th";
}

sub resolve1 {
  my($flag,@bib,$i,$k,$j,$done,@ref);
  my($l,$link);
  my($scheme, $value) = @_;
  $scheme =~ tr/A-Z/a-z/;
  if (!defined $cite{$scheme}) {
    &urn_error("404 Not Found0);
  }

  $flag = 0;
  open(INPUT, "$cite{$scheme}");
  while (<INPUT>) {
    $flag = 1 if (/^0*$value /);
    if ($flag == 1) {
      last if (/^$/);

Expires 4/30/99                                                [Page 20]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

      chop;
      push @bib,$_;
    }
  }

  $k=join " ",@bib;
  while ($k =~ /(fyi|std|rfc|bcp)([0-9]+)(.*)/i) {
    $k=$4;
    $a=$2; $b=$3;
    if (($a ne $scheme || $b ne $value) && ($1 !~ /obso/i)){
      $a =~ tr/A-Z/a-z/;
      $b =~ s/^0*//;
      push @ref,"urn:ietf:$a:$b";
    }
  }

MIME_SWITCH: {
    if ($accept =~ /text/uri-list/) {
        print "Status: 200 OK0;
        print "Content-type: text/uri-list0;
        print "#$urn0;
        foreach $i (@ref) {
            print "$i0;
        }
        last MIME_SWITCH;
    }
  if ($accept =~ /text/html/) {
    print "Status: 200 OK0;
    print "Content-type: text/html0HTML>0;
    print "<head><title>URN Resolution: I2Ns</title></head>0;
    print "<BODY>0;
    print "<h1>URN $urn resolves to the following URNs:</h1>0;
    print "<hr><ul>0;
        foreach $i (@ref) {
            print "<li>$i: Click to resolve using0;
            print "<a href=
            print "<a href=
            print "<a href=
            print "<a href=
            print "<a href=
        }
    print "</UL>0/body>0/HTML>0;
  }
}
}

sub make_link {
  my($sc);

Expires 4/30/99                                                [Page 21]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

  my($inarg)=@_;
  ($sc=$1) if ($inarg =~ /([a-z]*)/);
  return "/$sc/$inarg.ps" if (-e "/ftp/$sc/$inarg.ps");
  return "/$sc/$inarg.html" if (-e "/ftp/$sc/$inarg.html");
  return "/$sc/$inarg.txt";
}

sub urn_error {
  my($code) = @_; #store failure code here...

  print "Status: $code";
  print "Content-type: text/html0HTML>0;
  print "<head><title>URN Resolution: I2Ns $code</title></head>0;
  print "<BODY>0;
  print "<h1>URN to URN resolution failed for the URN:</h1>0;
  print "<hr><h3>$urn</h3>0;
  print "</body>0;
  print "</html>0;
  exit;
};

A.5 I2R

#!/usr/local/bin/perl

use strict;

#
# this is a URN 2 resource resolver for the ietf namespace
#

my(%pathbase) = (
  rfc => "rfc/rfc",
  fyi => "fyi/fyi",
  std => "std/std",
  bcp => "bcp/bcp",
  id => "internet-drafts/draft-"
);

my(%number2date) = (
  41 => "98apr",
  40 => "97dec", 39 => "97aug", 38 => "97apr",
  37 => "96dec", 36 => "96jun", 35 => "96mar",
  34 => "95dec", 33 => "95jul", 32 => "95apr",
  31 => "94dec", 30 => "94jul", 29 => "94mar",
  28 => "93nov", 27 => "93jul", 26 => "93mar",
  25 => "92nov", 24 => "92jul", 23 => "92mar",

Expires 4/30/99                                                [Page 22]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

  22 => "91nov", 21 => "91jul", 20 => "91mar",
  19 => "90dec" );

my($wgpath) = "/ftp/ietf";
my($urn) = $ENV{'QUERY_STRING'};
my($host) = $ENV{'SERVER_NAME'}; #get my host name for ftp: URLs
my($accept) = $ENV{'HTTP_ACCEPT'}; #this is the "Accept:" HTTP header

print "$urn0;
(&resolveid($1), exit) if ($urn =~ /urn:ietf:id:(i);
(&resolve1($1, $2), exit) if ($urn =~ /urn:ietf:(72)/i);
(&resolve2($1, $2), exit) if ($urn =~ /urn:ietf:mtg-(9*)-(
120&urn_error("400 Bad Request0);

sub resolve2 {
  my($ietfnum, $sesnam) = @_;
  &urn_error("404 Not Found0) if (!defined $number2date{$ietfnum});
  my($date)=$number2date{$ietfnum};
  my($link)="$wgpath/$sesnam/$sesnam-minutes-$date.txt";
  if (-f $link) {
      print "Status:  200 OK0;
      print "Content-type: text/plain0;
      open(FILE, "$link");
      while (<FILE>) {
          print $_;
      }
      close FILE;
    return;
  }
  my($link)="$wgpath/$date/$sesnam-minutes-$date.txt";
  if (-f $link) {
      print "Status:  200 OK0;
      print "Content-type: text/plain0;
      open(FILE, "$link");
      while (<FILE>) {
          print $_;
      }
      close FILE;
    return;
  }
  &urn_error("404 Not Found0);
}

sub end {
  my($inarg)=@_;
  return $inarg . "st" if ($inarg =~ /1$/);
  return $inarg . "nd" if ($inarg =~ /2$/);
  return $inarg . "rd" if ($inarg =~ /3$/);

Expires 4/30/99                                                [Page 23]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

  return $inarg . "th";
}

sub resolve1 {
  my($flag,@bib,$i,$k,$j,$done,@ref);
  my($l,$link);
  my($scheme, $value) = @_;
  $scheme =~ tr/A-Z/a-z/;
  &urn_error("404 Not Found0)if (!defined $pathbase{$scheme});
  my($txttry)="/ftp/$pathbase{$scheme}$value.txt";
  my($pstry)="/ftp/$pathbase{$scheme}$value.ps";
  my($htmltry)="/ftp/$pathbase{$scheme}$value.html";
MIME_SWITCH: {
    if ($accept =~ /application/postscript/ && -f $pstry) {
      print "Status:  200 OK0;
      print "Content-type: application/postscript0;
      open(FILE, "$pstry");
      while (<FILE>) {
          print $_;
      }
      close FILE;
      last MIME_SWITCH;
    }
    if ($accept =~ /text/html/ && -f $htmltry) {
        print "Status:  200 OK0;
        print "Content-type: text/html0;
        open(FILE, "$htmltry");
        while (<FILE>) {
            print $_;
        }
        close FILE;
        last MIME_SWITCH;
    }
    if ($accept =~ /text/plain/ && -f $txttry) {
        print "Status:  200 OK0;
        print "Content-type: text/plain0;
        open(FILE, "$txttry");
        while (<FILE>) {
            print $_;
        }
        close FILE;
        last MIME_SWITCH;
    }
    &urn_error("404 Not Found0);
  }
}

sub resolveid {

Expires 4/30/99                                                [Page 24]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

  my($flag,@bib,$i,$k,$j,$done,@ref);
  my($l,$link);
  my($scheme) = "id";
  my($value) = @_;
  $scheme =~ tr/A-Z/a-z/;
  &urn_error("404 Not Found0)if (!defined $pathbase{$scheme});
  my($txttry)="/ftp/$pathbase{$scheme}$value.txt";
  my($pstry)="/ftp/$pathbase{$scheme}$value.ps";
  my($htmltry)="/ftp/$pathbase{$scheme}$value.html";
MIME_SWITCH: {
    if ($accept =~ /application/postscript/ && -f $pstry) {
      print "Status:  200 OK0;
      print "Content-type: application/postscript0;
      open(FILE, "$pstry");
      while (<FILE>) {
          print $_;
      }
      close FILE;
      last MIME_SWITCH;
    }
    if ($accept =~ /text/html/ && -f $htmltry) {
        print "Status:  200 OK0;
        print "Content-type: text/html0;
        open(FILE, "$htmltry");
        while (<FILE>) {
            print $_;
        }
        close FILE;
        last MIME_SWITCH;
    }
    if ($accept =~ /text/plain/ && -f $txttry) {
        print "Status:  200 OK0;
        print "Content-type: text/plain0;
        open(FILE, "$txttry");
        while (<FILE>) {
            print $_;
        }
        close FILE;
        last MIME_SWITCH;
    }
    &urn_error("404 Not Found0);
  }
}

sub urn_error {
  my($code) = @_; #store failure code here...

  print "Status:  $code";

Expires 4/30/99                                                [Page 25]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

  print "Content-type: text/html0HTML>0;
  print "<head><title>URN Resolution: I2R $code</title></head>0;
  print "<BODY>0;
  print "<h1>URN to URL resolution failed for the URN:</h1>0;
  print "<hr><h3>$urn</h3>0;
  print "</body>0;
  print "</html>0;
  exit;
}

A.6 I2Rs

#!/usr/local/bin/perl

use strict;

#
# this is a URN 2 resources resolver for the ietf namespace
#

my(@urls);

my(%pathbase) = (
  rfc => "rfc/rfc",
  fyi => "fyi/fyi",
  std => "std/std",
  bcp => "bcp/bcp",
  id => "internet-drafts/draft-"
);

my(%number2date) = (
  41 => "98apr",
  40 => "97dec", 39 => "97aug", 38 => "97apr",
  37 => "96dec", 36 => "96jun", 35 => "96mar",
  34 => "95dec", 33 => "95jul", 32 => "95apr",
  31 => "94dec", 30 => "94jul", 29 => "94mar",
  28 => "93nov", 27 => "93jul", 26 => "93mar",
  25 => "92nov", 24 => "92jul", 23 => "92mar",
  22 => "91nov", 21 => "91jul", 20 => "91mar",
  19 => "90dec" );

my($wgpath) = "/ftp/ietf";
my($urn) = $ENV{'QUERY_STRING'};
my($host) = $ENV{'SERVER_NAME'}; #get my host name for ftp: URLs
my($accept) = $ENV{'HTTP_ACCEPT'}; #this is the "Accept:" HTTP header

(&resolveid($1), exit) if ($urn =~ /urn:ietf:id:()/i);

Expires 4/30/99                                                [Page 26]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

(&resolve1($1, $2), exit) if ($urn =~ /urn:ietf:(72)/i);
(&resolve2($1, $2), exit) if ($urn =~ /urn:ietf:mtg-(9*)-(
120&urn_error("400 Bad Request0);

sub resolve2 {
  my($ietfnum, $sesnam) = @_;
  my(@vers,$i);
  &urn_error("404 Not Found0) if (!defined $number2date{$ietfnum});
  my($date)=$number2date{$ietfnum};
  my($link)="$wgpath/$sesnam/$sesnam-minutes-$date.txt";
  if (-f $link) {
      push(@vers,$link);
  }
  $link="$wgpath/$date/$sesnam-minutes-$date.txt";
  if (-f $link) {
      push(@vers,$link);
  }
  &urn_error("404 Not Found0) if ($#vers==-1);

  print "Status: 200 OK0;
  print "Content-type: multipart/alternative; boundary=endpart0;
  foreach $i (@vers) {
      print "--endpart0;
      if ($i =~ /html$/) {
          print "Content-Type: text/html0;
      }
      if ($i =~ /txt$/) {
          print "Content-Type: text/plain0;
      }
      if ($i =~ /ps$/) {
          print "Content-Type: application/postscript0;
      }
      open(FILE, "$i");
      while (<FILE>) {
          print "$_";
      }
      close FILE;
  }
  print "--endpart0;
}

sub resolve1 {
  my($flag,@bib,$i,$k,$j,$done,@ref);
  my($l,$link,@vers);
  my($scheme, $value) = @_;
  $scheme =~ tr/A-Z/a-z/;
  &urn_error("404 Not Found0)if (!defined $pathbase{$scheme});
  my($try)="/ftp/$pathbase{$scheme}$value.txt";

Expires 4/30/99                                                [Page 27]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

  if (-f $try) {
      push(@vers, $try);
  }
  $try="/ftp/$pathbase{$scheme}$value.ps";
  if (-f $try) {
      push(@vers, $try);
  }
  $try="/ftp/$pathbase{$scheme}$value.html";
  if (-f $try) {
      push(@vers, $try);
  }
  print "Status: 200 OK0;
  print "Content-type: multipart/alternative; boundary=endpart0;
  foreach $i (@vers) {
      print "--endpart0;
      if ($i =~ /html$/) {
          print "Content-Type: text/html0;
      }
      if ($i =~ /txt$/) {
          print "Content-Type: text/plain0;
      }
      if ($i =~ /ps$/) {
          print "Content-Type: application/postscript0;
      }
      open(FILE, "$i");
      while (<FILE>) {
          print "$_";
      }
      close FILE;
  }
  print "--endpart0;
}

sub resolveid {
  my($flag,@bib,$i,$k,$j,$done,@ref);
  my($l,$link,@vers);
  my($scheme) = "id";
  my($value) = @_;
  $scheme =~ tr/A-Z/a-z/;
  &urn_error("404 Not Found0)if (!defined $pathbase{$scheme});
  my($try)="/ftp/$pathbase{$scheme}$value.txt";
  if (-f $try) {
      push(@vers, $try);
  }
  $try="/ftp/$pathbase{$scheme}$value.ps";
  if (-f $try) {
      push(@vers, $try);
  }

Expires 4/30/99                                                [Page 28]

INTERNET DRAFT     A URN Namespace for IETF Documents       October 1998

  $try="/ftp/$pathbase{$scheme}$value.html";
  if (-f $try) {
      push(@vers, $try);
  }
  print "Status: 200 OK0;
  print "Content-type: multipart/alternative; boundary=endpart0;
  foreach $i (@vers) {
      print "--endpart0;
      if ($i =~ /html$/) {
          print "Content-Type: text/html0;
      }
      if ($i =~ /txt$/) {
          print "Content-Type: text/plain0;
      }
      if ($i =~ /ps$/) {
          print "Content-Type: application/postscript0;
      }
      open(FILE, "$i");
      while (<FILE>) {
          print "$_";
      }
      close FILE;
  }
  print "--endpart0;
}
sub urn_error {
  my($code) = @_; #store failure code here...

  print "Status: $code";
  print "Content-type: text/html0HTML>0;
  print "<head><title>URN Resolution: I2Rs $code</title></head>0;
  print "<BODY>0;
  print "<h1>URN to URL resolution failed for the URN:</h1>0;
  print "<hr><h3>$urn</h3>0;
  print "</body>0;
  print "</html>0;
  exit;
}

Expires 4/30/99                                                [Page 29]

---

From: "Larry Masinter" <[email-masked]>
Date: Fri, 9 Oct 1998 10:53:16 PDT

> I.e. from some countries (not few), there are "questions" whether the 

But is the URN space hierarchical? It would seem that at least according
to the proposed "URN Namespace Definition Mechanisms", that each namespace
is expected to have consistent set features for the namespace. Are you
imagining something like this?

urn:us:ca:license:3URN101    California license plates
urn:us:ssn:459-82-0101       social security numbers
urn:us:tax:100-25-0717       taxpayer ID

but each of these sub-namespaces have different 'communities'
uniqueness considerations, persistence considerations, etc.

The syntax in RFC 2141 suggests that a namespace is just first part.

I would imagine that given the use of "-" as a possible delimiter for
namespaces, that the syntax actually should be

urn:us-ca-license:3URN101
urn:us-ssn:459-82-0101
urn:us-tax:100-25-0717

if a namespace is expected to have consistent values for the
elements of the template in draft-ietf-urn-nid-req, or else
you're actually defining hierarchical namespaces, where "us:ca:license"
is a namespace designator.

Am I misunderstanding something about the intention of having a
registration form for namespaces?

Do you want to reserve all namespaces that start with two letters
and then a "-"?

Larry
-- 
http://www.parc.xerox.com/masinter

---

From: [email-masked] (Claus André Färber)
Date: 10 Oct 1998 14:36:00 +0200

> imagining something like this?

I don't think so. The propsed Mechanisms are so open that you could  
certainly register a namespace that -- as a consistent set of features  
-- is subdividable into several namespaces by the same rules.

The draft even clearly mentions the possibility of subdividing  
(partitioning) namespaces.

--
Claus Andre Faerber <http://www.muc.de/~cfaerber/> Fax: +49_8061_3361
PGP: ID=1024/527CADCD FP=12 20 49 F3 E1 04 9E 9E  25 56 69 A5 C6 A0 C9 DC

---

From: [email-masked] (Claus André Färber)
Date: 10 Oct 1998 14:26:00 +0200

> 		above), is not already a registered NID, and is more
- 		ALL two-letter combinations are reserved for use
+                 ALL two-letter combinations as well as names that
+                 start with a two-letter combination followed by a
+                 hyphen are reserved for use
> 		standard IETF RFC update mechanisms.  Thus, proposals for

This leaves the issue whether to use urn:de:xyz: or urn:de-xyz: open.

---

From: [email-masked] (Claus André Färber)
Date: 10 Oct 1998 13:09:00 +0200

>                 LETDIGIT = DIGIT / %x41-%x5a / %x61-%x7a

Can you clean that up a bit?

Especially the name part needs either angle brackets or better a  
complete syntax:

         name           = "draft" "-" draft-name "-" draft-version

         draft-name     = draft-ietf / draft-individual
         draft-ietf     = "ietf" "-" wgbofname "-" draft-title
         draft-individual = draft-author "-" draft-title
         draft-title    = draft-namepart *( "-" draft-namepart )

         draft-author   = 1*(DIGIT/ALPHA)
         draft-nameart  = 1*(DIGIT/ALPHA)
         wgbofname      = 1*(DIGIT/ALPHA)
         number         = 1*DIGIT
         draft-version  = 2*DIGIT

         (DIGIT and ALPHA) are in the RFC 2234 Core Ruleset, so I don't
         think you need to or should redefine it.)

---

From: "Larry Masinter" <[email-masked]>
Date: Sat, 10 Oct 1998 22:21:31 PDT

> (partitioning) namespaces.

draft-ietf-urn-nid-req-06.txt clearly mentions the possibility
of subdividing the name space in order to delegate the assignment
of uniqueness, as happens, for example, with ISBN numbers, where
each publisher is delegated the authority of keeping their part
of the name space unique.

However, in the case of urn:us:ssn:001-101-4452 and
urn:us:ca:license:7URN123, this is not merely a delegation
for the purpose of uniqueness, but a separation of the namespace
into subspaces which will differ for every attribute in the
template given in draft-ietf-urn-nid-req-06.txt.

If you go through the fields in the draft:
   Registration Information
       Suppose that california changes their license plate registration
       mechanism in 2002, while the US changes social security numbers
       in 2014. The versioning of the name spaces would occur at
       different times.
   Declared registrant of the namespace
       This would migrate
   Declaration of syntactic structure
       Unlike the ISBN example where there is a uniform syntactic structure,
       the structure of license plates and social security numbers are
       different. Each "subnamespace" is likely to have a different
       syntactic structure.
   Relevant ancillary documentation
       The documentation for describing the rules of license plate
       numbers and vanity plates are different documents than those
       that describe the assignment of social security numbers.
   Identifier uniqueness considerations
       These are likely to differ for each subnamespace.

It would seem that these can't be easily handled by  having a 
country-code URN namespace then having the country parcel it out
for country-unique spaces. I could imagine reserving the names
"xx-<blah>" for country xx, so that "us-ssn" would be recommended
over "ssn" to distinguish it from "dk-ssn", but I'd think that
each of these should be registered separately.

Larry

---

From: "Ryan Moats" <[email-masked]>
Date: Mon, 12 Oct 1998 13:12:04 -0500

Thanks,
>          think you need to or should redefine it.)

I have used this as the basis for a new "name" declaration in -08.  I'll
wait
until the end of the month before recycling to get more comments.

Ryan

---

From: Patrik Fältström <[email-masked]>
Date: Mon, 12 Oct 1998 20:22:56 +0200

>each of these should be registered separately.

Are you saying that we will end up having problems with the resolution 
mechanism, when we define resolution for the "top-level" for a 
country-code, but for further resolution, one have to look at the 
resolution mechanisms defined by each one of the "parcels" the country has 
delegated?

I.e. your question has to do with how resolution is provided, and how 
discovery of resolution mechanisms is done?

Michael, Ryan, have you been thinking of this?

   paf

---

From: Michael Mealling <[email-masked]>
Date: Mon, 12 Oct 1998 15:34:57 -0400 (EDT)

> Michael, Ryan, have you been thinking of this?

I'm still not sure what the issue is. From the document it seems
that the request is that for a namespace that is administratively
specific to a country that it should be preceeded by that countries
country code. This seems reasonable. Now, if we're going to generalize
it out to just general hierarchy then that doesn't seem resonable.
I.e. the minor problem we're trying to solve with country codes doesn't
deserve to be handled by a sledgehammer...

Can someone explain the problem a bit better?

-MM

-- 
--------------------------------------------------------------------------------
Michael Mealling	|      Vote Libertarian!       | www.rwhois.net/michael
Sr. Research Engineer   |   www.ga.lp.org/gwinnett     | ICQ#:         14198821
Network Solutions	|          www.lp.org          |  [email-masked]

---

From: Patrik Fältström <[email-masked]>
Date: Tue, 13 Oct 1998 05:52:37 +0200

At 15.34 -0400 98-10-12, Michael Mealling wrote:
>Now, if we're going to generalize

I think what Larry wanted was the possibility that you used different 
resolution mechanisms for urn:us:ca:license-plates: and 
urn:us:social-security-numbers: and urn:se:personnummer: (the last is 
social security numbers in Swedish -- just to pick a different name for the 
same function).

Then, the licenseplate registry in California changes resolution mechanism.

Is that possible? I guess what is needed is that the namespace itself have 
to have some very complicated resolution mechanism for all it's 
subnamespaces?

   paf

---

From: "Ryan Moats" <[email-masked]>
Date: Tue, 13 Oct 1998 09:46:18 -0500

> to have some very complicated resolution mechanism for all it's

I haven't thought about this yet (although I guess the "ietf" space
counts as having somewhat different resolution mechanisms).  My thinking
at this point (no caffeine, so don't hold me as being too lucid) is
that the namespace can decide.  In other words, the resolver for the
"us" namespace can deligate resolution to other namespaces in a hierarchical
fasion IF IT WANTS TO.  Of course, scaling considerations imply that this
may be necessary, but that's as far as I've gotten.

Ryan