RFC 1609
Charting Networks in the X.500 Directory
Charting Networks in the X.500 Directory 🗺️✨
RFC 1609 💖
- Authors: G. Mansfield (AIC Systems Laboratory), T. Johannsen (Dresden University), M. Knopper (Merit Networks, Inc.) 🫶
- Category: Experimental 🧪
- Date: March 1994 📅
- Obsoletes/Updates: The title block doesn't list any RFC this one obsoletes or updates 🙈
Status of This Memo 📋
okay so this memo defines an Experimental Protocol for the Internet community 🧪. It is NOT an Internet standard of any kind, so don't treat it like one 😭. They're literally asking for discussion and suggestions for improvement, so share your thoughts 💬. Distribution is unlimited, meaning everyone can read it 🌈.
Abstract 🦋
ngl this is the big picture 🔥. We need a framework where infrastructure and service info about communication networks is accessible from all places, at all times, in a reasonably efficient way, and with reasonable accuracy 👑. This document shows a model where a whole communication network, with all its details and descriptions, can live in the X.500 Directory 📚. It also presents schemas of objects and their attributes for doing this 🧚. The model covers physical objects and several logical abstractions of those physical objects 💜.
Table of Contents 📖
1. Introduction 2
2. Infrastructural information requirements 2
3. The Nature of the Network Map - The X.500 Solution 4
4. The hierarchical model of a network 5
4.1 Network maps 5
4.2 Representation in the X.500 Directory 6
5. Position in The Directory Information Tree(DIT) 7
6. Proposed Schemes 8
6.1 Communication Object Classes 9
6.2 Physical elements 10
6.2.1 Network 10
6.2.2 Node 11
6.2.3 NetworkInterface 12
6.3 Logical Elements 12
6.3.1 Network 13
6.3.2 Node 13
6.3.3 NetworkInterface 13
7. Security Considerations 14
8. Authors' Addresses 14
9. References 151. Introduction 🎀
the rapid, widespread use of computer networking has made it super clear how important it is to hold and serve information about the networking infrastructure itself 💅. Network management is growing and people are really into it, mostly for fault and performance management on a local scale 🔥. But it's seriously held back because there's no organized pool of info about the network infrastructure itself 😭. Some piecemeal attempts have been made to give a bigger view of particular parts of the network (WHOIS, DNS, .. in the case of the Internet; [1], [2]) 🌸. But so far, little or no effort has gone into building the infrastructural framework for that info pool 🙈. In this work, we explore setting up a framework to hold and serve the infrastructural information of a network 🦋.
2. Infrastructural information requirements 🗺️
okay so network operation and management need info about the structure of the network, including nodes, links, and their properties 🧠. Current networks are literally beyond bounds 🌍, so the info has to cover networks beyond the span of a local domain of authority or administration 💜. When the network was small and simple, the map was already known to the knowledgable network administrator 👩💻. From that knowledge, the path of packets to different destinations could be charted 🗺️. But the network is now way too big for that 💀. Its growth is near explosive 🚀. This creates an urgent need for infrastructural and service related information that's accessible from all places, at all times, in a reasonably efficient manner and with reasonable accuracy ✨.
In the rest of this work, a network is the media for transmitting information 📡. Network elements are equipment with one or more network interfaces, which let them exchange information with the network 🔌. Network elements with multiple interfaces, e.g., gateways/routers/bridges/repeaters..., may be used to connect networks 🌉. Network related information, referred to as 'network map' in the rest of this paper, should:
- Show the interconnection between the various network elements. This will basically represent the Network as a graph where vertices represent objects like gateways/workstations/subnetworks and edges indicate the connections 🕸️.
- Show properties and functions of the various network elements and the interconnections. Attributes of vertices will represent various properties of the objects, e.g., speed, charge, protocol, OS, etc. Functions include services offered by a network element 🧩.
- Contain various name and address information of the networks and network elements 🏷️.
- Contain information about various administrative and management details related to the networks and network elements 📋.
- Contain the policy related information, part of which may be private while the other part may be made public 🔐.
Using this map, the following services may be provided 💖:
- Configuration management:
- Display the physical configuration of a network, i.e., nodes and their physical interconnections
- Display the logical configuration of a network, i.e., nodes and their logical interconnections.
- Route management:
- Find alternate routes by referring to the physical and logical configurations.
- Generate routing tables considering local policy and policy of transit domains
- Check routing tables for routing loops, non-optimality, incorrect paths, etc.
- Fault management: In case of network failures, alternatives may be found and used to bypass the problem node or link 🛠️.
- Service management: Locate various services and servers in the Network 🔍.
- Optimization: The information available can be used to carry out various optimizations, for example cost, traffic, response-time, etc. 📈.
- Provide mappings between the various names and addresses of elements 🔁.
- Depict administrative/autonomous domains 🗂️.
- Network Administration and Management: References to people responsible for administering and technically maintaining a network will be useful 🧑💻.
Examples of such usages are described in [3], [4] 📚.
3. The Nature of the Network Map - The X.500 solution 🌐
ngl, building and maintaining a detailed map of the network is a serious problem 😭. The map is global and the network keeps expanding 🚀. Here are some problems that are specific to the network map:
- The Network configuration is quasi-static. Nodes, links and networks are being added, updated and deleted someplace or the other 🔄.
- The Network is huge and geographically distributed 🌎.
- The network spans several political and administrative areas. The related information is also controlled and maintained in a distributed fashion 🏛️.
Short version: global network configuration info is unwieldy and growing nonstop, so it's impossible to manage it in a centralized way 🙅♀️. We need a distributed framework that lets users and applications access info about users, services, networks, ... easily and globally 🌸. The OSI X.500 Directory services [5] give us a rich framework for a globally distributed information service system 💜. The X.500 Directory is meant to be a very large, highly distributed database 🗄️. It's structured hierarchically, with entries arranged in a tree where each object corresponds to a node or an entry 🌳. Info about an object is stored as a set of attributes 🎀.
4. The hierarchical model of a network 🪆
To represent networks in the Directory, we use the following hierarchical model 💅.
A network is the media for transmitting information, with zero or more network elements, each having at least one network interface on the media. The media may be any kind of line (physical circuit/virtual circuit), or a collection of interconnected networks 🔗.
< The postscript version of this document >
< has a figure here. However, the figure >
<is too complex to be drawn in simple ASCII.>
Figure 1: Simple and composite networks and their mapping to the DIT.The model allows a hierarchy of subnetworks 🪜. Network elements with multiple interfaces may act as external gateways to the attached network and to networks higher up in the hierarchy 🚪. So a gateway may be the external gateway of several networks that are either interconnected or have a hierarchical relationship 🦋.
A network may be simple, consisting of zero or more network elements, or composite, consisting of several sub-networks 🧩. Examples of simple networks are ethernets, optical fiber/copper cables, free space, .. . ⚡
4.1 Network Maps 🗺️✨
Using the above model, it's straightforward to draw the topological graph of the network, where the vertices represent the components of the network and edges indicate the connections 🕸️. For a visual representation, the graph may be translated into a more "physical" illustration (figure 1) 🎨.
Just as there are several maps of the same geographical domain (political, natural...), one can envisage several views of the same network and its components 🌈. A view (called "image" in the remainder) could pertain to a particular protocol suite (IP/OSI/...), an administrative domain or purpose 💜. Using images, several abstractions of the same object are possible 🧚.
4.2. Representation in the X.500 Directory
okay bestie, so to draw all the different "images" of a network and how they connect to the real stuff, we make up three classes of objects 💅✨
- Communication Object Class (CO): All objects defined furtheron in this document belong to this class. Common attributes for all communication objects are defined in section 6.
- Physical Communication Object Class (PCO): A subclass of CO-class. This class defines common properties for all objects representing physical communication objects.
- Image Communication Object Class (ICO): A subclass of CO-class. This class defines common properties for all objects representing images of communication objects.
So the above classes sort every communication object into either physical or image. As the name says, a physical object has attributes that describe its physical properties, like location, weight, size, .... etc. 📦 An image object gets an Image-of attribute, and that attribute points to either a physical object or another image object 🔗
Here's the wild part 🤯 With this schema you can represent several logical network systems (running different protocol stacks, like IP, XNS, SNA, OSI, ...) all coexisting on the same physical network 🌈 Info about all these different network types, no matter which underlying protocol they use, lives in the Directory in perfect harmony 🫶 Their relationships get represented too, and you access all of it the same way no matter which source or destination network you're coming from, namely using the OSI X.500 protocol. Iconic 👑
Schemes for physical networks and for logical images of physical networks are defined in section 6.
All objects are defined in section 6.
...............
: :
: IP OSI :
: +-+ +-+ :
: |A| |B| :
NetWork -----> : +-+ +-+ :
/ \ : | | :
/ \ : ============ :
/ \ : | :
/ \ : +-+ :
/ \ : |C| :
/ \ : +-+ :
OSI-image IP-image : IP + OSI :
| | +..............+
V V
........ ........
: : : :
IP : OSI : : IP : OSI
+-+ : +-+ : : +-+ : +-+
|A| : |B| : : |A| : |B|
+-+ : +-+ : : +-+ : +-+
....|...: | : : | :..|...
: ============ : : ============ :
: | : : | :
: +-+ : : +-+ :
: |C| : : |C| :
: +-+ : : +-+ :
: IP + OSI : : IP + OSI :
+..............+ +..............+Figure 2: Several logical views of the same physical network
5. Position in the Directory Information Tree (DIT)
Info about networks usually lives in the DIT as a subordinate of the organization that maintains the network 🏢 The network model gets mapped into a tree structure for the network elements. There's one network object that gives the general description of the network. Its subordinates are node objects, one for each node element in the network, and node objects hold networkInterface objects as their own subordinates 🌳 A network can be physically or logically split into several (sub)networks. When that happens, a network entry gets network objects as subordinates, and those build the same structure all over again 🪆 These entries can also be kept as subordinates of organizationalUnit entries, with pointers coming from the "root" network.
This structure works for both physical and logical elements. The physical ones are named network, node and networkInterface, and the logical ones are named networkImage, nodeImage and networkInterfaceImage ✨
_root_
/ \
/ \
/ \
country \
/ \
/ organization
/ / | \
/ / | \
/ / | \
/ / | \
/ organizationalUnit* | \
/ / \ \ | \
/ / \ \__|_________ \
/ / \ | \ \
Person Network*<====>NetworkImage*
| |
| |
Node NodeImage
| |
| |
NetworkInterface NetworkInterfaceImage
Legends: * the object may recursively contain objects of
same class as children
Figure 3: Part of the Directory Information Tree,
showing relations of White Pages and network objectsFigure 3: Part of the Directory Information Tree, showing relations of White Pages and network objects
6. Proposed Schemes
A physical network is made up of wires and machines 🔌 The physical map of the network shows how these nodes are interconnected by these circuits 🗺️
For each physical network element, one or more images may exist 🪞 And the reverse is true too: an image may be attached to one or more physical objects. The types of images can grow along with the requirements 🌱 Relationships between elements (physical or logical) get expressed through attributes or through the element's position in the Directory tree.
Problems that are addressed in the schema:
- Avoiding data duplication
- Preserving administrative boundaries/controls.
- Simple representation (minimal number of pointers)
- Security: Though no special emphasis has been placed in this work, we believe the X.500 access control policies provide a reasonable secure framework for security and privacy 🔐
Security is an important one, bestie, so read item 4 carefully. The schema does not put special emphasis on security; the authors' belief is only that X.500 access control policies give a reasonable framework for it.
Problems that are not addressed:
- Caching policies, etc.: to be decided locally
6.1. Communication Object Classes
The object classes introduced in section 4 are defined as follows 💖
CommunicationObject OBJECT CLASS
SUBCLASS of top
MAY CONTAIN {
description :: CaseIgnoreStringSyntax,
/* can contain any information about the object,
however, wherever an appropriate attribute
exists, this should be used first to hold
information */
adminContact :: distinguishedNameSyntax,
/* points to the person which is responsible for
the administration of the instance this object
describes;
This refers to the instance only in the context
of the concrete object class */
technContact :: distinguishedNameSyntax,
/* points to the person which is responsible for
the technical maintenance of the instance this
object describes;
This refers to the instance only in the context
of the concrete object class;
Availability (e.g. hours of service) is not
covered by this attribute. */
}
PhysicalCommunicationObject OBJECT CLASS
SUBCLASS of CommunicationObject
MAY CONTAIN{
owner :: distinguishedNameSyntax,
/* refers to organization or person owning the
physical element;
Note that more detailed information (like lease,
rental, etc.) can be covered in a specific image
(ownerImage) of this element */
localityName :: CaseIgnoreStringSyntax
/* where the object is located;
can be used freely to "spot" a network element,
e.g. state/city/street/building/floor/room/
desk/... */
ICO :: distinguishedNameSyntax
/* points to image object the physical object
is related to;
might have several values if physical object is
used for several applications at the same time */
}
ImageCommunicationObject OBJECT CLASS
SUBCLASS of CommunicationObject
MAY CONTAIN{
type :: caseIgnoreStringSyntax,
/* expresses the view this object refers to, e.g.
view of provider/user/IP/OSI/...;
Note that this information can be covered by
the object class in some cases
(e.g. ipNetworkImage gives the IP view) */
imageOf :: distinguishedNameSyntax,
/* points to physical/image object the image
is related to;
might have several values if view applies to
several physical objects at the same time */
}6.2. Physical elements
These objects describe network elements without saying anything about how they're used 🧐 Every one of them inherits the properties of the PhysicalCommunicationObject class.
6.2.1. Network
The network object supplies the general descriptions that are common to a set of nodes and circuits making up one network 🌐 That includes info about the type of circuits (medium, broadcast or point-to-point, etc.) and their properties (speed etc.).
network OBJECT CLASS
SUBCLASS of PhysicalCommunicationObject
MUST CONTAIN {
networkName :: caseIgnoreStringSyntax }
MAY CONTAIN {
externalGateway :: distinguishedNameSyntax,
/* points to one or more nodes that connect
this network to neighbor networks;
whether a node actually is used as gateway
for one or the other protocol, is defined
in a related networkImageObject */
nwType :: caseIgnoreStringSyntax,
/* type of this network;
either "composite" (if consisting of subnetworks)
or type of a line:
bus, ring, star, mesh, point-to-point */
media :: caseIgnoreStringSyntax,
/* if network is not composite,
describes physical media:
copper, fiber optic, etc. */
speed :: numericStringSyntax,
/* nominal bandwidth, e.g. 64 kbps */
traffic :: numericStringSyntax
/* (average) use in percent of nominal bandwidth
[ this needs more specification later ] */
configurationDate :: uTCTimeSyntax,
/* date when network was configured in current
shape */
configurationHistory :: caseIgnoreStringSyntax
/* list of configuration changes, like:
added/removed nodes, lines */
}6.2.2. Node
The node object describes any kind of device that is part of the network, such as simple nodes, printers, and bridges 🖨️
node OBJECT CLASS
SUBCLASS of PhysicalCommunicationObject
MUST CONTAIN{
nodeName :: caseIgnoreStringSyntax }
MAY CONTAIN {
machineType :: caseIgnoreStringSyntax,
/* e.g. main frame, work station, PC, printer;
might include manufacturer */
OS :: caseIgnoreStringSyntax,
/* e.g. VM, UNIX, DOS; might include release */
}6.2.3 NetworkInterface 🎀✨
okay so every node object is gonna have one or more networkInterface objects as subordinates 💅 these are the ones that tell you about the node's interfaces and how it's connected, bestie 🌸
networkInterface OBJECT CLASS
SUBCLASS of PhysicalCommunicationObject
MUST CONTAIN {
networkInterfaceName :: caseIgnoreStringSyntax
/* It is suggested that the networkInterface
name is derived from the name of the logical
device this networkInterface represents for
the operating system, e.g. le0, COM1 */
}
MAY CONTAIN {
networkInterfaceAddress :: caseIgnoreStringSyntax,
/* this should contain a protocol-independent
interface address, e.g. Ethernet board number */
connectedNetwork :: distinguishedNameSyntax,
/* pointer to object of network which this networkInterface is
connected to */
}the networkInterfaceName MUST be there, no cap 🫶 and it's suggested to use the name of the logical device the OS sees, like le0 or COM1 🔥 the address and connectedNetwork are MAY, so they're optional, but the address should be protocol-independent, like an Ethernet board number ✨ and connectedNetwork is just a pointer to the network it's hooked up to 🦋
6.3. Logical Elements 🧚
okay this part's about images 🌈 an image is just an abstract view of a physical element, and you add the word image to the object type, so you get networkImage, nodeImage and networkInterfaceImage 💖 images either build their own Directory trees, or they get stored as part of the physical network tree (see section 5) 💜
all image objects inherit from the ImageCommunicationObject class ✨
here's the tea 🍓 every image has attributes that depend on the point of view (IP, OSI, whatever) and the user and provider of an image see it differently. a user might also be providing services of that same object to someone else 🙈
so a complete and general list of attributes can't be given, lowkey 💀 instead, we recommend defining subclasses of Image classes for each logical view. those subclasses inherit everything from the object classes below and add more specific attributes 🫶 examples for an IP-view are given in [1] 🌸
6.3.1. Network 🌷
there may be several network images for one and the same physical network: one for each protocol, application, etc 🦋
networkImage OBJECT CLASS
SUBCLASS of ImageCommunicationObject
MAY CONTAIN {
externalGateway :: distinguishedNameSyntax,
/* points to one or more nodes that act
as gateway for the protocol application
this images refers to */
speed :: numericStringSyntax,
/* nominal bandwidth for the channel dedicated
to this protocol or application ,
e.g. 64 kbps */
traffic :: numericStringSyntax,
/* (average) use in percent of nominal bandwidth
[this needs more specification later ] */
charge :: numericStringSyntax
/* amount of money that has to be paid to
service provider for usage;
[it is felt that this needs further definition:
e.g. monetary unit / time unit, monetary unit /
data unit ] */
}all of these are MAY, so they're optional 🌈 externalGateway points to one or more nodes acting as gateway for the protocol or application the image is about, speed is the nominal bandwidth for that channel (like 64 kbps 🔥), traffic is the average use as a percent of nominal bandwidth (this still needs more specification, ngl 🙈), and charge is the money paid to the service provider for usage (also still needs more definition, periodt 💅)
6.3.2. Node 🎀
name and functionality of a node can vary from protocol to protocol, so a node might be a gateway for one protocol but not another 🦋 routing policy gets stored in the case of policy gateways 💜
nodeImage OBJECT CLASS
SUBCLASS of ImageCommunicationObject
/* no attributes common for all nodeImages have been
defined yet */no common attributes for nodeImages have been defined yet, so it's kinda empty for now 🥺✨
6.3.3. NetworkInterface 🌸
just like physical nodes, nodeImages have networkInterfaces (networkInterfaceImages) that describe connectivity to other network elements 💖 networkInterfaceImages only show up if the protocol is establishing connections through that networkInterface 🫶
networkInterfaceImage OBJECT CLASS
SUBCLASS of ImageCommunicationObject
MAY CONTAIN {
networkInterfaceAddress :: caseIgnoreStringSyntax,
/* the networkInterface address in the image
context, e.g. IP number, NSAP */
connectedNetwork :: distinguishedNameSyntax
/* pointer to networkImageObject that describes
the network this networkInterface is attached
to in terms of the protocol or application the
image indicates */
}both of these are MAY too 🦋 the address is the networkInterface address in the image context, like an IP number or NSAP 🌈 connectedNetwork points to the networkImage object describing the network it's attached to, in terms of the protocol or app the image is about 💜
7. Security Considerations 🚨
okay, this part is short but it's serious bestie 😭 security issues are not discussed in this memo 💀 so if you're building on this, go find security info somewhere else, no cap 🙈
8. Authors' Addresses 🎀
Glenn Mansfield 🌸 AIC Systems Laboratory 6-6-3 Minami Yoshinari Aoba-ku, Sendai 989-32 Japan
Phone: +81 22 279-3310 EMail: glenn@aic.co.jp
Thomas Johannsen 🦋 Dresden University of Technology Institute of Communication Technology D-01062 Dresden Germany
Phone: +49 351 463-4621 EMail: Thomas.Johannsen@ifn.et.tu-dresden.de
Mark Knopper 💖 Merit Network, Inc. 1071 Beal Avenue Ann Arbor, MI 48109
EMail: mak@merit.edu
9. References 📚
[1] Harrenstein, K., Stahl, M., and E. Feinler, "NICNAME/WHOIS", RFC 954, SRI, October 1985. 🌷
[2] Mockapetris, P., "Domain Names - Implementation and Specification", STD 13, RFC 1035, USC/Information Sciences Institute, November 1987. 🧚
[3] Johannsen, T., Mansfield, G., Kosters, M., and S. Sataluri, "Representing IP information in the X.500 Directory", RFC 1609, Dresden University, AIC Systems Laboratory, Network Solutions,Inc., AT&T Bell Laboratories, March 1994. 💜
[4] Johannsen, T., and G. Mansfield, "The Soft Pages Project", OSI-DS WG document, OSI-DS-39, Dresden University, AIC Systems Laboratory, February 1993. 🌈
[5] CCITT Blue Book, "Data Communication Networks: Directory", Recommendations X.500-X.521, December 1988. ✨
📦 where this page comes from
- ietf: rfc1609 1994-03
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms