xorp

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
_TimeLocale
AbortTransaction< A >
AcceptInstruction to accept a route
AcceptSession
Action
PimMreTrackState::ActionLists
AddAddr4Class for adding an IPv4 address to a VIF
AddAddr6Class for adding an IPv6 address to a VIF
XrlPimNode::AddDeleteDataflowMonitorClass for handling the task of add/delete dataflow monitor requests
XrlPimNode::AddDeleteMfcClass for handling the task of add/delete MFC requests
AddEGPTableCommand
AddIGPTableCommand
AddInterfaceClass for adding an interface
AddInterfaceVifClass for adding a VIF to an interface
Addr4ModifierBase class for IPv4vif address modifier operations
Addr6ModifierBase class for IPv6vif address modifier operations
Address< A >
AddressFamilyMismatch
AddressInfo< A >OSPFv3 only, the information stored about an interface address
AddRoute< A >
AddTransactionRoute< A >
Adv< A >Storage for routing table entries indexed by advertising router
AggregateRoute< A >
AggregationFilter< A >Filters out aggregate routes depending whether on IBGP or EBGP outbound branch
AggregationHandler
AggregationTable< A >
AggregatorAttribute
AlignData< A >A template class for aligning buffer data with a particular data type
AllowCommand
AllowOperatorsCommand
AllowOptionsCommand
AllowRangeCommand
AnXrlTarget
AnyAttribute
AreaRouter< A >Area Router
TestMain::Arg
ArgsBreak a string into a sequence of space separated words
ArgumentParserBase class for Argument Parsers
ArithTemplate
ARPdARP daemon
ArpHeaderARP packet
AS4AggregatorAttribute
AS4Path
AS4PathAttributeAS4PathAttribute contain an AS4Path, whose structure is documented in aspath.hh
AS4Segment
ASExternalDatabaseStorage for AS-external-LSAs with efficient access
ASExternalLsaAS-external-LSA
AsNumA class for storing an AS number used by protocols such as BGP
ASPathAn ASPath is a list of ASSegments, each of which can be an AS_SET, AS_CONFED_SET, AS_SEQUENCE, or an AS_CONFED_SEQUENCE
ASPathAttributeASPathAttribute contain an ASPath, whose structure is documented in aspath.hh
ASPrependFilter< A >BGPRouteFilter that prepends an AS to the AS path
ASSegmentParent class for ASPath elements, which can be either ASSet or ASSequence
AssertMetric
AsyncFileOperatorBase class for asynchronous file transfer operations
AsyncFileReaderRead asynchronously from a file
AsyncFileWriterWrite asynchronously to non-blocking file
AtomicAggAttribute
Att_Ptr_Cmp< A >Att_Ptr_Cmp is needed because we want BGPAttributeManager to use a set of pointers, but when we check to see if something's in the set, we want to compare the data and not the pointers themselves
AttributeManager< A >AttributeManager manages the storage of PathAttributeLists, so that we don't store the same attribute list more than once
AuthThis is the class that should be instantiated to access authentication
AuthHandlerBaseBase clase for OSPFv2 authentication mechanisms
XrlArgs::BadArgs
XrlAtomList::BadAtomType
BadExternalRoute
BadFaceThe exception thrown when an operation on an OLSR interface fails
BadFinderMessageFormatException for badly formatted message data
BadLinkCodeThe exception thrown when an operation on a link code fails
BadLinkCoverageThe exception thrown when no suitable link to a one-hop neighbor exists
BadLogicalLinkThe exception thrown when an operation on a logical link fails
BadMidEntryThe exception thrown when an operation on a MID entry fails
XrlAtom::BadName
BadNeighborThe exception thrown when an operation on a one-hop neighbor fails
BadPacketExceptionException thrown when parsing malformed packets
BadPeerBad Peer exception
BadTopologyEntryThe exception thrown when an operation on a topology control entry fails
BadTwoHopCoverageThe exception thrown when no suitable link to a two-hop neighbor exists
BadTwoHopLinkThe exception thrown when an operation on a link in the two-hop neighborhood fails
BadTwoHopNodeThe exception thrown when an operation on a two-hop neighbor fails
BaseAndDerived< B, D >Class to determine if two types are base and derived
BaseCommand
BGP4ByteASCapability
BGPCapParameter
BGPMain
BGPMultiProtocolCapability
BGPMultiRouteCapability
BGPPacketThe main container for BGP messages (packets) which are sent back and forth
BGPParameter
BGPPeer
BGPPeerDataData that applies to a specific peering
BGPPeerList
BGPPlumbing
BGPPlumbingAF< A >
BGPRefreshCapability
BGPRouteFilter< A >Base class for a single filter within FilterTable's filter bank
BGPRouteTable< A >Base class for a stage in BGP's internal plumbing
BGPTestPacket
BGPTimerConst
BgpTrie< A >The BgpTrie is an augmented, specialized trie that allows us to lookup by network address or by path attribute list
BGPUnknownCapability
BGPUpdateAttribEncoding used in BGP update packets to encode prefixes (IPv4 only) for withdrawn routes and NLRI information
BGPUpdateAttribList
BGPVarRW< A >Allows reading an modifying a BGP route
BGPVarRWCallbacks< A >
BGPVarRWExport< A >Returns the output peering for the neighbor variable
BinOperBase class for binary operations
BlockedPortIO< A >
BoolTemplate
Brief
FirewallManager::BrowseState
BsrGroupPrefix
BsrRp
BsrZone
BufferA class for storing buffered data
buffer_
BufferedAsyncReader
AsyncFileReader::BufferInfo
AsyncFileWriter::BufferInfo
BugCatcher
BuildInfo
BuildLsa
CacheMem
CacheRoute< A >Used in CacheTable to store a SubnetRoute and the genid of the RibIn that generated the route
CacheTable< A >Specialized BGPRouteTable that stores routes modified by a FilterTable
CallbackSafeObjectBase class for objects that are callback safe
Peer< A >::CandidatePossible DR or BDR candidates
CandMprOrderPredOrders a sequence of Neighbor* in descending order of MPR candidacy
CfHomeArgs
ChainedSubnetRoute< A >
ClearDatabase
CliClientThe class for the CLI client
CliCommandThe class for the CLI command
CliCommandMatch
CliNodeThe class for the CLI node
CliPipeThe class for the "pipe" ("|") command
ClockBase
ClusterListAttribute
CodeThis class represents the intermediate language code
CodeGeneratorGeneric code generator
CodeGenerator::CodeGeneratorErrException thrown if code generation fails
CodeListA collection of code fragments
CommandThe command and its associated process ID
CommandTree
CommandTreeNode
CommitStatusA class for storing information regarding the current phase of commit operations
CommitTransaction< A >
IoLinkManager::CommTableKey
CommunityAttribute
ASExternalDatabase::compare
CompleteFile
ComponentRoute< A >
PolicyFilter::ConfErrorException thrown on configuration error
Configuration::ConfErrorException thrown on configuration error
BufferedAsyncReader::Config
ConfigNodeIdClass for encoding and decoding configuration-related node IDs
ConfigNodeIdMap< V >Class for storing the mapping between a ConfigNodeId node and the corresponding value
ConfigParam< T >A class for storing a configuration parameter
ConfigTree
ConfigTreeNode
ConfigurationClass that contains all configuration and generated code state
ConfigureAllInterfacesFromSystemClass for configuring all interfaces within the FEA by using information from the underlying system
ConfigureInterfaceFromSystemClass for configuring an interface within the FEA by using information from the underlying system
ConfigVar< A >The value of a configuration variable and its state enable/disabled
ConfPathSegment
ConnectCB
Coord
CorruptA corruption entry
CorruptMessageThis exception is thrown when a bad input message is received
CplFileArgs
CplFileConf
CplMatch
CplMatches
CrashDumper
CrashDumpManager
cref_counter_poolClass for maintaining the storage of counters used by cref_ptr
cref_ptr< _Tp >Compact Reference Counted Pointer Class
CTN_Compare
DampBGP Route Flap Damping RFC 2439
Damping
DampingTable< A >Manage the damping of routes
DampPeerOscillationsManage the damping of peer oscillations
DampRoute< A >An entry of this form exists only if the route has been damped
DataBaseHandleDataBase Handle
DataDescriptionPacketDatabase Description Packet
DatumBase class for data types available to Parser
DatumIPv4Binding
DatumIPv4NetBinding
DatumStringBinding
DatumUint32Binding
DatumVariableBindingDatum to variable binding
DebugIO< A >The DebugIO class realizes the interface IO
DebugMsgLogTable< A >Route Table that passes that passes through updates whilst writing them to the logging them via XORP's XLOG_TRACE
DebugPeerHandler
DebugIO< A >::DebugRouteEntry
DebugTable< A >
DecisionTable< A >BGPRouteTable which receives routes from all peers and decided which routes win
DefaultPeer< A >
DelayQueue< _Entry >Entries can be added to the queue at any rate
DelayValidation
DeleteAllNodes< A >Delete nodes in the cache table trie
DeleteEGPTableCommand
DeleteIGPTableCommand
DeleteRoute< A >
DeleteTransactionRoute< A >
DeletionTable< A >DeletionTable is a temporary BGPRouteTable used to delete routes when a peer goes down
DemoRes
Dependency< T >A class which relates objects and handles dependencies between them
Dependency< T >::DependencyErrorException thrown if an illegal action is requested
Detail
DirCache
DirectAddEGPTableCommand
DirectAddIGPTableCommand
DirectDeleteEGPTableCommand
DirectDeleteIGPTableCommand
DirectDiscardVifCommand
DirectEtherVifCommand
DirectLoopbackVifCommand
DirectManagementVifCommand
DirectRouteAddCommand
DirectRouteDeleteCommand
DirectRouteVerifyCommand
DirectRouteVifAddCommand
DirectTableOriginCommand
DirectUnreachableVifCommand
DirNode
DirReader
DiscardNextHopA nexthop that is the discard interface
DiscardVifCommand
DispatcherLink between elements and operations
DummyBaseCommand
DummyDecisionTable< A >
DummyFinder
DummyFinderTcp
DummyNextHopResolver< A >
DummyNextHopResolver2< A >
DummyNhLookupTable< A >
DummyPeer
DummyPeerHandler
DummyRegisterServer
DummyResolver< A >
DumpIterator< A >
DumpTable< A >
DupeTupleA member of the duplicate set
Edge< A >
EightBitTimeHelper class to encode a TimeVal as an 8 bit binary floating point value
ElemAny< T >Generic Element wrapper for existing classes
ElemBoolBoolean element
ElemCom3232bit unsigned integer with BGP communities friendly syntax
ElementBasic object type used by policy engine
ElementFactoryA factory for creating elements based on their type
ElemFilterFilter element
ElemAny< T >::ElemInitErrorException thrown if c-stype string initialization fails
ElemRefAny< T >::ElemInitErrorException thrown if c-stype string initialization fails
ElemInt3232bit signed integer
ElemNet< A >
ElemNextHop< A >
ElemNullAn element representing nothing
ElemRefAny< T >
ElemSet
ElemSetAny< T >A set of elements
ElemStrString element
ElemU3232bit unsigned integer
EmulateSubnet< A >Bind together a set of IO classes in order to form a virtual subnet for testing, one instance per subnet
EmulateSubnetHopsBind together a set of IO classes like EmulateSubnet, however, in this case, any OLSR protocol messages which flow through this entity have their hopcount and TTL decremented by a given integer
FileVarRW::Error
ether_addr
EtherVifCommand
EtxHelloMessageSpecialization of a HELLO message with ETX measurements
EtxTcMessageSpecialization of a TC message with ETX measurements
EventLoopEvent Loop
RunCommandBase::ExecIdClass for setting the execution ID when running the command
ExpandFile
Peer< A >::expect
ExpectedRouteChange< A >
ExpectTable< A >A Route Table for comparing route updates received against expected
ExportCodeGeneratorGenerates export filter code from a node structure
External< A >Handle AS-external-LSAs
ExternalInfo
ExternalRouteClass representing an external route entry, either learned or originated in the OLSRv1 HNA sub-protocol
ExternalRouteOrderPredOrders a sequence of OlsrTypes::ExternalID in descending order of preference for route selection
ExternalRoutesClass which manages distribution of external routes throughout the OLSR domain
ExtIntTable< A >Make two route RouteTables behave like one, while resolving nexthops that are not immediate neighbors
FaceAn OLSR interface
FaceCountersPer-interface protocol statistics
FaceManagerClass which manages all interface bindings in the OLSR routing process
FanoutTable< A >
FastPathAttributeList< A >
FeaDataPlaneManagerFEA data plane manager base class
FeaDataPlaneManagerDummyFEA data plane manager class for Dummy FEA
FeaDataPlaneManagerLinuxFEA data plane manager class for Linux
FeaDataPlaneManagerWindowsFEA data plane manager class for Windows
FeaIoFEA (Forwarding Engine Abstraction) I/O class
FeaNodeThe FEA (Forwarding Engine Abstraction) node class
FetchDBFetch all the LSAs for one area
Fib2mribNodeThe Fib2mrib node class
Fib2mribRouteA Fib2mrib helper class
Fib2mribVarRWAllows variables to be written and read from fib2mrib routes
FibAddEntry4Class to store request to add forwarding entry to FibConfig and dispatch it later
FibAddEntry6Class to store request to add forwarding entry to FibConfig and dispatch it later
XrlFibClientManager::FibClient< F >A template class for storing FIB client information
FibConfigForwarding Table Interface
FibConfigEntryGet
FibConfigEntryGetDummy
FibConfigEntryGetIPHelper
FibConfigEntryGetRtmV2
FibConfigEntryObserver
FibConfigEntryObserverDummy
FibConfigEntryObserverIPHelper
FibConfigEntryObserverRtmV2
FibConfigEntrySet
FibConfigEntrySetDummy
FibConfigEntrySetIPHelper
FibConfigEntrySetRtmV2
FibConfigForwarding
FibConfigForwardingDummy
FibConfigForwardingProcLinux
FibConfigForwardingSolaris
FibConfigForwardingSysctl
FibConfigForwardingWindows
FibConfigTableGet
FibConfigTableGetDummy
FibConfigTableGetIPHelper
FibConfigTableGetSysctl
FibConfigTableObserver
FibConfigTableObserverDummy
FibConfigTableObserverIPHelper
FibConfigTableObserverRtmV2
FibConfigTableSet
FibConfigTableSetDummy
FibConfigTableSetIPHelper
FibConfigTableSetRtmV2
FibConfigTransactionManagerClass to store and execute FibConfig transactions
FibConfigTransactionOperationBase class for operations that can occur during an FibConfig transaction
FibDeleteAllEntries4Class to store request to delete all forwarding entries to FibConfig and dispatch it later
FibDeleteAllEntries6Class to store request to delete all forwarding entries to FibConfig and dispatch it later
FibDeleteEntry4Class to store request to delete forwarding entry to FibConfig and dispatch it later
FibDeleteEntry6Class to store request to delete forwarding entry to FibConfig and dispatch it later
FibConfigTableGetSysctl::FibMsgFlag values used to tell underlying FIB message parsing routines which messages the caller is interested in
FibTableObserverBaseA base class that can be used by clients interested in observing changes in the Forwarding Information Base
FileExpansion
XrlParserFileInput::FileState
FileVarRW
FilterBaseBase class for all policy filters
FilterLSAFilter LSAs
FilterManagerDeals with sending code to policy filters
FilterManagerBaseBase class for a FilterManager
FilterManagerFake
FilterNeighbourFilter the neighbours
FilterTable< A >Specialized BGPRouteTable implementing a filter bank to modify or drop routes
FilterVersion< A >Specific version of a static route filter
Finder
FinderClass
FinderClientClass that represents clients of the Finder
FinderClientEnableXrls
FinderClientObserverBase class for parties interested in receiving FinderClient event notifications
FinderClientOneOffOpBase class for operations FinderClient only need execute once, eg resolutions
FinderClientOpBase class for operations to be executed by FinderClient
FinderClientQueryClass that handles resolutions for FinderClient, and puts results into FinderClient's resolved table and notifies the client
FinderClientRegisterTargetClass to register client with Finder
FinderClientRegisterXrlClass to register an Xrl with the Finder
FinderClientRepeatOpBase class for operations FinderClient may have to repeat, eg register target, register xrl, etc
FinderClientXrlCommandInterfaceInterface class for FinderClient Xrl requests
FinderClientXrlTarget
FinderConstants
FinderDBEntryA one-to-many container used by the FinderClient to store unresolved-to-resolved Xrl mappings
FinderEvent
FinderEventObserverTest class that registers for event notifications with the finder
FinderEventObserverPackageClass containing components for Finder event observation
FinderEventObserverXrlTargetXrl Handler interface for FinderEventObserver
FinderForwardedXrlClass that handles the forwarding of Xrl's targetted at the finder
FinderMessageBaseBase class for FinderMessage classes
FinderMessengerBaseBase class for FinderMessenger classes
FinderMessengerManagerBase class for classes managing descendents of FinderMessengerBase
FinderSendHelloToClientSend "hello" Xrl to Client
FinderSendRemoveXrlSend "remove xrl" to client
FinderSendRemoveXrlsSend "remove xrls for target" to client
FinderSendTunneledXrlSend tunneled Xrl to client
FinderServerA wrapper class for the components within a Finder
FinderTarget
FinderTcpAutoConnectorClass to establish and manage a single connection to a FinderTcpListener
FinderTcpBase
FinderTcpConnector
FinderTcpListenerClass that creates FinderMessengers for incoming connections
FinderTcpListenerBase
FinderTcpMessenger
FinderXrlCommandBaseBase class for Xrls sent from Finder
FinderXrlCommandQueueXrl Queue for Finder
FinderXrlMessageFinder Message class for Xrl transport
FinderXrlResponseFinder Message class for Xrl Response transport
FinderXrlTarget
FinishingRouteDump< A >
Fire< A >
FirewallAddEntry4
FirewallAddEntry6
FirewallDeleteAllEntries4
FirewallDeleteAllEntries6
FirewallDeleteEntry4
FirewallDeleteEntry6
FirewallEntryFirewall Table Entry
FirewallGet
FirewallGetDummy
FirewallGetIpfw2
FirewallGetNetfilter
FirewallGetPf
FirewallManagerFirewall configuration manager
FirewallReplaceEntry4
FirewallReplaceEntry6
FirewallSet
FirewallSetDummy
FirewallSetIpfw2
FirewallSetNetfilter
FirewallSetPf
FirewallTransactionManagerA class to store and execute firewall transactions
FirewallTransactionOperationBase class for operations that can occur during a firewall transaction
FlagSetDestructorA simple class that sets a boolean flag to true when destructed
FilterManager::FMExceptionException thrown on error
Foo
EmulateSubnet< A >::Frame
FreeList
FreeListBlock
Fte< A, N >Forwarding Table Entry
FteX
GenericModule
GenericModuleManager
GetAddressStats< A >Invoke Xrl to get address stats on RIP address and pretty print result
GetAddressStatus< A >Invoke Xrl to get address state on RIP address and pretty print result
GetAllAddressStats< A >Invoke Xrl to get all addresses, which we then use to get the counters for to pretty print result
GetAllPeerStats4Invoke Xrl to get all peers, which we then use to get the counters for to pretty print result
GetAllPeerStats6Invoke Xrl to get all peers, which we then use to get the counters for to pretty print result
GetAreaListGet the list of configured areas
GetExternals
GetInterfaces
GetLine
GetLinks
GetListAtom< A >
GetMids
GetNeighbors
GetNeighbourListGet the list of neighbours
GetNeighboursGet the Neighbour info for all the requested neighbours
GetPeerStats4Invoke Xrl to get peer stats on RIP address and pretty print result
GetPeerStats6Invoke Xrl to get peer stats on RIP address and pretty print result
GetPortPeerStats4Invoke Xrl to get peers on if/vif/addr, which we then use to get the counters for to pretty print result
GetPortPeerStats6Invoke Xrl to get peers on if/vif/addr, which we then use to get the counters for to pretty print result
Getter
GetTopology
GetTwohopLinks
GetTwohopNeighbors
GlDefSignal
GlHistory
GlHistoryLine
GlHistoryRange
GlHistorySize
GlHistoryState
GlLineList
GlLineNode
glob_tResult structure for glob()
GlSignalNode
GlTerminalSize
XrlBgpTargetBase::handler_table
XrlCliTargetBase::handler_table
XrlCoordTargetBase::handler_table
XrlFeaTargetBase::handler_table
XrlFeaIfmgrMirrorTargetBase::handler_table
XrlFib2mribTargetBase::handler_table
XrlFinderTargetBase::handler_table
XrlFinderclientTargetBase::handler_table
XrlMfeaTargetBase::handler_table
XrlMld6igmpTargetBase::handler_table
XrlOlsr4TargetBase::handler_table
XrlOspfv2TargetBase::handler_table
XrlOspfv3TargetBase::handler_table
XrlPimTargetBase::handler_table
XrlPolicyTargetBase::handler_table
XrlProfilerTargetBase::handler_table
XrlRibTargetBase::handler_table
XrlRibclientTargetBase::handler_table
XrlRipTargetBase::handler_table
XrlRipngTargetBase::handler_table
XrlRtrmgrTargetBase::handler_table
XrlShowDistancesTargetBase::handler_table
XrlShowRoutesTargetBase::handler_table
XrlStaticRoutesTargetBase::handler_table
XrlTestTargetBase::handler_table
XrlTestFeaIfmgrMirrorTargetBase::handler_table
XrlTestFeaRawlinkTargetBase::handler_table
XrlTestFinderEventsTargetBase::handler_table
XrlTestPeerTargetBase::handler_table
XrlTestSocket4TargetBase::handler_table
XrlTestSocket6TargetBase::handler_table
XrlTestXrlsTargetBase::handler_table
XrlVrrpTargetBase::handler_table
XrlXorpshTargetBase::handler_table
HashBucket
HashMemory
HashNode
HashTable
Heap
Heap::heap_entry
HeapBaseObjects stored on the heap should inherit from this class
HelloMessageRepresentation of a HELLO protocol message
HelloPacketHello packet
HMAC
HMACMD5
HnaMessageRepresentation of an HNA message, containing external routes
HomeDir
HorizonValidatorBase< A >
IBGPLoopFilter< A >BGPRouteFilter that drops routes that came to us from an IBGP peer
IEMap
IfConfigBase class for pushing and pulling interface configurations down to the particular system
IfConfigErrorReporterClass for propagating error information during IfConfig operations
IfConfigErrorReporterBaseBase class for propagating error information on from IfConfig
IfConfigGet
IfConfigGetDummy
IfConfigGetGetifaddrs
IfConfigGetIPHelper
IfConfigGetSysctl
IfConfigObserver
IfConfigObserverDummy
IfConfigObserverIPHelper
IfConfigProperty
IfConfigPropertyDummy
IfConfigPropertyWindows
IfConfigSet
IfConfigSetDummy
IfConfigSetIPHelper
IfConfigTransactionManager
IfConfigTransactionOperationBase class for Interface related operations acting on an IfTree
IfConfigUpdateReplicatorA class to replicate update notifications to multiple reporters
IfConfigUpdateReporterBaseBase class for propagating update information on from IfConfig
IfConfigVlanGet
IfConfigVlanGetLinux
IfConfigVlanSet
IfConfigVlanSetLinux
IfMgrCommandBaseBase class for Interface Manager Commands
IfMgrCommandDispatcherClass to dispatch Interface Manager Commands
IfMgrCommandFifoQueueFIFO Queue for command objects
IfMgrCommandIfClusteringQueueInterface Command Clustering Queue
IfMgrCommandQueueBaseBase class for Command Queue classes
IfMgrCommandSinkBaseBase class for command sinks
IfMgrCommandTee2-way IfMgr Command Tee
IfMgrHintCommandBaseBase class for configuration events
IfMgrHintObserverBase for classes that are interested in configuration event hint commands
IfMgrHintTreeCompleteHint that configuration tree has been sent in it's entirety
IfMgrHintUpdatesMadeHint that configuration tree has changed and tree should be examined
IfMgrIfAddCommand to add an interface
IfMgrIfAtomInterface configuration atom
IfMgrIfAtomToCommandsClass to convert an IfMgrIfAtom object into a sequence of commands
IfMgrIfCommandBaseBase class for interface state manipulator commands
IfMgrIfRemoveCommand to remove an interface
IfMgrIfSetBaudrateCommand to set the baudrate of interface
IfMgrIfSetDiscardCommand to set discard condition on interface
IfMgrIfSetEnabledCommand to set enabled condition on interface
IfMgrIfSetMacCommand to set MAC address of interface
IfMgrIfSetManagementCommand to set management condition on interface
IfMgrIfSetMtuCommand to set MTU of interface
IfMgrIfSetNoCarrierCommand to set the no_carrier flag of interface
IfMgrIfSetPifIndexCommand to set physical interface index
IfMgrIfSetStringCommand to set virtual-interface info
IfMgrIfSetUnreachableCommand to set unreachable condition on interface
IfMgrIfTreeInterface configuration tree container
IfMgrIfTreeToCommandsClass to convert an IfMgrIfTree object into a sequence of commands
IfMgrIP< A >Class specialized to provide a way to find IfMgrIPv{4,6}Atom given IPv{4,6} type
IfMgrIP< IPv4 >
IfMgrIP< IPv6 >
IfMgrIPv4AddCommand to add an address to a virtual interface
IfMgrIPv4AtomIPv4 configuration atom
IfMgrIPv4AtomToCommandsClass to convert an IfMgrIPv4Atom object into a sequence of commands
IfMgrIPv4CommandBaseBase class for interface IPv4 address data manipulation
IfMgrIPv4RemoveCommand to remove an address to a virtual interface
IfMgrIPv4SetBroadcastCommand to set broadcast address associated with a virtual interface address
IfMgrIPv4SetEnabledCommand to set enabled flag of a virtual interface interface address
IfMgrIPv4SetEndpointCommand to set endpoint address associated with a virtual interface address
IfMgrIPv4SetLoopbackCommand to mark virtual interface address as a loopback address
IfMgrIPv4SetMulticastCapableCommand to mark virtual interface address as multicast capable
IfMgrIPv4SetPrefixCommand to set prefix of a virtual interface interface address
IfMgrIPv6AtomIPv6 configuration atom
IfMgrManagedXrlReplicatorAn IfMgrXrlReplicator managed by an IfMgrXrlReplicationManager
IfMgrNWayCommandTee< SinkType >N-way IfMgr Command Tee
IfMgrVifAddCommand to add a virtual interface to an interface
IfMgrVifAtomVirtual Interface configuration atom
IfMgrVifAtomToCommandsClass to convert an IfMgrVifAtom object into a sequence of commands
IfMgrVifCommandBaseBase class for virtual interface state manipulation commands
IfMgrVifRemoveCommand to remove a virtual interface to an interface
IfMgrVifSetBroadcastCapableCommand to mark virtual interface as broadcast capable
IfMgrVifSetEnabledCommand to set enabled condition on a virtual interface
IfMgrVifSetLoopbackCapableCommand to mark virtual interface as loopback capable
IfMgrVifSetMulticastCapableCommand to mark virtual interface as multicast capable
IfMgrVifSetP2PCapableCommand to mark virtual interface as point-to-point capable
IfMgrVifSetPifIndexCommand to associate a physical interface id with a virtual interface
IfMgrVifSetPimRegisterCommand to mark virtual interface as PIM Register vif
IfMgrVifSetVifIndexCommand to associate a virtual interface id with a virtual interface
IfMgrVifSetVlanIdCommand to set the VLAN ID to a virtual interface
IfMgrXrlMirrorMaintainer of a local mirror of central IfMgr configuration state via Xrls sent by the IfMgr
IfMgrXrlMirrorRouter
IfMgrXrlMirrorRouterObserverBase for classes that watch for Finder events from an IfMgrXrlMirrorRouter
IfMgrXrlMirrorTarget
IfMgrXrlReplicationManagerClass that builds and maintains replicator state for multiple remote targets
IfMgrXrlReplicatorClass that sends a configuration information to a remote mirror of IfMgr configuration state
IfTreeContainer class for FEA Interface objects in a system
IfTreeAddr4Class for holding an IPv4 interface address and address related items
IfTreeAddr6Class for holding an IPv6 interface address and address related items
IfTreeInterfaceFEA class for holding physical interface state
IfTreeItemBase class for FEA configurable items where the modifications need to be held over and propagated later, ie changes happen during a transaction but are propagated during the commit
IfTreeListenerIfTree will make these callbacks to listeners when certain actions occur
IfTreeVifFEA class for virtual (logical) interface state
InitError
IoIpComm::InputFilterFilter class
IoLinkComm::InputFilterFilter class
FinderClient::InstanceInfo
InstanceWatcherInstance watcher base class
InstructionBase class for an instruction
InstrVisitorVisitor pattern to traverse a structure of instructions
IO< A >::interface_vif
InterfaceInfo
InterfaceModifierBase class for interface modifier operations
InterfaceMonitor
InterfaceNameOfQueuedCmdMatches
InterfaceStatsInfo
InternalMessage< A >InternalMessage is used to pass route changes between BGP route table classes
InternalRouteEntry< A >Internal routing entry, potentially one per area
IntraAreaPrefixLsaOSPFv3 only: Intra-Area-Prefix-LSA
IntTemplate
InvalidAddressA standard XORP exception that is thrown if an address is invalid
InvalidBufferOffsetA standard XORP exception that is thrown if a buffer ofset is invalid
InvalidCastA standard XORP exception that is thrown if a cast is invalid
InvalidFamilyA standard XORP exception that is thrown if an address family is invalid
XrlAtomList::InvalidIndex
InvalidLinkTupleThe exception thrown when the decoding or encoding of a LinkTuple inside a HelloMessage fails
InvalidMessageThe exception thrown when the decoding or encoding of a Message fails
InvalidNetmaskLengthA standard XORP exception that is thrown if an IP netmask length is invalid
InvalidPacketA standard XORP exception that is thrown if the packet is invalid
InvalidPortA standard XORP exception that is thrown if a port is invalid
XUID::InvalidString
InvalidStringA standard XORP exception that is thrown if a string is invalid
IO< A >Abstract interface to low level IO operations
IoIpA base class for I/O IP raw communication
IoIpCommA class that handles raw IP I/O communication for a specific protocol
IoIpDummyA base class for Dummy I/O IP raw communication
IoIpManagerA class that manages raw IP I/O
IoIpManagerReceiverClass that implements the API for sending IP packet to a receiver
IoIpReceiverA base class for I/O IP raw packets receiver
IoIpSocketA base class for I/O IP raw socket communication
IoLinkA base class for I/O link raw communication
IoLinkCommA class that handles raw link I/O communication for a specific protocol
IoLinkDummyA base class for Dummy I/O link raw communication
IoLinkManagerA class that manages raw link-level I/O
IoLinkManagerReceiverClass that implements the API for sending raw link-level packet to a receiver
IoLinkPcapA base class for I/O link raw pcap(3)-based communication
IoLinkReceiverA base class for I/O Link raw packets receiver
IoTcpUdpA base class for I/O TCP/UDP communication
IoTcpUdpCommA class that handles I/O TCP/UDP communication
IoTcpUdpDummyA base class for I/O TCP/UDP Dummy communication
IoTcpUdpManagerA class that manages I/O TCP/UDP communications
IoTcpUdpManagerReceiverClass that implements the API for sending TCP/UDP packets and related events to a receiver
IoTcpUdpReceiverA base class for I/O TCP/UDP data receiver
IoTcpUdpSocketA base class for I/O TCP/UDP socket communication
IPEncapsNextHop< A >An IP nexthop that is an encapsulation tunnel
IPExternalNextHop< A >An IP nexthop that is not an intermediate neighbor
IpHeader4IPv4 packet header
IpHeader4WriterClass for writing data to IPv4 packet header
IpHeader6IPv6 packet header
IpHeader6WriterClass for writing data to IPv6 packet header
IPNet< A >A template class for subnets
IPNextHop< A >Template class for nexthop information
IPPeerNextHop< A >A nexthop that is an immediate neighbor
IPRouteEntry< A >Routing Table Entry
IptupleStore the Local Interface, IP, Local Server Port, Peer IP and Peer Server Port tuple
IPv4IPv4 address class
IPv4ArgumentParser
IPv4Constants
IPv4Datum
IPv4NetArgumentParser
IPv4NetDatum
IPv4NetTemplate
IPv4RangeTemplate
IPv4RouteEntry
IPv4Template
IPv6IPv6 address class
IPv6Constants
IPv6NetTemplate
IPv6PrefixRFC 2470 A.4.1 IPv6 Prefix Representation OSPFv3 only
IPv6RangeTemplate
IPv6RouteEntry
IPv6Template
IpVifInputFilter
IPvXBasic IPvX class (for both IPv4 and IPv6)
IPvXHeaderInfoStructure used to store commonly passed IPv4 and IPv6 header information
IPvXNetIPvXNet class
IPvXRange< T >A linear IPvX class template (IPvX low)..(IPvX high)
is_port_for< A >Functor to test whether a particular OLSR port is appropriate for packet arriving on socket
IsEGP< A >EGP Protocol Policy
IsIGP< A >IGP Protocol Policy
IsLinkSymmetricPredWrapper for LogicalLink::is_sym()
IsOfProtocol< A >Protocol Policy class
IsTwoHopLinkStrictPredWrapper for TwoHopNeighbor::is_strict()
IvExecVisitor that executes instructions
IoTcpUdpComm::JoinedMulticastGroupJoined multicast group class
IoIpComm::JoinedMulticastGroupJoined multicast group class
IoLinkComm::JoinedMulticastGroupJoined multicast group class
XrlPimNode::JoinLeaveMulticastGroupClass for handling the task of join/leave multicast group requests
XrlMld6igmpNode::JoinLeaveMulticastGroupClass for handling the task of join/leave multicast group requests
KeepAlivePacketKeepAlivePacket are extremely simple, being made only of a header
KeySym
KeyTab
KnownCommunityFilter< A >BGPRouteFilter that processes well-known communities
KtKeyBinding
Lemming
LibFeaClientBridgeBridge class to intervene between the FEA's interface manager and libfeaclient
LinkAddrInfoWrapper for per-address information found in HELLO and TC
LinkCodeHelper class which represents the link code used in a link tuple
LinkInfo
LinkLsaOSPFv3 only: Link-LSA
LinkOrderPredOrders a sequence of OlsrTypes::LogicalLinkID in descending order of link preference
Links
LinkSortOrderPred
LinkStateAcknowledgementPacketLink State Acknowledgement Packet
LinkStateRequestPacketLink State Request Packet
LinkStateUpdatePacketLink State Update Packet
Links::LinkTupleA structure describing an emulated link between two nodes
LinkVifInputFilter
LoadInstruction to read a variable via VarRW interface
LocalDataData that applies to all BGP peerings
LocalPrefAttributeLocalPrefAttribute is a well-known uint32
LocalPrefInsertionFilter< A >BGPRouteFilter that inserts a LocalPref attribute
LocalPrefRemovalFilter< A >BGPRouteFilter that deletes a LocalPref attribute
LogicalLinkLogical link used to reach a directly reachable Neighbor
LogTable< A >A Base for Route Tables that log updates
LoopbackVifCommand
Ls_requestLink State Request as sent in a Link State Request Packet
LsaLink State Advertisement (LSA)
Lsa_headerLSA Header
LsaDecoderLSA byte streams are decoded through this class
LsaTempStoreRouter-LSA and Intra-Area-Prefix-LSA store
ltstr< A >
PriorityQueue< A >::lweight< B >
MacIEEE standard 48-bit address
MacaddrTemplate
MacConstants
MacHeaderInfoStructure used to store commonly passed MAC header information
ManagementVifCommand
MasterConfigTree
MasterConfigTreeNode
MasterTemplateTree
MasterTemplateTreeNode
MD5AuthHandlerOSPFv2 Authentication handler for MD5 scheme
MD5AuthHandler::MD5KeyClass to hold MD5 key information
MD5PacketRouteEntry4Route Entry for MD5 data
MD5PacketRouteEntry4WriterClass for writing data to MD5 authentication entry
MD5PacketTrailerContainer for MD5 trailer
MD5PacketTrailerWriterClass for writing data to MD5 authentication trailer
MEDAttributeMEDAttribute is an optional non-transitive uint32
MEDInsertionFilter< A >BGPRouteFilter that inserts a MED attribute
MEDRemovalFilter< A >BGPRouteFilter that removes a MED attribute
MergedTable< A >Make two route RouteTables behave like one
MessageAn OLSR protocol message
MessageDecoderDecoder for OLSR protocol messages
MessageQueueEntry< A >
MfeaDfeMulticast dataflow entry class
MfeaDfeLookupA class for storing all dataflow entries per (S,G)
MfeaDftThe MFEA (S,G) dataflow table for monitoring forwarded bandwidth
MfeaMrouterA class for multicast routing related I/O communication
MfeaNodeThe MFEA node class
MfeaNodeCliThe class for MfeaNode CLI access
MfeaVifA class for MFEA-specific virtual interface
MidEntryA multiple interface record (MID)
MidInfo
MidMessageRepresentation of a MID protocol message
MiniTraits< T >Class to determine subset of type traits
Mld6igmpGroupRecordA class to store information about multicast group membership
Mld6igmpGroupSetA class to store information about a set of multicast groups
Mld6igmpNodeThe MLD/IGMP node class
Mld6igmpNodeCliThe class for Mld6igmpNode CLI access
Mld6igmpSourceRecordA class to store information about a source (within a given multicast group)
Mld6igmpSourceSetA class to store information about a set of sources
Mld6igmpVifA class for MLD/IGMP-specific virtual interface
ModuleA class for managing router manager modules
ModuleCommand
ModuleDataHolds information about an XRL module that requested to be notified about a change
ModuleManager
MPReachNLRIAttribute< A >
MPUNReachNLRIAttribute< A >
Mre< E >Template class for the Multicast Routing Entry
MreGsKeyClass for (S,G) lookup key (Group-first, Source-second priority)
MreSgKeyClass for (S,G) lookup key (Source-first, Group-second priority)
MribThe Multicast Routing Information Base payload entry
MribLookupThe basic entry in the MribTable lookup tree
MribTableBase class for the Multicast Routing Information Base Table
MribTableIteratorThe Multicast Routing Information Base Table iterator
Mrt< E >Template class for Multicast Routing Table
mrt_header
mrt_update
EmulateSubnet< A >::Multiplex
MyMreMulticast Routing Entry test class
mySelectorListObserver
myTimerListObserver
NaryInstrAn N-ary operation
NeighborA one-hop neighbor
NeighborhoodRepresentation of OLSR node's one-hop and two-hop neighborhood
NeighborInfo
NeighborSortOrderPred
Neighbour< A >Neighbour specific information
NeighbourInfoNeighbour information that is returned by XRLs
NetCmp< A >A network comparitor class for the purposes of ordering networks in sorted containers
NetworkLsa
Next
NextHopGeneric class for next-hop information
NextHopAttribute< A >NextHopAttribute contains the IP address of the next hop
NextHopCache< A >A cache of next hop information
NextHopCache< A >::NextHopEntry
NexthopPeerCheckFilter< A >BGPRouteFilter rewrites the nexthop if it matches the peers address
NexthopPortMapperA class for to keep the mapping between next-hop information and a port number
NexthopPortMapperObserverA class for observing changes to a NetlinkPortMapper object
NextHopResolver< A >
NexthopRewriteFilter< A >BGPRouteFilter that changes the nexthop attribute in a route
NextHopRibRequest< A >Make requests of the RIB and get responses
NextTableMap< A >NextTableMap behaves more or less like a map between a BGPRouteTable* and a const PeerHandler*, but it gives deterministic ordering semantics so our test suites aren't dependent on the memory allocator
NextTableMapIterator< A >
NhLookupTable< A >
NHRequest< A >
Nmap< A >
XrlAtom::NoData
SelectorList::Node
Node< A >The base class of a node for building a hierarchy
NodeAcceptNode representing an accept statement
NodeAny< T >A generic node wrapper
NodeAssignAn assignment operation
NodeBinA node for a binary operation
NodeElemA node which holds an element
NodeNext
NodeProtoNode representing a protocol statement
NodeRejectNode representing a reject statement
Nodes
NodeSetA node which holds a set
NodeSubr
NodeTuple
NodeUnUnary operation
NoFinder
NoHorizonValidator< A >
NONCOPYABLE
SourceMatchCodeGenerator::NoProtoSpecException thrown if no protocol was specified in source block
NoSuchAddress
NotificationPacket
NotifyQueueQueue of route event notifications
NotifyQueueChangedEntry< A >Notification Queue entry indicating that a change occured to the metric, admin_distance or nexthop of a route in which interest was registered
NotifyQueueEntryBase class for a queue entry to be held in a NotifyQueue
NotifyQueueInvalidateEntry< A >Notification Queue entry indicating that a change occured which has caused a route registration to become invalid
NullAuthHandlerOSPFv2 Authentication handler when no authentication scheme is employed
Dependency< T >::ObjPair
OlsrAn OLSR routing process
OlsrTypesA scope to hold primitive types specific to OLSR
OlsrVarRW
OneoffTaskNode2
OneoffTimerNode2
OnFalseExitInstruction that exits the current term if top of stack is false
OpCommand
OpCommandList
OpenPacket
OperBase class for operations
OpInstance
Dispatcher::OpNotFoundException thrown if no operation is found for given arguments
OptionsHelper class to manipulate the options field in packets and LSAs
OriginateRouteFilter< A >Perform any filter operations that are required for routes that we originate
OriginatorIDAttributeOriginatorIDAttribute is an optional non-transitive uint32
OriginAttributeOriginAttribute has a payload of size 1 containing the origin type
OriginTable< A >RouteTable that receives and stores raw routes sent by routing protocols
Ospf< A >
OspfTypesOSPF Types
OspfVarRW< A >
OstreamLogTable< A >Route Table that passes through updates whilst logging them to an ostream instance
OtherPeer< A >
OutputThe base class that needs to be implemented by all print routines
OutputBase< A >Base class for RIP output processing components
Redistributor< A >::OutputEventInterface
OutputTable< A >Route Table Output class
OutputTester< A, OutputClass >
OutputUpdates< A >Triggered Updates Output class
Pa< A >
PacketAn OLSR packet containing Messages
PacketAssemblerSpecState< A >Internal specialized state for PacketAssembler classes
PacketAssemblerSpecState< IPv4 >IPv4 specialized PacketAssembler state
PacketAssemblerSpecState< IPv6 >IPv6 specialized PacketAssembler state
PacketDecoderPacket byte streams are decoded through this class
PacketQueue< A >Outbound packet queue
PacketRouteEntry< A >Route Entry as it appears in a RIP Packet
PacketRouteEntry< IPv4 >Route Entry appearing in RIP packets on IPv4
PacketRouteEntry< IPv6 >Route Entry appearing in RIP packets on IPv6
PacketRouteEntryWriter< A >
PacketRouteEntryWriter< IPv4 >
PacketRouteEntryWriter< IPv6 >
PAListRef< A >
Parse_error
ParsedFinderMessageBaseBase class for parsed Finder Messages
ParsedFinderXrlMessageParses finder protocol messages into Xrls
ParsedFinderXrlResponseParses finder protocol messages into Xrl responses
ParseError
ParserA lex/yacc wrapper which parses a configuration and returns nodes
Node< A >::path
Path_Att_Ptr_Cmp< A >
PathAttribute
PathAttributeList< A >PathAttributeList is used to handle efficiently path attribute lists
PathCache
PathName
PathNode
PathSegment
Pause< A >
PcaPathConf
Command::PCmd
Peer< A >A peer represents a single area and is bound to a PeerOut
peer_has_address< A >Unary Function Predicate class for use with STL to determine if a peer has an address
PeerCountersContainer of counters associated with a peer
PeerDumpState< A >
PeerHandlerPeerHandler's job is primarily format conversion
PeerManager< A >Peer Manager: 1) Monitor the state of the interfaces
PeerOut< A >In OSPF terms this class represents an interface/link; interface is too overloaded a term
PeerRoutes< A >RIP Peer Routes
AreaRouter< A >::PeerStateInternal state that is required about each peer
PeerTableInfo< A >
MribTable::PendingTransaction
PeriodicTimerNode2
pid_s
pim
PimBsr
PimJpGroup
PimJpHeader
PimJpSources
PimMfc
PimMre
PimMreAction
PimMreTask
PimMreTrackState
PimMribTablePIM-specific Multicast Routing Information Base Table
PimMrt
PimMrtG
PimMrtMfc
PimMrtRp
PimMrtSg
PimNbr
PimNodeThe PIM node class
PimNodeCli
PimRp
PimScopeZone
PimScopeZoneId
PimScopeZoneTable
pimstat
PimVifA class for PIM-specific virtual interface
Pinger
PlaintextAuthHandlerOSPFv2 Authentication handler for plaintext scheme
PlaintextPacketRouteEntry4Route Entry for Plaintext password
PlaintextPacketRouteEntry4WriterClass for writing data to Plaintext password authentication entry
PlumbingTest
PoisonReverseValidator< A >
PolicyConnectedTable< A >This table will filter connected routes
PolicyExceptionBase class for all policy exceptions
PolicyFilterA generic policy filter
PolicyFiltersA container for all policy filters a protocol should support
PolicyFilters::PolicyFiltersErr
PolicyInstrContainer for terms instructions
PolicyListThe list of policies associated with a protocol
PolicyMapContainer of all policies
PolicyMap::PolicyMapErrorException thrown on errors such as when a policy is not found
PolicyProfiler
PolicyRedistMapA Map between policytags and where the route should be redistributed
PolicyRedistTable< A >This table redistributes routes to protocols according to policytags
PolicyStatementA policy statement is a collection of terms
PolicyStatement::PolicyStatementErrException thrown on error such as when no term is found
PolicyTable< A >Generic Policy filter table suitable for export filters
PolicyTableExport< A >Export policy tables match neighbor in a different way
PolicyTableImport< A >Import policy tables also deal with propagating policy route dumps
PolicyTableSourceMatch< A >SourceMatch table has the aditional ability to perform route dumps
PolicyTagsA set of policy tags
PolicyTags::PolicyTagsErrorException thrown on failed initialization of tags
PolicyTargetThe XORP Policy target
policy_utils::PolicyUtilsErrGeneric exception for errors
cref_counter_pool::pool_item
Port< A >RIP Port
port_has_address< A >Unary function object to test whether a particular address is associated with a RIP port
port_has_interface_vifFunctor to test whether a particular interface/vif is associated with an XrlPort
port_has_io_in_state< A >Functor to test whether a particular XrlPort is in a given service state
port_has_local_addressFunctor to test whether a particular local address is associated with an XrlPort
PortAFSpecState< A >Specializable Address Family state for Port classes
PortAFSpecState< IPv4 >IPv4 specialized Port state
PortAFSpecState< IPv6 >IPv6 specialized Port state
PortCountersContainer of counters associated with a Port
PortIOBase< A >Base class for RIP Port I/O classes
PortIOUserBase< A >Base class for users of Port I/O classes
PortManagerBase< A >Base for RIP Port container and factory classes
PortTimerConstantsContainer of timer constants associated with a RIP port
Pr< A >Print the route command
PrintAddress< A >Class to print header
PrintPeers
PrintRoutes< A >
PriorityQueue< A >Tentative nodes in a priority queue
ModuleManager::Process
test_process::Process
ProcessWatch::Process
ProcessWatchKeeps track of which XORP processes of interest are alive
ProcessWatchBaseBase class for a process watcher
ProcessWatchFake
ProfileSupport for profiling XORP
profile_vars
ProfileLogEntry
Profile::ProfileState
ProgramAction
ProgramShutdown
ProgramStartup
ProgramStatusConfigMeValidation
ProgramStatusReadyValidation
ProgramStatusShutdownValidation
ProgramStatusStartupValidation
ProgramStatusValidation
ProtocolRouting protocol information
ProtocolMapMaps protocols to the XORP process name
ProtoNode< V >Base class for a protocol node
ProtoNodeCliBase class for Protocol node CLI access
SourceMatchCodeGenerator::ProtoRedefinedException thrown if protocol was re-defined in source block
ProtoStateBase class for keeping state for each protocol unit (node, vif, etc)
ProtoUnitBase class for each protocol unit (node, vif, etc)
PushPush operation
PushSetPush a set on the stack
PVariableExists
PVariableLocked
PVariableNotEnabled
PVariableNotLocked
PVariableUnknownContainer keyed by profile variable holding log entries
ProcessWatch::PWExceptionException thrown on error, such as Xrl failure
PWNotifierInterface which receives notification events from ProcessWatch
TestPeer::Queued
XrlQueue< A >::Queued
RandomGen
Range< T >A template class for implementing linear ranges X..Y
AreaRouter< A >::RangeRange to be summarised or suppressed from other areas
ReaderIxTuple< A >
UpdateQueueImpl< A >::ReaderPosState associated with an UpdateQueue reader
RealTrie< A >
RedistBinaryOp< A >Base class for Binary Redistribution Policy objects
RedistDisableCommand
RedistEnableCommand
Redistributor< A >::RedistEventInterface
RedistLogicalAnd< A >Logical-And for Redistribution Policy objects
RedistLogicalNot< A >Logical-Not for Redistribution Policy objects
RedistLogicalOr< A >Logical-And for Redistribution Policy objects
RedistNetCmp< A >Comparitor to allow nets to be stored in a sorted container
RedistOutput< A >Base class for propagaing output of route add and delete messages
RedistPolicy< A >Base class for Redistribution Policy objects
Redistributor< A >Controller class that takes routes from RedistTable and passes them on via RedistOutput
RedistRouteOrigin< A >Route Origination class for RouteRedistributor instances
RedistTable< A >RouteTable used to redistribute routes
RedistTransactionXrlOutput< A >Route Redistributor output that sends route add and deletes to remote redistribution target via the redist_transaction{4,6} xrl interfaces
RedistUnaryOp< A >Base class for Unary Redistribution Policy objects
RedistXrlOutput< A >Route Redistributor output that sends route add and deletes to remote redistribution target via the redist{4,6} xrl interfaces
RedistXrlTask< A >Base class for RedistXrlOutput Tasks
ref_counter_poolClass for maintaining the storage of counters used by ref_ptr
ref_ptr< _Tp >Reference Counted Pointer Class
RefTrie< A, Payload >The RefTrie itself
RefTrieNode< A, Payload >RefTrieNode definition
RefTriePostOrderIterator< A, Payload >Postorder Iterator on a trie
RefTriePreOrderIterator< A, Payload >
RegisterElementsDoes the initial registration of ElementFactory callbacks
RegisterOperationsDo initial registration of dispatcher callbacks
RegisterServerRegisterServer handles communication of notifications to the clients that registered interest in changes affecting specific routes
RegisterTable< A >RouteTable which stores routing protocols' registration of interest in changes to certain routes
XrlPimNode::RegisterUnregisterInterestClass for handling the task to register/unregister interest in the FEA or MFEA with the Finder
XrlMld6igmpNode::RegisterUnregisterInterestClass for handling the task to register/unregister interest in the FEA or MFEA with the Finder
XrlPimNode::RegisterUnregisterProtocolClass for handling the task to register/unregister with the MFEA as a protocol on an interface
XrlPimNode::RegisterUnregisterReceiverClass for handling the task to register/unregister with the FEA as a receiver on an interface
XrlMld6igmpNode::RegisterUnregisterReceiverClass for handling the task to register/unregister with the FEA as a receiver on an interface
RejectInstruction to reject a route
RemoveAddr4Class for removing an IPv4 address to a VIF
RemoveAddr6Class for removing an IPv6 address to a VIF
RemoveInterfaceClass for removing an interface
RemoveInterfaceVifClass for removing a VIF from an interface
RepeatedTaskNode2
RequestPacketTester
RequestStateSender state for tracking Xrl's forwarded by TCP
RequestTablePacketAssembler< A >Class to configure a RIP packet to be a table request
ResolvedIPRouteEntry< A >Extended RouteEntry, used by ExtIntTable
ResponsePacketAssembler< A >Class for RIP Response Packet Assemblers
ResponseReader< A >
FinderMessengerBase::ResponseState
RestoreInterfaceMacClass for restoring an interface MAC
RestoreInterfaceMtuClass for restoring an interface MTU
RIB< A >Master class for a RIB
RibClientTarget
RibDeregisterQueueEntry< A >
RibInTable< A >Specialized BGPRouteTable that stores routes from a BGP peer
RibIpcHandler
RibManagerMain top-level class containing RIBs and main eventloop
RibNotifierBase< A >Base class for RIB notificatiers
RibOutTable< A >
RibParser
RibRegisterQueueEntry< A >
RibRequestQueueEntry< A >The queue of outstanding requests to the RIB
RIBVarRW< A >Enables reading and writing variables to a RIB route
RibVif
RIP_AF_CONSTANTS< IPv4 >
RIP_AF_CONSTANTS< IPv6 >
RipPacket< A >RIP Packet class
RipPacketHeaderHeader appearing at the start of each RIP packet
RipPacketHeaderWriter
RipRoute< A >
RIPVarRW< A >Enables reading and writing variables of RIP routes
RMActionRouteMap action (not yet working)
RMMatchRouteMap conditional (not yet working)
RMMatchIPAddrRouteMap conditional (not yet working)
RMRuleRouteMap rule (not yet working)
RoundRobinObjBaseObjects stored in the RoundRobinQueue should inherit from this class
RoundRobinQueueThe Round-robin queue
Route< A >
RouteAddCommand
RouteCmd< A >The idealised command to execute
RouteData< A >Container for a route and the meta-data about the origin of a route used in the DecisionTable decision process
RouteDB< A >Class that manages routes
RouteDeleteCommand
RouteEntry< A >An OLSR internal route entry
RouteEntryOrigin< A >Base class for originators of RIP route entires
RouteEntryRef< A >RouteEntry reference class
RouteEntryOrigin< A >::RouteEntryStore< A >
RouteInjector< A >Unary function object to inject routes into a route database
RouteManagerRouting table manager
RouteMapRouteMap route filter (not yet working)
RouteMetaData
RouteQueueEntry< A >
RouteRange< A >Stores a Route and bounds on the validity of the route
RouterCLI
RouteRedistributor< A >Store for redistributed routes
RouteRegister< A >RouteRegister stores a registration of interest in a subset of a route
RouterInfoRouter ID and associated interface ID
RouterLinkDefines a link/interface, carried in a RouterLsa
RouterLsa
RouteTable< A >Base class for a routing table
RouteTableReader< A >
RouteVerifyCommand
RouteVifAddCommand
RouteWalker< A >Asynchronous RouteDB walker
RouteWalkTester< A >
Routing< A >
RoutingTable< A >
BGPMain::RoutingTableToken< A >Token generator to map between unicast and multicast
RpTable
RRIBGPLoopFilter< A >BGPRouteFilter that drops or reflects routes from an IBGP peer
RRInputFilter< A >BGPRouteFilter that drops routes with this routers ORIGINATOR_ID or CLUSTER_ID
RRPurgeFilter< A >RRPurge Remove ORIGINATOR_ID and CLUSTER_LIST attributes
FibConfigTableObserverRtmV2::RtmV2Observer
Rtrmgr
RunCommandA class for running an external command
RunCommandBaseBase virtual class for running an external command
RunShellCommandA class for running an external command by invoking a shell
IvExec::RuntimeErrorRun time errors, such as doing unsupported operations
RxmtWrapperSimple wrapper for retransmission timers that simplified debugging
SafeCallbackBaseBase class for safe callbacks
SafeWidget
Save
SchedulingTime
SelectorListA class to provide an interface to I/O multiplexing
SelectorListObserverBaseAbstract class used to receive SelectorList notifications
VisitorSemantic::sem_errorException thrown on a semantic error
VisitorDep::sem_errorSemantic error thrown if set is not found
SemanticVarRWA VarRW used for semantic checking
Send< A >
XrlMld6igmpNode::SendAddDeleteMembershipClass for handling the queue of sending Add/Delete membership requests
XrlPimNode::SendProtocolMessageClass for handling the task of sending protocol messages
XrlMld6igmpNode::SendProtocolMessageClass for handling the task of sending protocol messages
BGPMain::ServerStore the socket descriptor and iptuple together
Service2XrlTargetStatus< A >Class to receive state changes of services used by RIP and update status in the xrl interface accordingly
service_names_inUnary function class to build string containing ServiceBase objects in a particular state
ServiceBaseBase class for Services
ServiceChangeObserverBaseBase class for service status change observer
ServiceFilteredChangeObserverSelective Change Observer
SetAddr4BroadcastClass to set the broadcast address IPv4 address associated with a vif
SetAddr4EnabledClass to set enable state of an IPv4 address associated with a vif
SetAddr4EndpointClass to set the endpoint IPv4 address associated with a vif
SetAddr4PrefixClass to set the prefix of an IPv4 address associated with a vif
SetAddr6EnabledClass to set the enabled state of an IPv6 address associated with a vif
SetAddr6EndpointClass to set the endpoint IPv6 address associated with a vif
SetAddr6PrefixClass to set the prefix of an IPv6 address associated with a vif
SetIfStringClass for setting the VLAN state of a vif
SetInterfaceDiscardClass for setting the discard state of an interface
SetInterfaceEnabledClass for setting the enabled state of an interface
SetInterfaceMacClass for setting an interface MAC
SetInterfaceManagementClass for setting the management state of an interface
SetInterfaceMtuClass for setting an interface MTU
SetInterfaceUnreachableClass for setting the unreachable state of an interface
SetManagerClass that owns all sets
SetMapContainer of all sets
SetMap::SetMapErrorException thrown on error, such as deleting a set in use
SetManager::SetNotFoundException thrown when a set with an unknown name is requested
SetVifEnabledClass for setting the enabled state of a vif
SgCountClass that contains various counters per (S,G) entry
ShowDistancesOptions
ShowDistancesProcessor
ShowRoutesOptions
ShowRoutesProcessor
Shutdown
SimpleASFilter< A >BGPRouteFilter that drops routes that have a particular AS in their AS path
SimpleTransmit< A >A transmit object that sends fixed data
Simulator
SingleVarRWAn interface to VarRW which deals with memory management
SingleVarRW::SingleVarRWErrException thrown on error, such as reading unsupported variable
SlaveConfigTree
SlaveConfigTreeNode
SlaveModuleManager
Socket
SocketClient
SocketManager< A >
SocketServer
SourceGroupClass to store (S,G) (Source, Group) pair of addresses
SourceMatchCodeGeneratorCode generator for source match filters
SplitHorizonValidator< A >
SplitNets< A >Unary function object to split routes evenly into 2 sets
SpoofPort< A >
SpoofPortIO< A >
SpoofPortManager< A >
Spt< A >Shortest Path Tree
test_start::Start
StartingRouteDump< A >
StartTransaction< A >
Startup
StaticRouteA StaticRoute helper class
StaticRoutesNodeThe StaticRoutes node class
StaticRoutesVarRWAllows variables to be written and read from static routes
STCPPacketHeader
STCPRequestHandler
StoreInstruction to write a variable via VarRW interface
StringArgumentParser
StringDatum
StringGroup
StringMem
StringSegment
SubnetRoute< A >SubnetRoute holds a BGP routing table entry
SubnetRouteConstRef< A >Class to hold a const reference to a SubnetRoute
SubnetRouteRef< A >Class to hold a reference to a SubnetRoute
Subr
Summary
PeerManager< A >::SummarySaved summaries that can be introduced into a new area
SummaryNetworkLsaOSPFv2: Summary-LSA Type 3 OSPFv3: Inter-Area-Prefix-LSA
SummaryRouterLsaOSPFv2: Summary-LSA Type 4 OSPFv3: Inter-Area-Router-LSA
Symbol
System< A >Top Level container for XORP RIP implementation
SystemClockAn implementation of ClockBase that uses the underlying system's 'get current system time' function as it's clock source
SystemMulticastUpcallFilter
table_has_name< A >
table_has_name_and_type< A, T >
TableExtIntCommand
TableMergedCommand
TableOriginCommand
Code::TargetA target represents where the code should be placed
Task
TaskBaseItem
TaskList
TaskManager
TaskNode
TaskProgramItem
TaskXrlItem
TcMessageRepresentation of a TC protocol message
TemplateTree
TemplateTreeNode
TermA term is an atomic policy unit
Term::term_syntax_errorException thrown on a syntax error while parsing configuration
TermInstrContainer of instructions
TestFinderClientObserver
TestHeap
TestInfoThis class is passed as the first argument to each test function/method
TestMainA helper class for test programs
TestOutput< A >
TestPeer
TestRawLink
TestReceiver
TestRunCommandA class used for testing of
TestSender
TestService
TestServiceChangeObserver
TestSocket4TCP
TestSocket4TCPClient
TestSocket4TCPServer
TestSocket4UDP
TestTask
TestVarRW
TextTemplate
<the>PimVif::calculate_ipv6_pseudo_header_checksum: : the source address of the pseudo-header
TimerListXorpTimer creation and scheduling entity
TimerListObserverBaseAbstract class used to receive TimerList notifications
TimerNode
TimeSliceA class for computing whether some processing is taking too long
TimeSpent(Debugging) Used to find code that has taken too long to execute
TimeValTimeVal class
Tlv<Type,Length,Value> Read and Write TLV records
autotest::ToolAutoTestWarning
TopologyEntryA topology control record (TC)
TopologyInfo
TopologyManagerClass which manages topology outside of the one-hop and two-hop neighborhood in the OLSR domain
TraceTrace control variables
TraceAIO
TraceFinder
TraceFinderClient
TraceXrl
TransactionManager::TransactionTransaction class, just a list of operations to be dispatched
TransactionManagerA class for managing transactions
TransactionOperationBase class for operations within a Transaction
Transmit< A >The base class for all transmissions
RealTrie< A >::Tree
Trie< A, Payload, __Iterator >The trie stores BGP update packets the trie index is the NLRI
TrieDataA BGP update packet can have many NLRIs
TrieNode< A, Payload >TrieNode definition
TriePayloadThe payload of a RealTrie
TriePostOrderIterator< A, Payload >Postorder Iterator on a trie
TriePreOrderIterator< A, Payload >Preorder Iterator on a trie
TwoHopLinkA link between a Neighbor and a TwoHopNeighbor
TwohopLinkInfo
TwoHopLinkOrderPredOrders a sequence of OlsrTypes::TwoHopLinkID in descending order of link preference
TwoHopNeighborA two-hop neighbor
TwohopNeighborInfo
TxOnlyFilter
Type7LsaType-7 LSA used to convey external routing information in NSSAs
U32RangeA linear range class (uint32_t low)..(uint32_t high)
Uint32ArgumentParser
Uint32Datum
UIntRangeTemplate
UIntTemplate
MiniTraits< T >::UnConst< U >
MiniTraits< T >::UnConst< const U >
UnexpandedProgram
UnexpandedXrl
UnknownAttribute
ElementFactory::UnknownElementException thrown if an Unknown element is being created
UnknownFilter< A >BGPRouteFilter that processes unknown attributes
UnknownLsa
UnknownMessageWrapper class for an unknown OLSR message type
UnOperBase class for unary operations
UnreachableNextHopA nexthop that is the unreachable interface
UnreachableVifCommand
UnresolvableHost
UnresolvedIPRouteEntry< A >Extended Unresolved RouteEntry, used by ExtIntTable
UnusableMessageThis exception is thrown when an update message is received, and we find it unusable, but not so bad that we want to send a Notification and terminate the connection
UpdateBlock< A >Store for a fixed block of update
UpdatePacket
UpdateQueue< A >Update Queue for RIP Route entries
UpdateQueueImpl< A >Internal implementation of UpdateQueue class
UpdateQueueReader< A >Reader for UpdateQueue class
UpdateQueueTester< A >
UrlFileTemplate
UrlFtpTemplate
UrlHttpTemplate
UrlTftpTemplate
User
UserDB
UserInstance
Validation
Dispatcher::Value
SemanticVarRW::var_errorException thrown on illegal variable use
VarMap::VariableA variable has Access control, it has a name, and a type
VarMapA VarMap contains all information for legal protocol variables
VarMap::VarMapErrException thrown on VarMap errors such as on unknown variables
VarRWInterface used by policy filters to execute a policy on a route
verbose_ostream
VersionFilterPolicy filters which support versioning [i.e
VersionFiltersPolicy filters which support versioning [i.e
VertexA vertex in the shortest path tree
VifVirtual Interface class
VifAddrVirtual interface address class
VifCountClass that contains various counters per virtual interface
VifManagerVifManager keeps track of the VIFs currently enabled in the FEA
VifModifierBase class for vif modifier operations
ViMode
ViRepeat
VisitorVisitor pattern interface
VisitorDepThis visitor is used to check what sets a policy uses
VisitorPrinterThis visitor will produce a human readable text stream from a policy
VisitorSemanticA policy semantic checker
VisitorTest
ViUndo
Vlink< A >Manage all the state for virtual links
VrrpVRRP protocol implementation
VrrpAuthVRRP authentication data
VrrpExceptionExceptions generated by the VRRP protocol
VrrpHeaderThe VRRP header
VrrpInterfaceA network interface on which VRRP runs
VrrpPacketA VRRP packet including the IP header
VrrpTargetThe VRRP XORP process
VrrpVifImplementation of a VRRP network interface
Vlink< A >::VstateState about each virtual link
FinderEventObserver::Watch
BGPMain::RoutingTableToken< A >::WhichTable
Widget
WinRtmPipeWinRtmPipe class opens a routing socket and forwards data arriving on the socket to WinRtmPipeObservers
WinRtmPipeObserver
WinRtmPipePlumber
WinSupport
WordCompletion
WrongFinderMessageTypeException for mismatched finder message type
XrlAtom::WrongType
BaseAndDerived< B, D >::X
XrlDispatcher::XI
Xif::kdoc::XifKdocThing
Xif::parse::XifParser
XLogTraceTable< A >Route Table that passes that through updates whilst writing them to the logging them via XORP's XLOG_TRACE
xorp_noncopyableClass is not supposed to be coppied, so we don't implement the copy methods, but we do declare them
XorpClient
XorpExceptionA base class for XORP exceptions
XorpFd
XorpReasonedExceptionA base class for XORP exceptions that keeps the reason for exception
XorpRip< A >Class implementing RIP body
XorpShellBaseXorpShellBase base class
XorpTask
XorpTimerXorpTimer class
XorpUnexpectedHandlerXorpUnexpectedHandler installs the xorp_unexpected_handler when instantiated and re-installed the previous handler when uninstantiated
XrlXORP IPC request
XrlAction
XrlAddEGPTableCommand
XrlAddIGPTableCommand
XrlAddrJobBase< A >
Xif::xiftypes::XrlArg
XrlArgs
XrlAtom
XrlArgs::XrlAtomFound
XrlAtomListList class to contain XrlAtom's of one type
XrlArgs::XrlAtomNotFound
XrlAtomSpell
XrlBgpTarget
XrlBgpTargetBase
XrlBgpV0p3Client
XrlCliManagerV0p1Client
XrlCliNode
XrlCliProcessorV0p1Client
XrlCliTargetBase
XrlCmdEntry
XrlCmdErrorError codes for user callbacks
XrlCmdMap
XrlCommonV0p1Client
XrlCoordTarget
XrlCoordTargetBase
XrlCoordV0p1Client
XrlDatainV0p1Client
XRLdb
XrlDeleteEGPTableCommand
XrlDeleteIGPTableCommand
XrlDispatcher
XrlErrlet
XrlErrorAll known error codes arising from XRL dispatches
XrlFakeSender
XrlFeaFibClientV0p1Client
XrlFeaFibV0p1Client
XrlFeaFirewallV0p1Client
XrlFeaIfmgrMirrorTargetBase
XrlFeaIfmgrMirrorV0p1Client
XrlFeaIoFEA (Forwarding Engine Abstraction) XRL-based I/O class
XrlFeaNodeFEA (Forwarding Engine Abstraction) node class with XRL front-end
XrlFeaTargetFEA (Forwarding Engine Abstraction) XRL target class
XrlFeaTargetBase
XrlFib2mribNode
XrlFib2mribTargetBase
XrlFib2mribV0p1Client
XrlFibClientManagerClass for managing clients interested in FIB changes notifications
XrlFinderclientTargetBase
XrlFinderClientV0p2Client
XrlFinderEventNotifierV0p1Client
XrlFinderEventObserverV0p1Client
XrlFinderTargetBase
XrlFinderV0p2Client
XrlFtiV0p2Client
XrlIfmgrReplicatorV0p1Client
XrlIfmgrV0p1Client
Xif::xiftypes::XrlInterface
XrlIO< A >Concrete implementation of IO using XRLs
XrlIoIpManagerA class that is the bridge between the raw IP I/O communications and the XORP XRL interface
XrlIoLinkManagerA class that is the bridge between the raw link I/O communications and the XORP XRL interface
XrlIoTcpUdpManagerA class that is the bridge between the I/O TCP/UDP communications and the XORP XRL interface
XrlJobBaseBase class for Xrl Jobs that are invoked by classes derived from XrlJobQueue
XrlJobQueueClass for buffering and dispatching XRLs
Xif::xiftypes::XrlMethod
XrlMfeaClientV0p1Client
XrlMfeaNode
XrlMfeaTargetBase
XrlMfeaV0p1Client
XrlMld6igmpClientV0p1Client
XrlMld6igmpNode
XrlMld6igmpTargetBase
XrlMld6igmpV0p1Client
XrlOlsr4TargetConcrete implementation of OLSRv1/IPv4 XRL target
XrlOlsr4TargetBase
XrlOlsr4V0p1Client
XrlOspfV2Target
XrlOspfv2TargetBase
XrlOspfv2V0p1Client
XrlOspfv3TargetBase
XrlOspfv3V0p1Client
XrlParseError
XrlParser
XrlParserFileInputXrlParserFileInput class reads lines from a data source, strips out comments and handles continuation characters
XrlParserInputBase class for XrlParserInput's
XrlParserInputExceptionException class used by XrlParserInput difficulties
XrlPFConstructorError
XrlPFListener
XrlPFSender
XrlPFSenderFactory
XrlPFSTCPListenerListener for XRL's transported by TCP
XrlPFSTCPSenderSender of Xrls by TCP
XrlPFSTCPSenderList
XrlPFUNIXListener
XrlPFUNIXSender
XrlPimNode
XrlPimTargetBase
XrlPimV0p1Client
XrlPolicyBackendV0p1Client
XrlPolicyRedist4V0p1Client
XrlPolicyRedist6V0p1Client
XrlPolicyTargetThe XORP Xrl target
XrlPolicyTargetBase
XrlPolicyV0p1Client
XrlPortHelper class which encapsulates XRL socket service
XrlPortIO< A >
XrlPortManager< A >Class for managing RIP Ports and their transport systems
XrlProcessSpyClass that watches remote FEA and RIB processes
XrlProfileClientV0p1Client
XrlProfilerTarget
XrlProfilerTargetBase
XrlProfileV0p1Client
XrlQueue< A >Helper class to queue route adds and deletes to the RIB
XrlRawLinkClientV0p1Client
XrlRawLinkV0p1Client
XrlRawPacket4ClientV0p1Client
XrlRawPacket4V0p1Client
XrlRawPacket6ClientV0p1Client
XrlRawPacket6V0p1Client
XrlRedist4V0p1Client
XrlRedist6V0p1Client
XrlRedistManager< A >Xrl Route redistribution manager
XrlRedistTransaction4V0p1Client
XrlRedistTransaction6V0p1Client
XrlRibclientTargetBase
XrlRibClientV0p1Client
XrlRibNotifier< A >Class to send RIP updates to RIB process
XrlRibParser
XrlRibTargetImplement RIB Xrl target methods
XrlRibTargetBase
XrlRibV0p1Client
XrlRipCommonTarget< A >Common handler for Xrl Requests
XrlRipngTarget
XrlRipngTargetBase
XrlRipngV0p1Client
XrlRipTarget
XrlRipTargetBase
XrlRipV0p1Client
XrlRouteAddCommand
XrlRouteDeleteCommand
XrlRouter
XrlRouterDispatchStateSlow-path dispatch state
XrlRtrmgrClientV0p2Client
XrlRtrmgrInterface
XrlRtrmgrTargetBase
XrlRtrmgrV0p1Client
XrlSenderBase for classes able to transport Xrls
XrlShowDistancesTargetBase
XrlShowRoutesTargetBase
XrlShutdown
XrlSocket4UserV0p1Client
XrlSocket4V0p1Client
XrlSocket6UserV0p1Client
XrlSocket6V0p1Client
XrlSpec
XrlStartup
XrlStaticRoutesNode
XrlStaticRoutesTargetBase
XrlStaticRoutesV0p1Client
XrlStatusConfigMeValidation
XrlStatusReadyValidation
XrlStatusShutdownValidation
XrlStatusStartupValidation
XrlStatusValidation
XrlStdRouterStandard XRL transmission and reception point
XrlTarget< A >Class specialized to determine correct type of XrlTarget for addresses of type A
Xif::xiftypes::XrlTarget
XRLtarget
XrlTarget< IPv4 >
XrlTarget< IPv6 >
XrlMld6igmpNode::XrlTaskBaseA base class for handling tasks for sending XRL requests
XrlPimNode::XrlTaskBaseA base class for handling tasks for sending XRL requests
XrlTestFeaIfmgrMirrorTarget
XrlTestFeaIfmgrMirrorTargetBase
XrlTestFeaRawlinkTargetBase
XrlTestFinderEventsTargetBase
XrlTestPeerTarget
XrlTestPeerTargetBase
XrlTestPeerV0p1Client
XrlTestSocket4TargetBase
XrlTestSocket6TargetBase
XrlTestTarget
XrlTestTargetBase
XrlTestV1p0Client
XrlTestXrlsTargetBase
XrlTestXrlsV0p1Client
XrlToken
XrlVrrpTargetBase
XrlVrrpV0p1Client
XrlXorpshTargetBase
XUID
yy_buffer_state
yy_tb
yy_trans_info
YYSTYPE
ZeroTimerTest
 All Classes Namespaces Functions Variables Typedefs Enumerations