rfc1484.txt

著名的RFC文档,其中有一些文档是已经翻译成中文的的.

   Whilst the intention of the notation is to allow for specification of
   alternate values, it inherently allows for ambiguous names to be
   specified.  It needs to be demonstrated that problems of this
   characteristic are outweighed by other benefits of the notation.

   Utility

   Determine that the specification is being implemented and used.




Hardcastle-Kille                                               [Page 19]

RFC 1484                  User Friendly Naming                 July 1993


   Performance

   Measurements on the performance implications of using this approach
   should be made.

   Alogrithm

   The utility of the algorithm, and possible variants, should be
   investigated.

   This format, and the procedures for resolving purported names, should
   be evolved.  The syntax can be expected to be stable.  In light of
   experience, the algorithm for resolving purported names may be
   changed.

11.  References

   [CCI88]  The Directory --- overview of concepts, models and services,
            December 1988. CCITT X.500 Series Recommendations.

   [HK93]   S.E. Hardcastle-Kille. A string representation of
            distinguished names.  RFC 1485, Department of Computer
            Science, University College London, July 1993.

   [Kil89a] S.E. Kille. New name forms, May 1989.  ISO/IEC/JTC 21/
            WG4/N797 UK National Body Contribution to the Oslo Directory
            Meeting.

   [Kil89b] S.E. Kille. The THORN large scale pilot exercise.  Computer
            Networks and ISDN Systems, 16(1):143--145, January 1989.

   [Kil90]  S.E. Kille. Using the OSI directory to achieve user friendly
            naming. Research Note RN/20/29, Department of Computer
            Science, University College London, February 1990.

   [KRRT90] S.E. Kille, C.J. Robbins, M. Roe, and A. Turland. The ISO
            development environment:  User's manual (version 6.0),
            January 1990. Volume 5:  QUIPU.

   [Neu89]  G.W. Neufeld. Descriptive names in X.500.  In SIGCOMM 89
            Symposiun Communications Architectures and Protocols, pages
            64--71, September 1989.

   [Pet88]  L.L. Petersen. The profile naming service.  ACM Transactions
            on Computing Systems, 6(4):341--364, November 1988.






Hardcastle-Kille                                               [Page 20]

RFC 1484                  User Friendly Naming                 July 1993


   [Ros90]  M.T. Rose. Realizing the White Pages using the OSI Directory
            Service. Technical Report 90--05--10--1, Performance Systems
            International, Inc., May 1990.

12.  Security Considerations

      Security issues are not discussed in this memo.

13.  Author's Address

   Steve Hardcastle-Kille
   ISODE Consortium
   P.O. Box 505
   London
   SW11 1DX
   England

   Phone:[phone]

   EMail:  [e-mail]

   DN: CN=Steve Hardcastle-Kille,
   O=ISODE Consortium, C=GB

   UFN: S. Hardcastle-Kille,
   ISODE Consortium, GB

A.  Pseudo-code for the matching algorithm

   The following pseudo-code is intended to clarify the matching
   algorithm.  The language uses ASN.1 data types, with flow control
   "C"-like,but with keywords upper--cased.
   ____________________________________________________________________

PurportedName ::= SEQUENCE OF String
                -- simplication, as attribute types can optionally be
                -- specified

                -- Each element of the Purported Name is a string
                -- which has been parsed from the BNF

Attribute ::= SEQUENCE {                                            10
        type OBJECT IDENTIFIER,
        value ANY }

RDN ::= Attribute -- simplification, as can be multi-value

DN ::= SEQUENCE OF RDN



Hardcastle-Kille                                               [Page 21]

RFC 1484                  User Friendly Naming                 July 1993


Environment ::= SEQUENCE OF DN

                                                                    20
EnvironmentList ::= SEQUENCE OF SEQUENCE {
                        lower-bound INTEGER,
                        upper-bound INTEGER,
                        environment Environment }


