RFC 7729
Forwarding and Control Element Separation (ForCES) Logical Functional Block (LFB) Subsidiary Management
RFC 7729: ForCES Logical Functional Block (LFB) Subsidiary Management 💖
Okay bestie, this RFC is from the IETF, and it's Standards Track 🎀 (so it's an official Internet standard, not just a suggestion). It's ISSN 2070-1721, dated December 2015, and it's about the ForCES architecture. Its three authors are B. Khasnabish (ZTE TX, Inc.), E. Haleplidis (University of Patras), and J. Hadi Salim, Ed. (Mojatatu Networks). The title block lists no Obsoletes or Updates, so it doesn't replace or change any older RFCs 🦋.
Abstract ✨
Okay so, deployment experience has shown that ForCES (Forwarding and Control Element Separation) is seriously useful for managing stuff that isn't just packet forwarding 💅. So the Forwarding Element Manager (FEM) gets modeled as a Logical Functional Block (LFB), and this one is called the Subsidiary Mechanism (SM) LFB 🌸. A Control Element (CE) that runs a Forwarding Element's (FE) resources can also manage its config through the SM LFB, which is giving main character energy 👑.
This doc introduces the SM LFB class, an LFB class that describes an FE's configuration parameters 🧚. Those include loading new LFB classes, CE associations, debug mechanism manipulation, and a general purpose attribute definition for config info 🍓.
Status of This Memo ⭐
This is an Internet Standards Track document. 🎀
It's a product of the Internet Engineering Task Force (IETF) and represents the consensus of the IETF community 🫶. It got public review and was approved for publication by the Internet Engineering Steering Group (IESG) ✨. For more on Internet Standards, check Section 2 of RFC 5741 💜.
Info about the current status, errata, and how to give feedback lives at http://www.rfc-editor.org/info/rfc7729 🌈.
Copyright Notice 💅
Copyright (c) 2015 IETF Trust and the persons identified as the document authors. All rights reserved 🔥.
This doc is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) as they were in effect on the publication date 📜. Read them carefully, because they explain your rights and restrictions 🙈. Code Components pulled from this doc must include Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions, and they come without warranty as described in the Simplified BSD License 🦋.
Table of Contents 🌸
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1. Requirements Language . . . . . . . . . . . . . . . . . . 5
1.2. Definitions . . . . . . . . . . . . . . . . . . . . . . . 5
2. Use Cases . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1. High Availability . . . . . . . . . . . . . . . . . . . . 6
2.2. Scalability . . . . . . . . . . . . . . . . . . . . . . . 6
2.3. Adding New Resources to an NE . . . . . . . . . . . . . . 6
2.4. New LFB Class Installation . . . . . . . . . . . . . . . 6
2.5. Logging Mechanism . . . . . . . . . . . . . . . . . . . . 7
2.6. General-Purpose Attribute Definition . . . . . . . . . . 7
3. Applicability Statement . . . . . . . . . . . . . . . . . . . 8
3.1. FE Integrated . . . . . . . . . . . . . . . . . . . . . . 8
3.2. Virtual FEs . . . . . . . . . . . . . . . . . . . . . . . 8
4. SM Library . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.1. Frame Definitions . . . . . . . . . . . . . . . . . . . . 8
4.2. Data Type Definitions . . . . . . . . . . . . . . . . . . 9
4.3. Metadata Definitions . . . . . . . . . . . . . . . . . . 9
4.4. SM . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.4.1. Data Handling . . . . . . . . . . . . . . . . . . . . 10
4.4.2. Components . . . . . . . . . . . . . . . . . . . . . 10
4.4.3. Capabilities . . . . . . . . . . . . . . . . . . . . 10
4.4.4. Events . . . . . . . . . . . . . . . . . . . . . . . 11
5. XML for SM LFB . . . . . . . . . . . . . . . . . . . . . . . 11
6. Security Considerations . . . . . . . . . . . . . . . . . . . 17
7. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 18
7.1. LFB Class Names and LFB Class Identifiers . . . . . . . . 18
8. References . . . . . . . . . . . . . . . . . . . . . . . . . 18
8.1. Normative References . . . . . . . . . . . . . . . . . . 18
8.2. Informative References . . . . . . . . . . . . . . . . . 19
Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . . 20
Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 201. Introduction ✨
Deployment experience has shown the value of using ForCES to manage resources beyond packet forwarding 💖. So the FEM gets modeled as an LFB, called the SM LFB 🎀. A CE that controls an FE's resources can also manage that FE's config through the SM LFB 🦋. This doc introduces the SM LFB class, an LFB that specifies an FE's configuration parameters 🧚.
On a running FE, a CE application may update the FE's runtime configuration through an SM LFB instance 🌸.
ForCES Network Element
+-------------------------------------+
| +---------------------+ |
| | Control Application | |
| +--+--------------+---+ |
| | | |
| | | |
-------------- Fc | -----------+--+ +-----+------+ |
| CE Manager |---------+-| CE 1 |------| CE 2 | |
-------------- | | | Fr | | |
| | +-+---------+-+ +------------+ |
| Fl | | | Fp / |
| | | +--------+ / |
| | | Fp |/ |
| | | | |
| | | Fp /|----+ |
| | | /--------/ | |
-------------- Ff | ---+---------- -------------- |
| FE Manager |---------+-| FE 1 | Fi | FE 2 | |
-------------- | | |------| | |
| -------------- -------------- |
| | | | | | | | | |
----+--+--+--+----------+--+--+--+-----
| | | | | | | |
| | | | | | | |
Fi/f Fi/f
Fp: CE-FE interface
Fr: CE-CE interface
Fc: Interface between the CE Manager and a CE
Ff: Interface between the FE Manager and an FE
Fl: Interface between the CE Manager and the FE Manager
Fi/f: FE external interface
Figure 1: ForCES Architectural DiagramFigure 1 shows a control app changing FE config at runtime through the SM LFB control 🔥. You might think this control app is acting as the FE Manager and therefore shows up as messaging for Ff (FEM to FE interface) over the standard Fp plane 🙈. But the SM LFB only describes a subset of the operations that can happen over Ff, so it doesn't mean leaving the Ff interface behind 💅.
The SM LFB class describes an FE's config parameters: which LFB classes it should load, which CEs it should be associated with, and those CEs' IP addresses 📜. It also gives a general purpose attribute definition for config info, plus the ability to manipulate the debug logging mechanism 🌈.
This doc assumes FEs are already booted 💜. Their config can then be updated at runtime through the SM LFB for runtime config purposes ⭐. This doc does not specify or standardize the FEM-FE (Ff) interface as shown in [RFC3746] 🙅. Instead, it describes a mechanism where a CE can tell the SM how to manage the FE using ForCES 🦋.
This work item makes no assumption about whether FE resources are physical or virtual 🌸. The LFB library here applies to both 🧚. So it can also help control virtual FEs, where individual FEMs can be addressed to control the creation, configuration, and resource assignment of virtual FEs inside a physical FE 🍓.
1.1. Requirements Language 🎀
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in [RFC2119] 💖.
1.2. Definitions 💅
This doc follows the terminology from [RFC3654], [RFC3746], [RFC5810], and [RFC5812] 📖. Specifically, the reader is expected to already know these terms ✨:
- Logical Functional Block (LFB) 🧩
- Forwarding Element (FE) 🌸
- Control Element (CE) 🎀
- ForCES Network Element (NE) 🦋
- FE Manager (FEM) 🧚
- CE Manager 🍓
- ForCES Protocol 💜
- ForCES Protocol Layer (ForCES PL) 🌈
- ForCES Protocol Transport Mapping Layer (ForCES TML) ⭐
2. Use Cases 🦋
Here we go with some sample use cases to show why the SM LFB is needed and useful 💖.
All of these use cases assume an FE is already booted up and tied to at least one CE 🎀. A control application can delete a CE from an FE's table of CEs, and that tells the FE to end its connection with the removed CE 🙅. Likewise, the control application, through the master CE, can tell an FE to set up a ForCES association with a new CE by adding that CE to the FE's CEs table 🌸.
2.1. High Availability 🫶
Say an FE is associated with only one CE 🧚. At runtime, a CE management app might ask, for redundancy reasons, that the FE be associated with another CE as a backup 🔥. To do this, the CE management app specifies the Control Element ID (CEID) of the new backup CE (which has to be uniquely identifiable within the NE) and that CE's IP address (IPv4 or IPv6) 💅.
2.2. Scalability 🚀
Picture an NE cluster with FEs connected to multiple CEs, possibly in an active backup setup 🌈. Now say system analytics notice that a CE is turning into a bottleneck 😭. A new CE could be booted and some FEs moved over to it 🍓. To do this, the CE management app first asks an FE to connect to a new CE, then tells that FE to change its master to the new CE, as described in [RFC7121] 💜.
2.3. Adding New Resources to an NE
okay so picture this 🫶 a resource pooling setup with a bunch of FEs all in one pool, every single one connected to a dormant resource pool CE 💤. an NE system manager can totally pull an FE out of that pool and move it onto a working NE whenever they need to 🦋. how? they tell the FE to connect to a CE on the working NE first, and then tell it to disconnect from the resource pool manager CE. it's giving glow-up 💅
2.4. New LFB Class Installation
the CE can find out, through the DynamicLFBLoading capability of the SM LFB, whether an FE is able to load new LFB classes 👀. if the FE does support new LFB class loading, the CE can request that a new LFB gets installed and supported by the FE ✨
to load an LFB class on an FE, the CE has to provide these parameters:
- LFB class - The LFB class ID
- LFB version - The version of the LFB class
- LFB class name - Optional, the LFB name
- Parameters - Optional parameters. These parameters are implementation specific. For example, in one implementation they may contain the path where the LFB class implementation resides.
the parameters are fields that need documenting, and what goes in them depends on the implementation 📝. one example is where the LFB class to be installed lives, and/or how to download it 🌸. the exact details of location semantics are implementation specific and out of scope for this document, bestie 🙈. BUT this LFB library gives us a placeholder, the SupportedParameters capability, which will host any standardized parameters 💜
this document doesn't standardize these parameters. some future document is expected to handle that 🧚. they're placeholders so we don't have to redefine the LFB class versions every time 🎀. they're simple strings that describe which parameters the LFB supports, and the CE is expected to read this capability to figure out which parameters it can use 💅
2.5. Logging Mechanism
the SM LFB class also gives us some really useful log-level manipulation 🔥. experience has shown that the CE may need to turn debug levels up or down for parts of the FE, whether that's LFBs, portions of LFBs, or generic processing code. all of these are called "modules" 🧩. the module granularity is implementation specific, and this document doesn't go into it 🤷♀️. the debug levels are derived from the "syslog Message Severities" registry, which lives at http://www.iana.org/assignments/syslog-parameters and is defined in [RFC3164] 🌈
2.6. General-Purpose Attribute Definition
experience has also shown that a generic attribute name-value pair is super useful for describing configuration information ✨. this LFB class defines exactly that, as a table of attribute name-value pair values 📋. the attribute name-value pair is implementation specific, and for now there's nothing to standardize 🙃. for example, picture switches with the exact same LFB classes and capabilities that still need to play different roles, like a Spine switch or a Top-of-Rack (ToR) switch in data-center setups 🏢. an attribute that defines the role can be retrieved from the FE, and that then decides how the switch gets controlled and configured 🎀
same as with the LFB class loading parameters, this LFB class library gives us a placeholder, the SupportedArguments capability, which will host any standardized arguments 💖. this document doesn't standardize these parameters either. the CE is expected to read the SupportedArguments capability to know which attributes it can use 🫶
3. Applicability Statement
okay, so there are a couple of usage scenarios for SM 💫. these two are not implementation details, they just show how the SM class can be used to get the intended SM for manipulating FE configuration ✨. there are more, but these are the main ones, so no need to panic about the rest 🌸
3.1. FE Integrated
only one instance of the SM LFB class can exist, and it's directly related to the FE 🦋
3.2. Virtual FEs
if the FE software has hierarchical virtual FEs, multiple instances of the SM LFB class can exist, one per virtual FE 🧚♀️ it's like having a little SM for each one 💅
4. SM Library
4.1. Frame Definitions
this LFB class doesn't define any frames 🙈
4.2. Data Type Definitions
this library defines the following data types 📚
+------------+--------------------------------------+---------------+
| Data Type | Type | Synopsis |
| Name | | |
+------------+--------------------------------------+---------------+
| loglevels | An enumerated char-based atomic data | The possible |
| | type. | debug log |
| | | levels. |
| | | Derived from |
| | | syslog. |
| LogRowType | A struct containing three | The logging |
| | components: the LogModule (string), | module row. |
| | the optional ModuleFilename | |
| | (string), and the optional | |
| | DebugLevel, which is one of the | |
| | enumerated loglevels. | |
| CERow | A struct that contains three | A struct that |
| | components: the address family of | defines the |
| | the CE IP (uchar), the CE's IPs | CE table row. |
| | (octetstring[16]), and the CE's ID | |
| | (uint32). | |
| LCRowtype | A struct that contains four | The LFB Class |
| | components: the LFB class ID | Configuration |
| | (uint32), the LFB version | Definition. |
| | (string[8]), the optional LFB Name | |
| | (string), and the optional | |
| | Parameters (string). | |
| NameVal | A struct that contains two | Arbitrary |
| | components: an attribute name | Name Value |
| | (string) and an attribute value | struct. |
| | (string). | |
+------------+--------------------------------------+---------------+FEM Data Types 🎀
4.3. Metadata Definitions
this LFB doesn't define any metadata definitions, so there's nothing to see here 🫧
4.4. SM
the Subsidiary Mechanism LFB is an LFB that standardizes configuration of the FE parameters 💜
4.4.1. Data Handling
the SM LFB doesn't handle any packets 🙅♀️. its whole job is to give the CE the configuration parameters so they can be updated at runtime ⚡
4.4.2. Components
this LFB class has four components specified 🧩
the Debug component (ID 1) is a table for changing an FE's module debug levels 🐛. when rows in an FE's debug table change, the debug level of the matching module changes too 🔥
the LFBLoad component (ID 2) is a table of the LFB classes that the FE loads 📦. adding new rows here tells the FE to load new LFB classes, and removing rows unloads them when that's possible 🌈. these two actions will, in effect, alter the SupportedLFBs capabilities table of the FEObject LFB [RFC5812] 🎀. every row MUST provide the LFB class ID, which this library specifies 💖. optionally, the LFB class ID version may be specified, and the FE MUST assume version 1.0 is used when the version is unspecified 🫶
the AttributeValues component (ID 3) is the AttributeValues table, which is a generic attribute-value pair 🧾
the CEs (ID 4) is the table of runtime CEs that we're asking the FE to be able to connect with 🤝. adding a row here tells the FE it's allowed to connect with the specified CE ✨. deleting from this table tells the FE to terminate any connection with that CE 💀. how the FE interacts with the new CEs depends on the operations discussed in [RFC7121] 💅
worth noting: the generic attribute-value pairs, the LFBload parameters, and the module information are all strings 🧵. to cope with string sizes, a CE application can pull that info out of the component properties, as defined in [RFC5812] 🦋
4.4.3. Capabilities
this LFB provides three capabilities 🌸. the first, DynamicLFBLoading, says whether this FE supports dynamic loading of new LFB classes 👀. the second, SupportedParameters, is a placeholder that stores all the supported parameters for LFB class loading 🎀. the last one, SupportedAttributes, is also a placeholder, and it stores all the supported attributes for the attribute-value pair table 💜
4.4.4. Events
this LFB has four events specified 🔔
two of them reflect CE additions, and report to the CE whether an entry in the CEs information has been added or deleted 🫶. in both cases, the event report contains the contents of the added or deleted row ✨
the other two reflect LFB class loading, and notify whether an entry in the LFBLoad table has been added or deleted 📦
5. XML for SM LFB ✨
Okay bestie, here's the whole XML LFB Library for SM, dropped in exactly as written 💅
<LFBLibrary xmlns="urn:ietf:params:xml:ns:forces:lfbmodel:1.1"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" provides="SM">
<!-- XXX -->
<dataTypeDefs>
<dataTypeDef>
<name>loglevels</name>
<synopsis>The possible debug log levels. Derived from syslog.
</synopsis>
<atomic>
<baseType>char</baseType>
<specialValues>
<specialValue value="-1">
<name>DEB_OFF</name>
<synopsis> The logs are totally turned off </synopsis>
</specialValue>
<specialValue value="0">
<name>DEB_EMERG</name>
<synopsis> Emergency level </synopsis>
</specialValue>
<specialValue value="1">
<name>DEB_ALERT</name>
<synopsis> Alert level </synopsis>
</specialValue>
<specialValue value="2">
<name>DEB_CRIT</name>
<synopsis> Critical level </synopsis>
</specialValue>
<specialValue value="3">
<name>DEB_ERR</name>
<synopsis> error level </synopsis>
</specialValue>
<specialValue value="4">
<name>DEB_WARNING</name>
<synopsis> warning level </synopsis>
</specialValue>
<specialValue value="5">
<name>DEB_NOTICE</name>
<synopsis>Notice level </synopsis>
</specialValue>
<specialValue value="6">
<name>DEB_INFO</name>
<synopsis>Info level </synopsis>
</specialValue>
<specialValue value="7">
<name>DEB_DEBUG</name>
<synopsis>Debug level </synopsis>
</specialValue>
</specialValues>
</atomic>
</dataTypeDef>
<dataTypeDef>
<name>LogRowtype</name>
<synopsis>The logging module row</synopsis>
<struct>
<component componentID="1">
<name>lmodule</name>
<synopsis>The LOG Module Name</synopsis>
<typeRef>string</typeRef>
</component>
<component componentID="2">
<name>filename</name>
<synopsis>The Module File Name</synopsis>
<optional/>
<typeRef>string</typeRef>
</component>
<component componentID="3">
<name>deblvl</name>
<synopsis>debug level</synopsis>
<optional/>
<typeRef>loglevels</typeRef>
</component>
</struct>
</dataTypeDef>
<dataTypeDef>
<name>CERow</name>
<synopsis>The CE Table Row</synopsis>
<struct>
<component componentID="1">
<name>AddressFamily</name>
<synopsis>The address family</synopsis>
<atomic>
<baseType>uchar</baseType>
<specialValues>
<specialValue value="2">
<name>IFA_AF_INET</name>
<synopsis>IPv4</synopsis>
</specialValue>
<specialValue value="10">
<name>IFA_AF_INET6</name>
<synopsis>IPv6</synopsis>
</specialValue>
</specialValues>
</atomic>
</component>
<component componentID="2">
<name>CEIP</name>
<synopsis>CE ip v4 or v6(selected by family)</synopsis>
<typeRef>octetstring[16]</typeRef>
</component>
<component componentID="3">
<name>CEID</name>
<synopsis>The CE ID</synopsis>
<optional/>
<typeRef>uint32</typeRef>
</component>
</struct>
</dataTypeDef>
<dataTypeDef>
<name>LCRowtype</name>
<synopsis>The LFB Class Configuration Definition</synopsis>
<struct>
<component componentID="1">
<name>LFBClassID</name>
<synopsis>The LFB Class ID</synopsis>
<typeRef>uint32</typeRef>
</component>
<component componentID="2">
<name>LFBVersion</name>
<synopsis>The LFB Class Version</synopsis>
<optional/>
<typeRef>string</typeRef>
</component>
<component componentID="3">
<name>LFBName</name>
<synopsis>The LFB Class Name</synopsis>
<optional/>
<typeRef>string</typeRef>
</component>
<component componentID="4">
<name>Parameters</name>
<synopsis>Optional parameters such as where the LFB is
located</synopsis>
<optional/>
<typeRef>string</typeRef>
</component>
</struct>
</dataTypeDef>
<dataTypeDef>
<name>NameVal</name>
<synopsis>Arbitrary Name Value struct</synopsis>
<struct>
<component componentID="1">
<name>AttrName</name>
<synopsis>The Attribute Name</synopsis>
<typeRef>string</typeRef>
</component>
<component componentID="2">
<name>AttrVal</name>
<synopsis>The Attribute Value</synopsis>
<typeRef>string</typeRef>
</component>
</struct>
</dataTypeDef>
</dataTypeDefs>
<LFBClassDefs>
<LFBClassDef LFBClassID="19">
<name>SM</name>
<synopsis>
The Subsidiary Management LFB
</synopsis>
<version>1.0</version>
<components>
<component componentID="1" access="read-write">
<name>Debug</name>
<synopsis>A table to support changing of all debug levels
</synopsis>
<array type="variable-size">
<typeRef>LogRowtype</typeRef>
</array>
</component>
<component componentID="2" access="write-only">
<name>LFBLoad</name>
<synopsis>An LFB Class to Load</synopsis>
<array type="variable-size">
<typeRef>LCRowtype</typeRef>
</array>
</component>
<component componentID="3" access="read-write">
<name>AttributeValues</name>
<synopsis>Table of general purpose SM attribute Values
</synopsis>
<array type="variable-size">
<typeRef>NameVal</typeRef>
</array>
</component>
<component componentID="4" access="write-only">
<name>CEs</name>
<synopsis>Table of CEs we are asking the FE to associate
with</synopsis>
<array type="variable-size">
<typeRef>CERow</typeRef>
</array>
</component>
</components>
<!---->
<capabilities>
<capability componentID="10">
<name>DynamicLFBLoading</name>
<synopsis>This capability specifies whether this FE supports
dynamic loading of new LFBs</synopsis>
<typeRef>boolean</typeRef>
</capability>
<capability componentID="11">
<name>SupportedParameters</name>
<synopsis>This capability contains all the supported
parameters</synopsis>
<array type="variable-size">
<typeRef>string</typeRef>
</array>
</capability>
<capability componentID="12">
<name>SupportedAttributes</name>
<synopsis>This capability contains all the supported
attributes names</synopsis>
<array type="variable-size">
<typeRef>string</typeRef>
</array>
</capability>
</capabilities>
<events baseID="20">
<event eventID="1">
<name>CEAdded</name>
<synopsis>An CE has been added</synopsis>
<eventTarget>
<eventField>CEs</eventField>
</eventTarget>
<eventCreated/>
<eventReports>
<eventReport>
<eventField>CEs</eventField>
<eventSubscript>_CEIDsrowid_</eventSubscript>
</eventReport>
</eventReports>
</event>
<event eventID="2">
<name>CEDeleted</name>
<synopsis>An CE has been deleted</synopsis>
<eventTarget>
<eventField>CEs</eventField>
<eventSubscript>_CEIDsrowid_</eventSubscript>
</eventTarget>
<eventDeleted/>
<eventReports>
<eventReport>
<eventField>CEs</eventField>
<eventSubscript>_CEIDsrowid_</eventSubscript>
</eventReport>
</eventReports>
</event>
<event eventID="3">
<name>LFBLoaded</name>
<synopsis>An LFB has been loaded</synopsis>
<eventTarget>
<eventField>LFBLoad</eventField>
</eventTarget>
<eventCreated/>
<eventReports>
<eventReport>
<eventField>LFBLoad</eventField>
<eventSubscript>_LFBLoadrowid_</eventSubscript>
</eventReport>
</eventReports>
</event>
<event eventID="4">
<name>LFBUnloaded</name>
<synopsis>An CE has been unloaded</synopsis>
<eventTarget>
<eventField>LFBLoad</eventField>
<eventSubscript>_LFBLoadrowid_</eventSubscript>
</eventTarget>
<eventDeleted/>
<eventReports>
<eventReport>
<eventField>LFBLoad</eventField>
<eventSubscript>_LFBLoadrowid_</eventSubscript>
</eventReport>
</eventReports>
</event>
</events>
</LFBClassDef>
</LFBClassDefs>
</LFBLibrary>Figure 2: FEM XML LFB Library
6. Security Considerations 🔐
Okay, this one is serious, so let's get into it 🫶
This document does not alter the ForCES model [RFC5812] or the ForCES protocol [RFC5810]. So it has no impact on their security considerations. What it does do is define the operational parameters and capabilities of an LFB that manages the SM, which covers loading LFBs and creating new connections between FEs and CEs.
On the issue of trust, a designer should keep in mind that the CE that creates new connections to CEs is either:
- The FE manager that is responsible for managing the FEs, or
- An already associated CE
In both of these cases, the entity making the connections should already be trusted to do that job. If the entity making the connections is faulty, rogue, or hacked, there is literally no way for the FE to know, and it will perform any action that the CE requests 💀 So this document does not try to analyze the security issues that could come from misuse of the SM LFB. Any such issues, if they exist, and their mitigation strategies are for the designers of the particular SM implementation, not the general mechanism 🧚
If you want the deep dive on potential threats from ForCES and how the ForCES architecture handles them, the ForCES framework [RFC3746] document is the one to read, especially Section 8 🍓
7. IANA Considerations 🌸
7.1. LFB Class Names and LFB Class Identifiers ✨
Okay so, the LFB classes in this doc belong to LFBs defined by Standards Track RFCs 🦋. For identifiers in the 0 to 65535 range, the registration procedure is Standards Action. For anything over 65535, it's First Come First Served with any publicly available specification [RFC5226]. This spec registers one LFB class name and one LFB class identifier in the "Logical Functional Block (LFB) Class Names and Class Identifiers" registry, and honestly it's giving tidy 💅
+------------+--------+---------+-----------------------+-----------+
| LFB Class | LFB | LFB | Description | Reference |
| Identifier | Class | Version | | |
| | Name | | | |
+------------+--------+---------+-----------------------+-----------+
| 19 | SM | 1.0 | An SM LFB to | RFC 7729 |
| | | | standardize | (this |
| | | | subsidiary management | document) |
| | | | for ForCES Network | |
| | | | Elements | |
+------------+--------+---------+-----------------------+-----------+Logical Functional Block (LFB) Class Name and Class Identifier
8. References 📚
8.1. Normative References
[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate
Requirement Levels", BCP 14, RFC 2119,
DOI 10.17487/RFC2119, March 1997,
<http://www.rfc-editor.org/info/rfc2119>.
[RFC5810] Doria, A., Ed., Hadi Salim, J., Ed., Haas, R., Ed.,
Khosravi, H., Ed., Wang, W., Ed., Dong, L., Gopal, R., and
J. Halpern, "Forwarding and Control Element Separation
(ForCES) Protocol Specification", RFC 5810,
DOI 10.17487/RFC5810, March 2010,
<http://www.rfc-editor.org/info/rfc5810>.
[RFC5812] Halpern, J. and J. Hadi Salim, "Forwarding and Control
Element Separation (ForCES) Forwarding Element Model",
RFC 5812, DOI 10.17487/RFC5812, March 2010,
<http://www.rfc-editor.org/info/rfc5812>.
[RFC7121] Ogawa, K., Wang, W., Haleplidis, E., and J. Hadi Salim,
"High Availability within a Forwarding and Control Element
Separation (ForCES) Network Element", RFC 7121,
DOI 10.17487/RFC7121, February 2014,
<http://www.rfc-editor.org/info/rfc7121>.8.2. Informative References
[RFC3164] Lonvick, C., "The BSD Syslog Protocol", RFC 3164,
DOI 10.17487/RFC3164, August 2001,
<http://www.rfc-editor.org/info/rfc3164>.
[RFC3654] Khosravi, H., Ed. and T. Anderson, Ed., "Requirements for
Separation of IP Control and Forwarding", RFC 3654,
DOI 10.17487/RFC3654, November 2003,
<http://www.rfc-editor.org/info/rfc3654>.
[RFC3746] Yang, L., Dantu, R., Anderson, T., and R. Gopal,
"Forwarding and Control Element Separation (ForCES)
Framework", RFC 3746, DOI 10.17487/RFC3746, April 2004,
<http://www.rfc-editor.org/info/rfc3746>.
[RFC5226] Narten, T. and H. Alvestrand, "Guidelines for Writing an
IANA Considerations Section in RFCs", BCP 26, RFC 5226,
DOI 10.17487/RFC5226, May 2008,
<http://www.rfc-editor.org/info/rfc5226>.Acknowledgments 🫶
The authors want to give a huge shoutout to Damascene Joachimpillai, Joel Halpern, Chuanhuang Li, and many others for their discussions and support, they're iconic 👑
The authors are super grateful to Joel Halpern for shepherding this document 🌸 They also want to thank Alia Atlas for taking on the role of sponsoring this document. And finally, thanks to Juergen Schoenwaelder for his operational directorate's review and Alexey Melnikov for his security review. Main character energy for the whole review squad 💜
Authors' Addresses 🧚
Bhumip Khasnabish
ZTE TX, Inc.
55 Madison Avenue, Suite 160
Morristown, New Jersey 07960
United States
Phone: +001-781-752-8003
Email: vumip1@gmail.com, bhumip.khasnabish@ztetx.com
URI: http://tinyurl.com/bhumip/
Evangelos Haleplidis
University of Patras
Department of Electrical and Computer Engineering
Patras 26500
Greece
Email: ehalep@ece.upatras.gr
Jamal Hadi Salim (editor)
Mojatatu Networks
Suite 200, 15 Fitzgerald Road
Ottawa, Ontario K2H 9G1
Canada
Email: hadi@mojatatu.com📦 where this page comes from
- ietf: rfc7729 2015-12
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms