view Side-By-Side changes

Application Working Group                                      L. Howard
INTERNET-DRAFT                                    Independent Consultant
Expires in six months from                             12 September                              17 November 1997
Intended Category: Experimental



      An Approach for Using LDAP as a Network Information Service
                   <draft-howard-nis-schema-00.txt>
                   <draft-howard-nis-schema-01.txt>



Status of this Memo

   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. Internet-Drafts may be updated, replaced, or made obsolete by
   other documents at any time. It is not appropriate to use Internet-
   Drafts as reference material or to cite them other than as a "working
   draft" or "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 ds.internic.net (US East Coast), nic.nordu.net
   (Europe), ftp.isi.edu (US West Coast), or munnari.oz.au (Pacific
   Rim).

   Distribution of this document is unlimited.

Abstract

   This document describes an experimental mechanism for mapping
   entities related to TCP/IP and the UNIX system into X.500 [X500]
   entries so that they may be resolved with the Lightweight Directory
   Access Protocol [1]. [LDAPV3]. A set of attribute types and object classes
   are proposed, along with specific guidelines for interpreting them.

   The intention is to assist the deployment of LDAP as an
   organizational nameservice. No proposed solutions are intended as
   standards for the Internet. Rather, it is hoped that a general
   consensus will emerge as to the appropriate solution to such
   problems, leading eventually to the adoption of standards. The
   proposed mechanism has already been implemented with some success.




Howard                                                          [Page 1]





Internet Draft              NIS X.500 schema           12 September            17 November 1997


1. Background and Motivation

   The UNIX (R) operating system, and its derivatives (specifically,
   those which support TCP/IP and conform to the X/Open Single UNIX
   specification [13]) [XOPEN]) require a means of looking up entities, by
   matching them against search criteria or by enumeration. (Other
   operating systems that support TCP/IP may provide some means of
   resolving some of these entities. This schema is applicable to those
   environments also.)

   These entities include users, groups, IP services (which map names to
   IP ports and protocols, and vice versa), IP protocols (which map
   names to IP protocol numbers and vice versa), RPCs (which map names
   to ONC Remote Procedure Call [12] [RFC1057] numbers and vice versa), NIS
   netgroups, booting information (boot parameters and MAC address
   mappings), filesystem mounts, IP hosts and networks, and RFC822 mail
   aliases.

   Resolution requests are made through a set of C functions, provided
   in the UNIX system's C library. For example, the UNIX system utility
   'ls', which enumerates the contents of a filesystem directory, uses
   the C library function getpwuid(3c) getpwuid() in order to map user IDs to login
   names. Once the request is made, it is resolved using a 'nameservice'
   which is supported by the client library. The nameservice may be, at
   its simplest, a collection of files in the local filesystem which are
   opened and searched by the C library. Other common nameservices
   include the Network Information Service (NIS) and the Domain Name
   System (DNS). (The latter is typically only used for resolving hosts,
   services and networks.) Both these nameservices have the advantage of
   being distributed and thus permitting a common set of entities to be
   shared amongst many clients.

   LDAP is a distributed, hierarchical directory service access protocol
   which is used to access repositories of users and other network-
   related entities. Because LDAP is usually often not tightly integrated with
   the host operating system, information such as users needs may need to be
   kept both in LDAP and in an operating system supported nameservice
   such as NIS. By using LDAP as the the primary means of resolving
   these entities, these redundancy issues are minimized and the
   scalability of LDAP can be exploited. (By comparison, NIS services
   based on flat files do not have the scalability or extensibility of
   LDAP or X.500.)

        "In general, it is advantageous for different network
        applications and services to refer to the directory for
        user account information, rather than each service keeping
        its own collection of user account records, which requires
        the network administrator to separately create or destroy
        user entities, passwords, etc., in many different systems



Howard                                                          [Page 2]





Internet Draft              NIS X.500 schema           12 September 1997


        each time a user joins or leaves the organization." [4]

   The object classes and attributes defined below are suitable for
   representing the aforementioned entities in a form compatible with
   LDAP and X.500 directory services. While the schema is by no means
   deemed to be authoritative, it is considered desirable to have a
   single, open schema rather than the proliferation of multiple
   proprietary schema. This document is one step towards such a schema.

2. General Issues



Howard                                                          [Page 2]





Internet Draft              NIS X.500 schema            17 November 1997


2.1. Terminology

   In

   For the purposes of this document, the term 'NIS-related entities' 'nameservice' refers to a
   service, such as NIS or flat files, that is used rather
   loosely by the operating
   system to refer resolve entities within a single, local naming context.
   Contrast this with a 'directory service' such as LDAP, which supports
   extensible schema and multiple naming contexts.

   The term 'NIS-related entities' broadly refers to those entities (described in the previous
   section) which are
   typically represented in resolved using the Network Information Service. (NIS was
   previously known as Yellow Pages, or YP.) It should
   not be inferred from this that deploying Deploying LDAP for resolving such these entities (nisObject excluded) requires
   does not imply that NIS to be used, as a gateway or otherwise. The In
   particular, the host and network classes are generically applicable,
   and may be implemented on operating systems other than
   the UNIX any system that wish wishes to use LDAP to resolve these entities. or X.500
   for host and network resolution.

   The 'DUA' (directory user agent) refers to the LDAP client querying
   these entities, such as an LDAP to NIS gateway or the C library.  The
   'client' refers to the application which ultimately makes use of the
   information returned by the resolution. It is irrelevant whether the
   DUA and the client reside within the same address space. The act of
   the DUA making this information to the client is termed
   'republishing'.

   To avoid confusion, the term 'login name' refers to the user's login
   name (being the value of the uid attribute) and the term 'user ID'
   refers to he user's integer identification number (being the value of
   the uidNumber attribute).

   The term 'principal' is used to
   distinguish accounts that may be used for authentication from those
   that are not.

   The term 'nameservice' refers phrases 'resolving an entity' and 'resolution of entities' refer
   respectively to enumerating NIS-related entities of a service, such as NIS given type, and
   matching them against a given search criterion. One or flat
   files, that is used by the operating system to resolve more entities
   within a single, local naming context. Contrast this with a
   'directory service' such as LDAP, which support extensible schema and
   multiple naming contexts.

   The phrase 'resolving an entity' or 'resolution of entities' refers
   to enumerating NIS-related entities of a given type, or matching them
   against a given search criterion. One or more entities are returned
   as
   are returned as a result of successful 'resolutions' (a 'match'
   operation will



Howard                                                          [Page 3]





Internet Draft              NIS X.500 schema           12 September 1997 only return one entity).

   The use of the term UNIX does not confer upon this schema the
   endorsement of owners of the UNIX trademark. Where necessary, the
   term 'TCP/IP entity' is used to refer to protocols, services, hosts,
   and networks, and the term 'UNIX entity' to its complement. (The
   former category does not mandate the host operating system supporting
   the interfaces required for resolving UNIX entities.)

   The OIDs defined below are rooted at derived from iso(1) org(3) dod(6)
   internet(1) directory(1) nisSchema(1).

2.2. Attributes

   The attributes and classes defined in this document are summarized



Howard                                                          [Page 3]





Internet Draft              NIS X.500 schema            17 November 1997


   below.

   The reader is referred to [2] for the BFN for attribute type
   definitions.

   The following attributes are defined in this document:

           uidNumber
           gidNumber
           gecos
           homeDirectory
           loginShell
           shadowLastChange
           shadowMin
           shadowMax
           shadowWarning
           shadowInactive
           shadowExpire
           shadowFlag
           memberUid
           memberNisNetgroup
           nisNetgroupTriple
           ipServicePort
           ipServiceProtocol
           ipProtocolNumber
           oncRpcNumber
           ipHostNumber
           ipNetworkNumber
           ipNetmaskNumber
           macAddress
           bootParameter
           bootFile
           automountInformation
           nisMapName
           nisMapEntry



Howard                                                          [Page 4]





Internet Draft              NIS X.500 schema           12 September 1997

   Additionally, some of the attributes defined in [2], [9] [LDAPATTRS] and [16]
   [LDAPDOMAINS] are
   imported. required.

2.3. Object classes

   The reader is referred to [2] for the BFN for object class
   definition.

   The following object classes are defined in this document:

           posixAccount
           shadowAccount
           posixGroup
           ipService
           ipProtocol
           oncRpc
           ipHost
           ipNetwork



Howard                                                          [Page 4]





Internet Draft              NIS X.500 schema            17 November 1997


           nisNetgroup
           automount
           nisObject

   Additionally, some of the classes defined in [2] [LDAPATTRS] and [9]
   [LDAPDOMAINS] are imported. required.

2.4. Syntax definitions

   The following syntax definition [2] is definitions [LDAPATTRS] are used in representing by this schema.
   The nisNetgroupTripleSyntax encodes NIS netgroup triples. triples:

           ( nisSchema.0.0 NAME 'nisNetgroupTripleSyntax'
             DESC 'NIS netgroup triple' )

   Values in this syntax are encoded according to represented by the following BNF: following:

        nisnetgrouptriple = "(" hostname "," username "," domainname ")"
        hostname          = "" / "-" / keystring
        username          = "" / "-" / keystring
        domainname        = "" / "-" / keystring

   The bootParameterSyntax syntax encodes boot parameters:

           ( nisSchema.0.1 NAME 'bootParameterSyntax'
             DESC 'Boot parameter' )

   where:

        bootparameter     = key "=" value
        key               = keystring
        value             = keystring

   Values adhering to these syntaxes are encoded as strings.

3. Attribute definitions

   This section contains attribute definitions which must be implemented
   by DUAs supporting the schema.

        ( nisSchema.1.0 NAME 'uidNumber'
          DESC 'An integer uniquely identifying a user in an
                administrative domain'



Howard                                                          [Page 5]





Internet Draft              NIS X.500 schema           12 September 1997
          EQUALITY integerMatch SYNTAX 'INTEGER' SINGLE-VALUE )

        ( nisSchema.1.1 NAME 'gidNumber'
          DESC 'An integer uniquely identifying a group in an
                administrative domain'



Howard                                                          [Page 5]





Internet Draft              NIS X.500 schema            17 November 1997


          EQUALITY integerMatch SYNTAX 'INTEGER' SINGLE-VALUE )

        ( nisSchema.1.2 NAME 'gecos'
          DESC 'The GECOS field, including field; the user's common name'
          EQUALITY caseIgnoreIA5Match
          SUBSTRINGS caseIgnoreIA5SubstringsMatch
          SYNTAX 'IA5String' SINGLE-VALUE )

        ( nisSchema.1.3 NAME 'homeDirectory'
          DESC 'The absolute path of the user's home directory'
          EQUALITY caseExactIA5Match
          SYNTAX 'IA5String' SINGLE-VALUE )

        ( nisSchema.1.4 NAME 'loginShell'
          DESC 'The absolute path of the user's shell'
          EQUALITY caseExactIA5Match
          SYNTAX 'IA5String' SINGLE-VALUE )

        ( nisSchema.1.5 NAME 'shadowLastChange'
          EQUALITY integerMatch
          SYNTAX 'INTEGER' SINGLE-VALUE )

        ( nisSchema.1.6 NAME 'shadowMin'
          EQUALITY integerMatch
          SYNTAX 'INTEGER' SINGLE-VALUE )

        ( nisSchema.1.7 NAME 'shadowMax'
          EQUALITY integerMatch
          SYNTAX 'INTEGER' SINGLE-VALUE )

        ( nisSchema.1.8 NAME 'shadowWarning'
          EQUALITY integerMatch
          SYNTAX 'INTEGER' SINGLE-VALUE )

        ( nisSchema.1.9 NAME 'shadowInactive'
          EQUALITY integerMatch
          SYNTAX 'INTEGER' SINGLE-VALUE )

        ( nisSchema.1.10 NAME 'shadowExpire'
          EQUALITY integerMatch
          SYNTAX 'INTEGER' SINGLE-VALUE )

        ( nisSchema.1.11 NAME 'shadowFlag'
          EQUALITY integerMatch
          SYNTAX 'INTEGER' SINGLE-VALUE )

        ( nisSchema.1.12 NAME 'memberUid'
          EQUALITY caseExactIA5Match
          SUBSTRINGS caseExactIA5SubstringsMatch
          SYNTAX 'IA5String{128}' )



Howard                                                          [Page 6]