friendlyMatch(p:  PurportedName; el:  EnvironmentList):    SET OF DN
{
                                -- Find correct environment
                                                                    30
        IF length(el) == 0 THEN return(NULL);

        IF length(p) <= head(el).upper-bound
                        && length(p) >= head(el).lower-bound THEN
                return envMatch (p, head(el).environment);
        ELSE
                return(friendlyMatch(p, tail(el));
}
                                                                    40
envMatch(p:  PurportedName; e:  Environment):    SET OF DN
{
                                -- Check elements of environment
                                -- in the defined order

        matches:  SET OF DN;

        IF length(e) == 0 THEN return(NULL);

        matches = purportedMatch(head(e).DN, p)                     50
        IF matches != NULL THEN
                return(matches);
        ELSE
                return(envMatch(p, tail(e));
}
purportedMatch(base:  DN; p:  PurportedName):  SET OF DN
{
        s:  String = head(p);                                       60
        matches:  SET OF DN = NULL;

        IF length(p) == 1 THEN
                IF length(base) == 0 THEN
                        IF (matches = rootSearch(s)) != NULL THEN
                                return(matches);
                        ELSE return(leafSearch(base, s, one-level);
                ELSE IF length(base) == 1 THEN



Hardcastle-Kille                                               [Page 22]

RFC 1484                  User Friendly Naming                 July 1993


                        IF (matches = intSearch(base, s)) != NULL THEN
                                return(matches);                    70
                        ELSE return(leafSearch(base, s, one-level);
                ELSE
                        IF (matches = leafSearch(base, s, subtree)) !=
                NULL THEN
                                return(matches);
                        ELSE return(intsearch(base, s);

        IF length(base) == 0 THEN
                FOR x IN rootSearch(s) DO
                        matches += (purportedMatch(x, tail(p));     80
        ELSE

                FOR x IN intSearch(base, s) DO
                        matches += (purportedMatch(x, tail(p));
        return(matches);
}
-- General.    Might need to tighten the filter for short strings,
-- in order to stop being flooded.    Alternatively, this could be
-- done if the loose search hists a size limit                      90

rootSearch(s:  String):  SET OF DN
{
        IF length(s) == 2 THEN
                return(search(NULL, one-level, s, {CountryName,
                        FriendlyCountryName, OrganizationName},
                        {exact}, {Country, Organisation}));
                        -- test exact match only
                        -- probably a country code
        ELSE                                                       100
                return(search(NULL, one-level, s, {OrganizationName,
                        FriendlyCountryName}, {substring, approx},
                        {Country, Organisation}));
}

intSearch( base:  DN; s:  String)
{
        IF present(base, OrgUnitName) THEN
                return(search(base, one-level, s, {OrgUnitName},   110
                        {substring, approx}, {OrgUnit}));
        ELSE IF present(base, OrganisationName) THEN
                return(search(base, one-level, s, {OrgUnitName,
                        LocalityName}, {substring, approx},
                        {Organization, OrgUnit, Locality}));
        ELSE IF present(base, LocalityName) THEN
                return(search(base, one-level, s, {OrganisationName},
                        {substring, approx}, {Locality});



Hardcastle-Kille                                               [Page 23]

RFC 1484                  User Friendly Naming                 July 1993


        ELSE
                return(search(base, one-level, s, {OrganisationName,120
                        LocalityName}, {substring, approx},
                        {Organisation, Locality}));
}
present(d:  DN; t:  AttributeType):  BOOLEAN
{
        FOR x IN d DO
                IF x.type == t THEN return(TRUE);
        return(FALSE);                                             130
}

SearchScope := ENUMERATED (base-object, one-level, subtree)

leafSearch(base:  DN; s:  String; search-scope:  SearchScope)
{
        return(search(base, search-scope, s, {CommonName, Surname,
                UserId}, {substring, approx}));
}
                                                                   140
search(base:  DN; search-scope:  SearchScope; s:  string;
        alist SET OF AttributeType; matchtypes SET OF MatchType
        objectClasses SET OF ObjectClass OPTIONAL): SET OF DN
{
        -- mapped onto Directory Search, with OR conjunction
        -- of filter items

        return dNSelect (s, search-results, alist);
}                                                                 150
read(base:  DN; alist SET OF AttributeType):  SET OF Attribute;
{
        -- mapped onto Directory Read
        -- Types repeated to deal with multiple values
        -- This would be implemented by returning selected info
        -- with the search operation
}
dNSelect(s:  String; dlist SET OF DN; alist:  SET OF AttributeType):
16SET0OF DN
{
        exact, good:  SET OF DN;

        FOR x IN dlist DO
                IF last(DN).Value == s THEN
                        exact += x;
                ELSE IF FOR y IN read(x, alist) DO
                        IF y.value == s THEN
                                good += x;
                                                                   170



Hardcastle-Kille                                               [Page 24]

RFC 1484                  User Friendly Naming                 July 1993


        IF exact != NULL THEN return(exact);
        IF good != NULL THEN return(good);
        return(userQuery(dlist));
}
userQuery(dlist SET OF DN): SET OF DN
{
        -- pass back up for manual checking                        180
        -- user can strip all matches to force progres....
}
head()    -- return first element of list
tail()    -- return list with first element removed
length()  -- return size of list
last()    -- return last element of list

                      Figure 2: Matching Algorithm
______________________________________________________________________



































Hardcastle-Kille                                               [Page 25]