Internet Draft              NIS X.500 schema           12 September            17 November 1997


          SUBSTRINGS caseExactIA5SubstringsMatch
          SYNTAX 'IA5String' )

        ( nisSchema.1.13 NAME 'memberNisNetgroup'
          EQUALITY caseExactIA5Match
          SUBSTRINGS caseExactIA5SubstringsMatch
          SYNTAX 'IA5String' )

        ( nisSchema.1.14 NAME 'nisNetgroupTriple'
          DESC 'Netgroup triple'
          SYNTAX 'nisNetgroupTripleSyntax' )

        ( nisSchema.1.15 NAME 'ipServicePort'
          EQUALITY integerMatch
          SYNTAX 'INTEGER' SINGLE-VALUE )

        ( nisSchema.1.16 NAME 'ipServiceProtocol'
          EQUALITY caseIgnoreIA5Match
          SYNTAX 'IA5String' )

        ( nisSchema.1.17 NAME 'ipProtocolNumber'
          EQUALITY integerMatch
          SYNTAX 'INTEGER' SINGLE-VALUE )

        ( nisSchema.1.18 NAME 'oncRpcNumber'
          EQUALITY integerMatch
          SYNTAX 'INTEGER' SINGLE-VALUE  )

        ( nisSchema.1.19 NAME 'ipHostNumber'
          DESC 'IP address in as a dotted decimal notation, decimal, eg. 192.168.1.1'
          EQUALITY caseIgnoreIA5Match
          SYNTAX 'IA5String{128}' )

        ( nisSchema.1.20 NAME 'ipNetworkNumber'
          DESC 'IP address in network as a dotted decimal notation, decimal, eg. 192.168'
          EQUALITY caseIgnoreIA5Match
          SYNTAX 'IA5String{128}' )

        ( nisSchema.1.21 NAME 'ipNetmaskNumber'
          DESC 'IP address in netmask as a dotted decimal notation, decimal, eg. 255.255.255.0'
          EQUALITY caseIgnoreIA5Match
          SYNTAX 'IA5String{128}' )

        ( nisSchema.1.22 NAME 'macAddress'
          DESC 'MAC address in colon-separated hex notation, for
                example 0:0:92:90:ee:e2'
          EQUALITY caseIgnoreIA5Match
          SYNTAX 'IA5String{128}' )



Howard                                                          [Page 7]





Internet Draft              NIS X.500 schema            17 November 1997


        ( nisSchema.1.23 NAME 'bootParameter'
          DESC 'rpc.bootparamd parameter; informal syntax is key=value'
          EQUALITY caseExactIA5Match parameter'
          SYNTAX 'IA5String' 'bootParameterSyntax' )

        ( nisSchema.1.24 NAME 'bootFile'
          DESC 'name of the boot image, which may be used by bootpd.
                Alternatively, this may specified as a value of



Howard                                                          [Page 7]





Internet Draft              NIS X.500 schema           12 September 1997


                bootParameter.' 'Boot image name'
          EQUALITY caseExactIA5Match
          SYNTAX 'IA5String' )

        ( nisSchema.1.25 NAME 'automountInformation'
          DESC 'An entry in an automount map.' map'
          EQUALITY caseExactIA5Match
          SUBSTRINGS caseExactIA5SubstringsMatch
          SYNTAX 'IA5String' )

        ( nisSchema.1.26 NAME 'nisMapName'
          EQUALITY caseExactIA5Match
          SUBSTRINGS caseExactIA5SubstringsMatch
          SYNTAX 'IA5String{1024}' SINGLE-VALUE )

        ( nisSchema.1.27 NAME 'nisMapEntry'
          EQUALITY caseExactIA5Match
          SUBSTRINGS caseExactIA5SubstringsMatch
          SYNTAX 'IA5String{1024}' SINGLE-VALUE )



4. Class definitions

   This section contains class definitions which must be implemented by
   DUAs supporting the schema.

   The definitions under the OID 2.5.6 are imported. The rfc822MailGroup object class may used to represent a mail group
   for the purpose of alias expansion. (Several Several alternative schemes for
   mail routing and delivery using LDAP directories have been proposed [4]; these issues
   will not be considered in detail here.) directories, which are outside
   the scope of this document.

        ( nisSchema.2.0 NAME 'posixAccount' SUP top STRUCTURAL AUXILIARY
          DESC 'Abstraction of an account with POSIX attributes.'
          MUST ( cn $ uid $ uidNumber $ gidNumber $ homeDirectory )
          MAY ( userPassword $ loginShell $ gecos $ description ) )

        ( nisSchema.2.1 NAME 'shadowAccount' SUP top AUXILIARY
          DESC 'Additional attributes for shadow passwords.'
          MUST uid
          MAY ( userPassword $ shadowLastChange $ shadowMin
                shadowMax $ shadowWarning $ shadowInactive $
                shadowExpire $ shadowFlag $ description ) )



Howard                                                          [Page 8]





Internet Draft              NIS X.500 schema            17 November 1997


        ( nisSchema.2.2 NAME 'posixGroup' SUP top STRUCTURAL
          DESC 'Abstraction of a group of posixAccounts.' accounts.'
          MUST ( cn $ gidNumber )



Howard                                                          [Page 8]





Internet Draft              NIS X.500 schema           12 September 1997
          MAY ( userPassword $ memberUid $ description ) )

        ( nisSchema.2.3 NAME 'ipService' SUP top STRUCTURAL
          DESC 'Abstraction an Internet Protocol service.
                Maps an IP port and protocol (eg. (such as tcp or udp)
                to one or more names.
                The distinguished value of the cn attribute denotes
                the service's canonical name.'
          MUST ( cn $ ipServicePort $ ipServiceProtocol )
          MAY ( description ) )

        ( nisSchema.2.4 NAME 'ipProtocol' SUP top STRUCTURAL
          DESC 'Abstraction of an IP protocol. Maps a protocol number
                to one or more names. The distinguished value of the cn
                attribute denotes the protocol's canonical name.'
          MUST ( cn $ ipProtocolNumber $ description )
          MAY description )

        ( nisSchema.2.5 NAME 'oncRpc' SUP top STRUCTURAL
          DESC 'Abstraction of an Open Network Computing (ONC) [12]
               [RFC1057] Remote Procedure Call (RPC) binding. Maps
               This class maps an ONC RPC number to a name.
               The distinguished value of the cn attribute denotes
               the RPC service's canonical name.'
          MUST ( cn $ oncRpcNumber $ description )
          MAY description )

        ( nisSchema.2.6 NAME 'ipHost' SUP top STRUCTURAL
          DESC 'Abstraction of a host. The schema defined in [3] is used
                to denote the canonical hostname, by mapping the
                distinguished name into a DNS domain name.
                The associatedDomain attribute is used for interrogating
                the DIT, and as such must contain values for the host's
                canonical name and its aliases.' See section 5.4.'
          MUST ( dc $ ipHostNumber $ associatedDomain )
          MAY ( macAddress $ bootParameter $ bootFile $ dc $
                l $ description $ manager $ serialNumber ) )

        ( nisSchema.2.7 NAME 'ipNetwork' SUP top
          STRUCTURAL
          DESC 'Abstraction of a network.' network. See section 5.4.'
          MUST ( dc $ ipNetworkNumber $ associatedDomain )
          MAY ( ipNetmaskNumber $ l $ description $ manager $ dc ) )

        ( nisSchema.2.8 NAME 'nisNetgroup' SUP top STRUCTURAL
          DESC 'Abstraction of a netgroup. May refer to other netgroups.'
          MUST cn
          MAY ( nisNetgroupTriple $ memberNisNetgroup $ description ) )

        ( nisSchema.2.9 NAME 'automount' SUP top STRUCTURAL



Howard                                                          [Page 9]





Internet Draft              NIS X.500 schema           12 September            17 November 1997


          DESC 'Abstraction of an automount map; each entry in the map
                is represented by a value of the automountInformation
                attribute. The map name is given by the cn attribute.
                Each value of the automountInformation attribute
                constitutes a mount entry.'
          MUST cn
          MAY ( automountInformation $ description ) )

        ( nisSchema.2.10 NAME 'nisObject' SUP top STRUCTURAL
          DESC 'Abstraction of a generic NIS map or entry.'
          MUST nisMapName
          MAY ( cn $ nisMapEntry $ description ) )



5. Implementation details

5.1. Resolution Suggested resolution methods

   The ideal preferred means of directing a client application (one using the
   shared services of the C library) to use LDAP as its information
   source for the functions listed in 5.2 is to modify the source code
   to directly query LDAP. As the source code to commercial C libraries and
   applications is rarely available to the end-user, it is
   acceptable to one could emulate a
   supported nameservice (such as NIS) and
   modify the resolution code to use LDAP. NIS). (This is also an appropriate
   opportunity to perform caching of entries across client process address
   spaces.) In the case of NIS, reference implementations are widely
   available and the client-server RPC interface is well known.

   There exists no standard mechanism, other than NIS, for resolving
   automount and nisObject entries.  The former may be supported by the
   automounter itself; both classes should be supported by an LDAP to
   NIS gateway. However, an implementation which claims to conform to DUAs implementing this specification is schema are not required to
   support these classes. (To
   mandate otherwise would exclude implementations integrated with all the C
   library.)

   Some classes defined herein.

   The means by which the operating system is directed to use LDAP is
   implementation dependent. For example, some operating systems and C
   libraries support end-user extensible resolvers using dynamically
   loadable libraries and a nameservice "switch". Others allow end-user defined symbols to be substituted at
   runtime. Regardless, the means by which the operating system is
   directed to use LDAP is implementation dependent, as is the The means by in which the
   DUA locates LDAP servers. (It servers is also implementation dependent. It is
   anticipated that the
   Dynamic Host Configuration Protocol (DHCP) DNS SRV records [RFC2052] may be used for the latter
   [16].) this.

5.2. Affected resolver calls



Howard                                                         [Page 10]





Internet Draft              NIS X.500 schema           12 September 1997 library functions

   The following entry points functions are typically found in the C libraries of
   most UNIX and POSIX compliant systems. An LDAP search filter [5]
   [LDAPFILT] which may be used to satisfy the function call is included
   alongside each function
   name, with printf(3s) format notation used to denote the function
   parameter(s), if any. Generally, those functions in section 3n of the
   UNIX system's manual pages refer to TCP/IP entries, name. Parameters are denoted by %s and those in
   section 3c refer to the remainder. %d for



Howard                                                         [Page 10]





Internet Draft              NIS X.500 schema            17 November 1997


   string and integer arguments, respectively. Long lines are broken with the '\'
   character.

        getpwnam(3c) broken.

        getpwnam()              (&(objectClass=posixAccount)(uid=%s))
        getpwuid(3c)            (&(objectClass=posixAccount)\
        getpwuid()              (&(objectClass=posixAccount)
                                (uidNumber=%d))
        getpwent(3c)
        getpwent()              (objectClass=posixAccount)

        getspnam(3c)

        getspnam()              (&(objectClass=shadowAccount)(uid=%s))
        getspent(3c)
        getspent()              (objectclass=shadowAccount)

        getgrnam(3c)

        getgrnam()              (&(objectClass=posixGroup)(cn=%s))
        getgrgid(3c)            (&(objectClass=posixGroup)\
        getgrgid()              (&(objectClass=posixGroup)
                                (gidNumber=%d))
        getgrent(3c)
        getgrent()              (objectClass=posixGroup)

        getservbyname(3n)       (&(objectClass=ipService)\

        getservbyname()         (&(objectClass=ipService)
                                (cn=%s)(ipServiceProtocol=%s))
        getservbyport(3n)       (&(objectClass=ipService)\
                                (ipServicePort=%d)\
        getservbyport()         (&(objectClass=ipService)
                                (ipServicePort=%d)
                                (ipServiceProtocol=%s))
        getservent(3n)
        getservent()            (objectClass=ipService)

        getrpcbyname(3n)

        getrpcbyname()          (&(objectClass=oncRpc)(cn=%s))
        getrpcbynumber(3n)
        getrpcbynumber()        (&(objectClass=oncRpc)(oncRpcNumber=%d))
        getrpcent(3n)
        getrpcent()             (objectClass=oncRpc)

        getprotobyname(3n)

        getprotobyname()        (&(objectClass=ipProtocol)(cn=%s))
        getprotobynumber(3n)    (&(objectClass=ipProtocol)\
        getprotobynumber()      (&(objectClass=ipProtocol)
                                (ipProtocolNumber=%d))
        getprotoent(3n)
        getprotoent()           (objectClass=ipProtocol)

        gethostbyname(3n)       (&(objectClass=ipHost)\

        gethostbyname()         (&(objectClass=ipHost)
                                (associatedDomain=%s))
        gethostbyaddr(3n)
        gethostbyaddr()         (&(objectClass=ipHost)(ipHostNumber=%s))
        gethostent(3n)
        gethostent()            (objectClass=ipHost)

        getnetbyname(3n)        (&(objectClass=ipNetwork)\

        getnetbyname()          (&(objectClass=ipNetwork)
                                (associatedDomain=%s))
        getnetbyaddr(3n)        (&(objectClass=ipNetwork)\
        getnetbyaddr()          (&(objectClass=ipNetwork)
                                (ipNetworkNumber=%s))
        getnetent(3n)
        getnetent()             (objectClass=ipNetwork)



Howard                                                         [Page

        setnetgrent()           (&(objectClass=nisNetgroup)(cn=%s))

        getaliasbyname()        (&(objectClass=rfc822MailGroup)(cn=%s))
        getaliasent()           (objectClass=rfc822MailGroup)





Howard                                                         [Page 11]





Internet Draft              NIS X.500 schema           12 September            17 November 1997


        setnetgrent(3n)         (&(objectClass=nisNetgroup)(cn=%s))

        getaliasbyname(3n)      (&(objectClass=rfc822MailGroup)(cn=%s))
        getaliasent(3n)         (objectClass=rfc822MailGroup)


5.3. Interpreting user and group entries

   User and group resolution is initiated by the functions prefixed by
   getpw and getgr respectively. A The uid attribute contains the user's
   login name is denoted by the
   value of name. The cn attribute, in posixGroup entries, contains the uid attribute (which will typically
   group's name.

   The account object class provides a convenient structural class for
   posixAccount, and should be used as a
   relative distinguished name); a group's name where additional attributes are not
   required.

   It is denoted by a value of
   the suggested that uid and cn attribute. are used as the RDN attribute type
   for posixAccount and posixGroup entries, respectively.

   An account's GECOS field is preferably determined by a value of the
   gecos attribute. If no gecos attribute exists, the value of the cn
   attribute must be used. (The existence of the gecos attribute allows
   attributes
   information embedded in the GECOS field, such as a user's telephone
   number, to be returned to the client without overloading the cn
   attribute.)
   attribute. It also accommodates directories where the common name
   does not contain the user's full name.)

   An entry of class posixAccount posixAccount, posixGroup, or shadowAccount without
   a userPassword attribute must be denied the opportunity to
   authenticate. For example, the The client may should be returned a non-matchable password
   such as "*" by the DUA.

   A user which is a member of a posixGroup which has no userPassword
   attribute must not be allowed to authenticate themself as a member of
   that group, unless the user's gidNumber attribute implies a user has
   the same group ID (in which case the operating system may determine
   this implicitly). "x".

   userPassword values must be represented by following BNF syntax:

        passwordvalue          = schemeprefix encryptedpassword
        schemeprefix           = "{" scheme "}"
        scheme                 = "crypt" / "md5" / "sha" / altscheme
        altscheme              = "x-" keystring
        encryptedpassword      = encrypted password

   (where the

   The encrypted password consists contains of a plaintext key encrypted hashed using appropriate encoding algorithm; for example, crypt(3) with a
   two-character random salt for "crypt") the
   algorithm scheme.

   userPassword values which do not adhere to the BNF above syntax must not
   be used for authentication. (The The DUA must iterate through the values
   of the attribute until a value matching the above BNF syntax is found.) found.
   Only if
   encryptedPassword encryptedpassword is an empty string does the user have no
   password.



Howard                                                         [Page 12]





Internet Draft              NIS X.500 schema           12 September 1997 DUAs are not required to consider encryption schemes which
   the client will not recognise; recognize; in many most cases, it may be sufficient to
   consider only "crypt".

   Below is an example of a userPassword attribute:




Howard                                                         [Page 12]





Internet Draft              NIS X.500 schema            17 November 1997


           userPassword: {crypt}X5/DBrWPOQQaI


   A future document standard may use LDAP v3 attribute descriptions to represent
   hashed userPasswords, as in the following: noted below. This schema should not be used
   with LDAP v2 DUAs and DSAs.

        attributetype           = attributename sep attributeoption
        attributename           = "userPassword"
        sep                     = ";"
        attributeoption         = schemeclass "-" scheme
        schemeclass             = "hash" / altschemeclass
        scheme                  = "crypt" / "md5" / "sha" / altscheme
        altschemeclass          = "x-" keystring
        altscheme               = keystring


   For example, consider the attribute:


   Below is an example of a userPassword attribute, represented with an
   LDAP v3 attribute description:

           userPassword;hash-crypt: X5/DBrWPOQQaI


   which would otherwise be represented as

           userPassword: {crypt}X5/DBrWPOQQaI.


   A DUA may make use of utilise the attributes in the shadowAccount class to
   provide shadow password service (getspnam(3c) (getspnam() and getspent(3c)). getspent()). In such
   cases, the DUA must not make use of the userPassword attribute for getpwnam(3c)
   getpwnam() et al, and must return a non-matchable password (such as
   "x") to the client instead.

5.4. Interpreting hosts and networks

   The means for representing DNS [6] [RFC1034] domains in LDAP
   distinguished names described in [3] [RFC1279] and [9] is used [LDAPDOMAINS] are
   incorporated into this schema. However, the ipHostNumber and
   ipNetworkNumber attributes are defined in part preference to represent TCP/IP
   hosts and networks in LDAP.

   Note the use of the ipHostNumber attribute instead of the dNSRecord
   attribute.  The rationale is that, dNSRecord, in
   order to minimize the
   responsibility placed on simplify the DUA, attribute values ought to directly
   contain DUA's role in interpreting entries in the information they seek to represent. This contrasts with,
   for example, a
   directory. A dNSRecord value which expresses a complete DNS resource record record,
   including time to live and class data. It is
   considered that this information data, which is extraneous to using LDAP as a
   direct means to resolve hosts and networks. this
   schema.

   Additionally, it is
   considered more appropriate for an entity, the ipHost and ipNetwork classes permit a host or
   network (respectively) and all its aliases, aliases to be



Howard                                                         [Page 13]





Internet Draft              NIS X.500 schema           12 September 1997 represented by a
   single entry in the DIT, which directory. This is not always necessarily possible when if a
   DNS resource record is mapped directly to an LDAP entry.
   Implementations that wish to use LDAP to master DNS zone information
   are not precluded from doing so, and may simply avoid the ipHost and
   ipNetwork classes.




Howard                                                         [Page 13]





Internet Draft              NIS X.500 schema            17 November 1997


   This document redefines (although redefines, although not to the extent of excluding the
   existing definition) exclusively, the ipNetwork
   class defined in [3], for [RFC1279], in order to achieve consistent naming
   consistency
   with ipHost. The ipNetworkNumber attribute is also used in the
   siteContact object class [14]. (The [ROSE].

   The trailing zeros in a network address should must be omitted.) omitted. CIDR-style
   network addresses (eg. 192.168.1/24) can may be used.

   The associatedDomain attribute must contain the host or network's
   canonical, qualified domain name, and any other names by which the
   host or network is known. This should include the host's or network's
   non qualified name. When interrogated the directory for ipHosts, the
   associatedDomain attribute must be used but this in the search filter.

   The use of the dc attribute to distinguish hosts is recommended, but
   not required. If used, it must contain the host's non-qualified name.
   It has no role in interrogation.

   If an entry of class ipHost or ipNetwork belongs to a naming context
   denoted by
   containing relative distinguished names (RDNs) [10] [LDAPDN] of attribute
   type dc (domainComponent), then the distinguished name (DN) may be used to
   select which value of associatedDomain is transformed
   into the canonical host name.
   Such a DN is mapped to a domain name system (DNS) suffix by concatenating each RDN value
   with a period ('.').  For example, an entry of class ipHost with a DN
   of dc=foo, dc=bar, dc=edu or dc=foo, dc=bar, dc=edu, o=Internet is parsed into may
   select the host
   name foo.bar.edu. If domain foo.bar.edu from the naming context values of associatedDomain.
   The mapping must terminate at the first relative distinguished name
   which is does not contain 'dc'
   values, a non-qualified host name is returned. For organizations
   which wish to use existing X.500 container classes to form their
   context (ie. organization and organizationalUnit) domainComponent.  This mapping must not be applied if
   the entry's RDN values of
   unrequired type are skipped by the DUA in determining the domain
   name. As such, a DN of dc=foo, dc=bar, dc=edu, o=Ace Industry, c=US
   may be parsed as foo.bar.edu. As this may be considered a naming
   violation, this document does is not specifically endorse this. dc. Instead, associatedDomain alone must
   determine the hostname.

   Hosts with IPv6 addresses should be written in their "preferred" form
   as defined in section 2.2.1 of [15], [RFC1884], such that all components of
   the address are indicated and leading zeros are omitted. This is to
   provide
   provides a consistent means of resolving ipHosts by address.


5.5. Interpreting other entities

   In general, a one-to-one mapping between entities and LDAP entries is
   proposed, in that each entity has exactly one representation in the
   DIT. In some cases this is not feasible; for example, a service which
   is represented in more than one protocol domain. Consider the
   following entry:

           dn: cn=domain, dc=aceindustry, dc=aja, dc=com
           cn: domain
           cn: nameserver
           objectClass: top
           objectClass: ipService
           ipServicePort: 53
           ipServiceProtocol: tcp



Howard                                                         [Page 14]





Internet Draft              NIS X.500 schema           12 September            17 November 1997


           objectClass: top
           objectClass: ipService
           ipServicePort: 53
           ipServiceProtocol: tcp
           ipServiceProtocol: udp

   This entry would map maps to the following two (2) services entities:

           domain  53/tcp  nameserver
           domain  53/udp  nameserver

   While the above two entities could have been equally may be represented as separate LDAP
   entities, with different distinguished names (such as
   cn=domain+ipServiceProtocol=tcp, ... and
   cn=domain+ipServiceProtocol=udp, ...) it is considered that
   representing convenient to represent
   them as a single entry is more convenient. entry. (If a service is represented in multiple
   protocol domains with different respective ports, then multiple entries are mandatory, with
   required; multivalued RDNs
   being may be used to distinguish between them.)

   Entries of class automount inherently represent more than one entity:
   each value of the automountInformation attribute is may be a record in a
   NIS record. database.

   With the exception of userPassword values, which must be parsed
   according to the BNF syntax considered in section 5.2, any empty values
   (those that consist
   (consisting of a zero length string) are returned by the DUA to the
   client. The client may not make sense of them, but this
   situation is no different to parsing files which contain empty
   fields. (By contrast, the DUA must reject any entries which do not conform to the schema, ie. are missing certain
   schema (missing mandatory attributes. attributes). Non-conforming entries should
   be ignored while enumerating entries;
   whether the enumeration is terminated at such an entry is
   implementation dependent, although it is strongly suggested that the
   offending entry be treated as if it were not present.) entries.

   The nisObject object class is provided may be used as a generic means of
   representing NIS entities. Its use is not encouraged; where support
   for entities not described in this schema is desired, an appropriate
   schema should be devised. Implementors are strongly advised to
   support end-user extensible mappings between NIS entities and object
   classes. The nisObject class may be useful were one to use LDAP to
   query a NIS server, although it is anticipated that the converse will
   be more common. between NIS entities and object
   classes. (Where the nisObject class is used, the nisMapName attribute
   may establish part of the DN, to assist the DUA in locating
   entries belonging to a particular map.)

   Entries which inherit also from the cacheObject object class (and
   thus contain the 'ttl' attribute) may be used by DUAs to perform
   cache validation. [17] as a RDN.)


5.6. Canonicalizing entries with multi-valued naming attributes




Howard                                                         [Page 15]





Internet Draft              NIS X.500 schema           12 September 1997

   For entities such as services, protocols, and RPCs, where there may
   be one or more aliases, the respective entry's relative distinguished
   name is should be used to form the canonical name.  Any other values for
   the same attribute are used as aliases. For example, the service
   described in section 5.5 has the canonical name 'domain' and exactly
   one alias, 'nameserver'.




Howard                                                         [Page 15]





Internet Draft              NIS X.500 schema            17 November 1997


   The schema in this document generally only defines one attribute per
   class which is suitable for distinguishing an entity (excluding any
   attributes with integer syntax; it is assumed that entries will be
   distinguished based on name). Usually, this is the common name (cn)
   attribute.  (For users, either the cn or uid attributes may be used
   to canonicalize an entry. For hosts and networks, the entire distinguished
   name may be considered per section 5.4.) name is considered, as per
   section 5.4.) This fact aids the DUA in determining the canonical name of
   an entity: entity, as it can simply examine the value of the relative distinguished
   name. Aliases are thus any values of the distinguishing attribute
   (such as cn) which do not match the canonical name of the entity.

   In the event that a different attribute is used to distinguish the
   entry, as may be the case with conforming entries that belong to
   additional where these object classes are used as
   auxiliary classes, it is possible that the entity's entry's canonical name cannot may not be deduced from present in
   the RDN. In this situation, case, the DUA must choose one of the non-distinguished non-
   distinguished values to represent the entity's canonical name. Because As the
   directory server guarantees no ordering of attribute values, attempting it may
   not be possible to distinguish an entry in a
   deterministic fashion may require the DUA to maintain a mapping
   between entries' DNs and their canonical names as considered by the
   DUA. deterministically. This document does
   ambiguity should not require this, nor does it advocate that
   such situations be resolved by mapping one DIT directory entry into
   multiple entities.

6. Implementation focus

   A NIS daemon server which uses LDAP instead of local files has been
   developed which supports the schema defined in this document.

   A set
   of extensions to a particular implementation of the Mach operating
   system has also been developed, which sidesteps NIS and uses LDAP
   directly.

   Work is underway to develop a freely available (under the GNU General
   Library Public License) reference implementation of the C library resolution code that supports LDAP using the draft schema. The code
   will be compatible with has been
   written for the Free Software Foundation's GNU C library
   and Foundation. It may support other C
   libraries which support the Name Service Switch (NSS) or the
   Information Retrieval Service (IRS).

   The alias lookup functions referred to in section 5.2 are presently



Howard                                                         [Page 16]





Internet Draft              NIS X.500 schema           12 September 1997


   available only in the GNU C library, and (albeit with different
   names) in the C library of one commercial UNIX system vendor. It is
   anticipated that the mail transport agent (MTA) will typically
   consult LDAP or NIS directly instead of using the C library; however,
   support for the suggested library calls is encouraged.

   The author has made available a freely distributable set of Perl scripts for parsing configuration files
   which parses local databases such as /etc/passwd and /etc/hosts and generating LDIF data suitable for preparing an
   generates LDIF
   database, as well as a set of Java classes for generating flat files
   from the DIT. output.

7. Security considerations

   The entirety of related security considerations are outside the scope
   of this document. However, it It should be noted that making passwords encrypted
   with a widely understood one way hash function (such as
   crypt(3)) crypt()) available to
   non-privileged users is potentially dangerous because it exposes them to
   dictionary and brute-force attacks.  It is proposed only for
   compatibility with existing UNIX system implementations. Sites where
   security is critical may should consider using
   Kerberos or another a strong authentication
   service for logins. A variation on
   this is to authenticate to an LDAP server by binding over an
   encrypted connection (such as SSL [8]). user authentication.

   Alternatively, the encrypted password could be made available only to



Howard                                                         [Page 16]





Internet Draft              NIS X.500 schema            17 November 1997


   a subset of privileged DUAs, which would provide 'shadow' password
   service to client applications. This may be difficult to enforce.

   Because the schema represents operating system-level entities, access
   to these entities should be granted on a discretionary basis. (That
   said, there (There
   is little point in restricting access to data which will be
   republished without restriction, eg. by a NIS server.) however.) It is particularly
   important that only administrators can modify entries defined in this
   schema, with the exception of allowing a principal to change their
   password (which may be done on behalf of the user by a client bound
   as a superior principal, such that password restrictions may be
   enforced). For example, if a user were allowed to change the value of
   their uidNumber attribute, they could subvert security by
   equivalencing their account with the root superuser account.

   A subtree of the DIT which is to be republished by a DUA (such as a
   NIS gateway) should be within the same administrative domain that the
   republishing DUA represents. (For example, principals outside an
   organization, while conceivably part of the DIT, should not be
   considered with the same degree of authority as those within the
   organization.)




Howard                                                         [Page 17]





Internet Draft              NIS X.500 schema           12 September 1997

   Finally, care should be exercised with integer attributes of a
   sensitive nature (particularly the uidNumber and gidNumber
   attributes) which contain zero-length values. It may be wiser to
   treat such values as corresponding to the "nobody" or "nogroup" user
   and group, respectively.

8. Acknowledgements

   Thanks to Leif Hedstrom of Netscape Communications Corporation,
   Rosanna Lee of Sun Microsystems Inc., and Mark Wahl of Critical Angle
   Inc. for their valuable contributions to the development of this
   schema. Thanks to Andrew Josey of The Open Group for clarifying the
   use of the UNIX trademark.

   UNIX is a registered trademark of The Open Group.

9. References

   [1]  M. Wahl, T. Howes, S. Kille, "Lightweight Directory Access
        Protocol (Version 3)", INTERNET-DRAFT <draft-ietf-asid-ldapv3-
        protocol-06.txt>, June 1997.

   [2]

   [LDIF]G. Good, "The LDAP Data Interchange Format (LDIF)", INTERNET-
        DRAFT <draft-ietf-asid-ldif-02.txt>, November 1996.

   [LDAPATTRS]
        M. Wahl, T. Howes, S. Kille, "Lightweight Directory Access
        Protocol: Standard and Pilot Attribute Definitions", INTERNET-
        DRAFT <draft-ietf-asid-ldapv3-attributes-06.txt>, <draft-ietf-asid-ldapv3-attributes-08.txt>, June 1997.

   [3]  S. Kille, "X.500 and Domains", RFC 1279,




Howard                                                         [Page 17]





Internet Draft              NIS X.500 schema            17 November 1991.

   [4]  H. Lachman, "LDAP-based Routing of SMTP Messages: Approach Used
        by Netscape", INTERNET-DRAFT <draft-ietf-asid-email-routing-ns-
        00.txt>, March 1997.

   [5] 1997


   [LDAPFILT]
        T. Howes, "A String Representation of LDAP Search Filters",
        INTERNET-DRAFT <draft-ietf-asid-ldapv3-filter-00.txt>, March <draft-ietf-asid-ldapv3-filter-02.txt>, May 1997. See also [10].

   [6]

   [LDAPDN]
        M. Wahl, S. Kille, T. Howes, "Lightweight Directory Access
        Protocol (v3): UTF-8 String Representation of Distinguished
        Names", INTERNET-DRAFT <draft-ietf-asid-ldapv3-dn-04.txt>,
        November 1997.

   [LDAPDOMAINS]
        S. Kille, M. Wahl, A. Grimstad, R. Huber, S. Sataluri, "An
        Approach for Using Domains in LDAP Distinguished Names",
        INTERNET-DRAFT <draft-ietf-asid-ldap-domains-02.txt>, September
        1997.

   [LDAPV3]
        M. Wahl, T. Howes, S. Kille, "Lightweight Directory Access
        Protocol (Version 3)", INTERNET-DRAFT <draft-ietf-asid-ldapv3-
        protocol-08.txt>, June 1997.

   [RFC1034]
        P. Mockapetris, "Domain names - concepts and facilities", RFC
        1034, November 1987.

   [7]  "Information

   [RFC1057]
        Sun Microsystems, Inc., "RPC: Remote Procedure Call: Protocol
        Specification Version 2", RFC 1057, June 1988.

   [RFC1279]
        S. Kille, "X.500 and Domains", RFC 1279, November 1991.

   [RFC1884]
        R. Hinden, S. Deering, "IP Version 6 Addressing Architecture",
        RFC 1884, December 1995.

   [RFC2052]
        A. Gulbrandsen, P. Vixie, "A DNS RR for specifying the location
        of services (DNS SRV)", RFC 2052, October 1996.

   [ROSE]M. T. Rose, "The Little Black Book: Mail Bonding with OSI
        Directory Services", ISBN 0-13-683210-5, Prentice-Hall, Inc.,
        1992.

   [X500]"Information Processing Systems - Open Systems Interconnection
        -
        The Directory: Overview of Concepts, Models and Service",
        ISO/IEC JTC 1/SC21, International Standard 9594-1, 1988.

   [8]  A. O. Freier, P. Karlton, P. Kocher, "The SSL Protocol, Version
        3.0", INTERNET-DRAFT <draft-ietf-tls-ssl-version3-00.txt>
        November 1996.

   [9]  S. Kille, M. Wahl, "An Approach for Using Domains in LDAP The Directory: Overview of Concepts, Models and Service",
        ISO/IEC JTC 1/SC21, International Standard 9594-1, 1988.




Howard                                                         [Page 18]





Internet Draft              NIS X.500 schema           12 September 1997


        Distinguished

        Names", INTERNET-DRAFT <draft-ietf-asid-ldap-domains-00.txt>,
        July 1996.

   [10] S. Kille, "A String Representation of Distinguished Names", RFC
        1779, March 1995.

   [11] G. Good, "The LDAP Data Interchange Format (LDIF)", INTERNET-
        DRAFT <draft-ietf-asid-ldif-00.txt>,            17 November 1996.

   [12] Sun Microsystems, Inc., "RPC: Remote Procedure Call: Protocol
        Specification Version 2", RFC 1057, June 1988.

   [13] 1997


   [XOPEN]
        ISO/IEC 9945-1:1990, Information Technology - Portable Operating
        Systems Interface (POSIX) - Part 1: Systems Application
        Programming Interface (API) [C Language]

   [14] M. T. Rose, "The Little Black Book: Mail Bonding with OSI
        Directory Services", ISBN 0-13-683210-5, Prentice-Hall, Inc.,
        1992.

   [15] R. Hinden, S. Deering, "IP Version 6 Addressing Architecture",
        RFC 1884, December 1995.

   [16] L. Hedstrom, L. Howard, "DHCP Options for LDAP", INTERNET-DRAFT
        <draft-hedstrom-dhcp-ldap-00.txt>, July 1997.

   [17] T. Howes, L. Howard, "A Simple Caching Scheme for LDAP and X.500
        Directories", INTERNET-DRAFT <draft-ietf-asid-ldap-cache-
        01.txt>, July 1997.

10. Author's Address

   Luke Howard
   PO Box 59
   Central Park Vic 3145
   Australia
   Email: lukeh@xedoc.com


A. Example entries

   The examples described in this section are provided to illustrate the
   schema described in this draft. They are not an authoritative
   reference. meant to be exhaustive.
   Entries are presented in LDIF notation [11]. [LDIF].

   The following entry is an example of the posixAccount class:



Howard                                                         [Page 19]





Internet Draft              NIS X.500 schema           12 September 1997

           dn: uid=lukeh, dc=aceindustry, uid=lester, dc=aja, dc=com
           cn: Luke Howard
           objectClass: top
           objectClass: person account
           objectClass: posixAccount
           sn: Howard
           telephoneNumber: +61 3 9428 0788
           uid: lukeh lester
           cn: Lester the Nightfly
           userPassword: {crypt}X5/DBrWPOQQaI
           gecos: Luke Howard Lester
           loginShell: /bin/csh
           uidNumber: 10
           gidNumber: 10
           homeDirectory: /home/lukeh /home/lester


   This corresponds the UNIX system password file entry:

        lukeh:X5/DBrWPOQQaI:10:10:Luke Howard:/home/lukeh:/bin/sh

   Note that the userPassword value is parsed into a password suitable
   for matching with crypt(3). Attributes such as telephoneNumber and sn
   (which belong to classes other than posixAccount), are not used in
   determining the corresponding password file entry but may be useful
   to other LDAP clients. (In most cases, entries of class posixAccount
   will also inherit from person or organizationalPerson.)

        lester:X5/DBrWPOQQaI:10:10:Lester:/home/lester:/bin/sh

   The following entry is an example of the ipHost class:

           dn: dc=yoyo, dc=aceindustry, dc=peg, dc=aja, dc=com
           dc: yoyo
           objectClass: top
           objectClass: ipHost
           objectClass: domainRelatedObject
           dc: peg
           associatedDomain: yoyo.aceindustry.com peg
           associatedDomain: peg.aja.com



Howard                                                         [Page 19]





Internet Draft              NIS X.500 schema            17 November 1997


           associatedDomain: www.aceindustry.com www.aja.com
           ipHostNumber: 10.0.0.1
           macAddress: 0:0:92:90:ee:e2
           bootParameter: bootfile=mach
           bootParameter: root=fs:/nfsroot/yoyo root=fs:/nfsroot/peg
           bootParameter: swap=fs:/nfsswap/yoyo swap=fs:/nfsswap/peg
           bootParameter: dump=fs:/nfsdump/yoyo dump=fs:/nfsdump/peg

   This entry represents the host yoyo.aceindustry.com, canonically peg.aja.com, also known as
   www.aceindustry.com.
   www.aja.com and peg. Note that the while associatedDomain values are used
   in searching to
   search for the entry, but the distinguished name is may be parsed to
   determine the host's canonical name. The MAC address, boot image, Ethernet address and
   two four
   boot parameters are also specified in this entry. The auxilary



Howard                                                         [Page 20]





Internet Draft              NIS X.500 schema           12 September 1997


   class domainRelatedObject is not mandatory. (Thus, the NIS maps
   prefixed by 'hosts', 'ethers', and 'bootparams' could all be derived
   from similar entries.) specified.

   An example of the nisNetgroup class:

           dn: cn=nightfly, dc=aceindustry, dc=aja, dc=com
           cn: nightfly
           objectClass: top
           objectClass: nisNetgroup
           cn: nightfly
           nisNetgroupTriple: (fagen,peg,dunes.aceindustry.com) (charlemagne,peg,dunes.aja.com)
           nisNetgroupTriple: (becker,-,) (lester,-,)
           memberNisNetgroup: kamakiriad

   This entry represents the netgroup nightfly, which contains two
   triples (the user fagen, charlemagne, the host peg, and the domain
   dunes.aceindustry.com;
   dunes.aja.com; and, the user becker, lester, no host, and any domain) and one
   netgroup (kamakiriad).

   Finally, an example of the nisObject class:

           dn: nisMapName=quote.byname, nisMapName=tracks, dc=dunes, dc=aceindustry, dc=aja, dc=com
           objectClass: top
           objectClass: nisObject
           nisMapName: quote.byname tracks

           dn: cn=foobar, nisMapName=quote.byname, cn=Maxine, nisMapName=tracks, dc=dunes, dc=aceindustry, dc=aja, dc=com
           objectClass: top
           objectClass: nisObject
           objectClass: cacheObject
           ttl: 86400
           cn: foobar Maxine
           nisMapName: quote.byname tracks
           nisMapEntry: 75.00 Nightfly$4

   This entry represents the NIS map quote.byname, and a constitutent
   entry, with the key of foobar tracks, and a value of 75.00. The latter entry
   has a time-to-live of 24 hours. single map entry.







Howard                                                         [Page 21] 20]



----