libxorp Globals

Annotated List  Files  Globals  Hierarchy  Index  Top

c_format.hh

• inline int  arg_count ()
• template <class A> inline int  arg_count (A)
• template <class A, class B> inline int  arg_count (A,B)
• template <class A, class B, class C> inline int  arg_count (A,B,C)
• template <class A, class B, class C, class D> inline int  arg_count (A,B,C,D)
• template <class A, class B, class C, class D, class E> inline int  arg_count (A,B,C,D,E)
• template <class A, class B, class C,class D, class E, class F> inline int  arg_count (A,B,C,D,E,F)
• template <class A, class B, class C, class D, class E, class F, class G> inline int  arg_count (A,B,C,D,E,F,G)
• template <class A, class B, class C, class D, class E, class F, class G, class H> inline int  arg_count (A,B,C,D,E,F,G,H)
• template <class A, class B, class C, class D, class E, class F, class G, class H, class I> inline int  arg_count (A,B,C,D,E,F,G,H,I)
• template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J> inline int  arg_count (A,B,C,D,E,F,G,H,I,J)
• template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J, class K> inline int  arg_count (A,B,C,D,E,F,G,H,I,J,K)
• template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J, class K, class L> inline int  arg_count (A,B,C,D,E,F,G,H,I,J,K,L)
• template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J, class K, class L, class M> inline int  arg_count (A,B,C,D,E,F,G,H,I,J,K,L,M)
• template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J, class K, class L, class M, class N> inline int  arg_count (A,B,C,D,E,F,G,H,I,J,K,L,M,N)
• void  c_format_validate (const char* fmt, int n)
• string  do_c_format (const char* fmt, ...)

debug.h

• inline void  swallow_args (const char*)
• template <class A> inline void  swallow_args (const char*, A)
• template <class A, class B> inline void  swallow_args (const char*, A, B)
• template <class A, class B, class C> inline void  swallow_args (const char*, A, B, C)
• template <class A, class B, class C, class D> inline void  swallow_args (const char*, A, B, C, D)
• template <class A, class B, class C, class D, class E> inline void  swallow_args (const char*, A, B, C, D, E)
• template <class A, class B, class C, class D, class E, class F> inline void  swallow_args (const char*, A, B, C, D, E, F)
• template <class A, class B, class C, class D, class E, class F, class G> inline void  swallow_args (const char*, A, B, C, D, E, F, G)
• template <class A, class B, class C, class D, class E, class F, class G, class H> inline void  swallow_args (const char*, A, B, C, D, E, F, G, H)
• template <class A, class B, class C, class D, class E, class F, class G, class H, class I> inline void  swallow_args (const char*, A, B, C, D, E, F, G, H, I)
• template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J> inline void  swallow_args (const char*, A, B, C, D, E, F, G, H, I, J)
• template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J, class K> inline void  swallow_args (const char*, A, B, C, D, E, F, G, H, I, J, K)
• template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J, class K, class L> inline void  swallow_args (const char*, A, B, C, D, E, F, G, H, I, J, K, L)
• inline void  check_args (const char*, ...)

ether_compat.h

• struct ether_addr*  ether_aton (const char *a)
• char*  ether_ntoa (const struct ether_addr* ea)

exceptions.hh

• void  xorp_catch_standard_exceptions ()
• void  xorp_print_standard_exceptions ()
• void  xorp_unexpected_handler ()

ipnet.hh

• template <class A> uint32_t  overlap (const IPNet<A>& a1, const IPNet<A>& a2)

ipv4net.hh

• typedef IPNet<IPv4> IPv4Net

ipv6net.hh

• typedef IPNet<IPv6> IPv6Net

ipvx.hh

• inline size_t  family2addr_size (const int family)
• inline uint32_t  family2addr_bitlen (const int family)

ipvxnet.hh

• typedef IPNet<IPvX> BaseIPvXNet

mac.hh

• inline bool  operator== (const Mac& m1, const Mac& m2)
• inline bool  operator== (const EtherMac& m1, const EtherMac& m2)

nexthop.hh

• typedef IPNextHop<IPv4> IPv4NextHop
• typedef IPNextHop<IPv6> IPv6NextHop
• typedef IPNextHop<IPvX> IPvXNextHop
• typedef IPPeerNextHop<IPv4> IPv4PeerNextHop
• typedef IPPeerNextHop<IPv6> IPv6PeerNextHop
• typedef IPPeerNextHop<IPvX> IPvXPeerNextHop
• typedef IPEncapsNextHop<IPv4> IPv4EncapsNextHop
• typedef IPEncapsNextHop<IPv6> IPv6EncapsNextHop
• typedef IPEncapsNextHop<IPvX> IPvXEncapsNextHop
• typedef IPExternalNextHop<IPv4> IPv4ExternalNextHop
• typedef IPExternalNextHop<IPv6> IPv6ExternalNextHop
• typedef IPExternalNextHop<IPvX> IPvXExternalNextHop

popen.hh

• pid_t  popen2 (const string& command, FILE *& outstream, FILE *& errstream)
• int  pclose2 (FILE *iop_out)

selector.hh

• enum SelectorMask { SEL_RD = 0x01, SEL_WR = 0x02, SEL_EX = 0x04, SEL_ALL = SEL_RD | SEL_WR | SEL_EX }
• typedef XorpCallback2<void,int,SelectorMask>::RefPtr SelectorCallback
• typedef ref_ptr<SelectorTag> Selector

service.hh

• enum ServiceStatus { SERVICE_READY = 0x001, SERVICE_STARTING = 0x002, SERVICE_RUNNING = 0x004, SERVICE_PAUSING = 0x008, SERVICE_PAUSED = 0x010, SERVICE_RESUMING = 0x020, SERVICE_SHUTTING_DOWN = 0x040, SERVICE_SHUTDOWN = 0x080, SERVICE_FAILED = 0x100, SERVICE_ALL = SERVICE_READY | SERVICE_STARTING | SERVICE_RUNNING | SERVICE_PAUSING | SERVICE_PAUSED | SERVICE_RESUMING | SERVICE_SHUTTING_DOWN | SERVICE_SHUTDOWN | SERVICE_FAILED }
• const char*  service_status_name (ServiceStatus s)

status_codes.h

• typedef enum --
• enum -- { PROC_NULL = 0, PROC_STARTUP = 1, PROC_NOT_READY = 2, PROC_READY = 3, PROC_SHUTDOWN = 4, PROC_FAILED = 5, PROC_DONE = 6 }

timer.hh

• typedef XorpCallback0<void>::RefPtr OneoffTimerCallback
• typedef XorpCallback0<bool>::RefPtr PeriodicTimerCallback
• typedef XorpCallback1<void, XorpTimer&>::RefPtr BasicTimerCallback

timeval.hh

• inline TimeVal  operator- (const TimeVal& v)
• inline TimeVal  operator* (int n, const TimeVal& t)
• inline TimeVal  operator* (const double& d, const TimeVal& t)
• inline TimeVal  random_uniform (const TimeVal& lower, const TimeVal& upper)
• inline TimeVal  random_uniform (const TimeVal& upper)
• inline TimeVal  positive_random_uniform (const TimeVal& center, const double& factor)

token.hh

• string  copy_token (const string& token_org)
• string  pop_token (string& token_line)
• bool  is_token_separator (const char c)
• bool  has_more_tokens (const string& token_line)
• string  char_line2token_line (const char *char_line)

tokenize.hh

• inline void  tokenize (const string& str, vector<string>& tokens, const string& delimiters = " ")

utility.h

• extern int  xorp_isalnum (int c)
• extern int  xorp_isalpha (int c)
• extern int  xorp_iscntrl (int c)
• extern int  xorp_isdigit (int c)
• extern int  xorp_isgraph (int c)
• extern int  xorp_islower (int c)
• extern int  xorp_isprint (int c)
• extern int  xorp_ispunct (int c)
• extern int  xorp_isspace (int c)
• extern int  xorp_isupper (int c)
• extern int  xorp_isxdigit (int c)
• extern int  xorp_tolower (int c)
• extern int  xorp_toupper (int c)

utils.hh

• template<class T> void  delete_pointers_list (list<T *>& delete_list)
• template<class T> void  delete_pointers_vector (vector<T *>& delete_vector)

xlog.h

• typedef enum --
• enum -- { XLOG_LEVEL_FATAL = 0, XLOG_LEVEL_ERROR, XLOG_LEVEL_WARNING, XLOG_LEVEL_INFO, XLOG_LEVEL_TRACE, XLOG_LEVEL_MAX }
• typedef enum --
• enum -- { XLOG_VERBOSE_LOW = 0, XLOG_VERBOSE_MEDIUM, XLOG_VERBOSE_HIGH, XLOG_VERBOSE_MAX }
• typedef int  (*xlog_output_func_t) (void *obj, const char *msg)
• int  xlog_init (const char *argv0, const char *preamble_message)
• int  xlog_exit (void)
• int  xlog_start (void)
• int  xlog_stop (void)
• int  xlog_is_running (void)
• int  xlog_enable (xlog_level_t log_level)
• int  xlog_disable (xlog_level_t log_level)
• void  xlog_set_preamble (const char *text)
• const char*  xlog_process_name (void)
• void  xlog_set_verbose (xlog_verbose_t verbose_level)
• void  xlog_level_set_verbose (xlog_level_t log_level, xlog_verbose_t verbose_level)
• int  xlog_add_output (FILE *fp)
• int  xlog_remove_output (FILE *fp)
• int  xlog_add_output_func (xlog_output_func_t func, void *obj)
• int  xlog_remove_output_func (xlog_output_func_t func, void *obj)
• int  xlog_add_default_output (void)
• int  xlog_remove_default_output (void)
• void  _xcond_trace_entry (const char *module_name, const char *file, int line, const char *fn)
• const char * xlog_localtime2string (void)
• int  x_vasprintf (char **ret, const char *format, va_list ap)
• int  x_asprintf (char **ret, const char *format, ...)

xorp.h

• typedef enum --
• enum -- { true = TRUE, false = FALSE }
• typedef bool bool_t

Global member Documentation

#include <c_format.hh>

#include <c_format.hh>

#include <c_format.hh>

#include <c_format.hh>

#include <c_format.hh>

#include <c_format.hh>

#include <c_format.hh>

#include <c_format.hh>

#include <c_format.hh>

#include <c_format.hh>

#include <c_format.hh>

#include <c_format.hh>

#include <c_format.hh>

#include <c_format.hh>

#include <c_format.hh>

#include <c_format.hh>

#include <c_format.hh>

#include <debug.h>

#include <debug.h>

#include <debug.h>

#include <debug.h>

#include <debug.h>

#include <debug.h>

#include <debug.h>

#include <debug.h>

#include <debug.h>

#include <debug.h>

#include <debug.h>

#include <debug.h>

#include <debug.h>

#include <debug.h>

#include <ether_compat.h>

#include <ether_compat.h>

#include <exceptions.hh>

Print diagnostic message if exception is derived from XorpException or from standard exceptions, and terminate the program.

#include <exceptions.hh>

Print diagnostic message if exception is derived from XorpException or from standard exceptions.

Note that unlike xorp_catch_standard_exceptions(), the program does NOT terminate.

#include <exceptions.hh>

Unexpected exceptions are programming errors and this handler can be installed with XorpUnexpectedHandler to print out as much information as possible. The default behaviour is just to dump core, but it very hard to detect what happened.

#include <ipnet.hh>

Determine the number of the most significant bits overlapping between two subnets.

Parameters:

Returns: the number of bits overlapping between a1 and a2.

#include <ipv4net.hh>

#include <ipv6net.hh>

#include <ipvx.hh>

#include <ipvx.hh>

#include <ipvxnet.hh>

Base IPvXNet just has IPNet methods. IPvXNet is derived from BaseIPvXNet and has IPvX specific functions such as whether contained type is an IPv4 network or an IPv6 network.

See IPNet for available methods.

#include <mac.hh>

#include <mac.hh>

#include <nexthop.hh>

#include <nexthop.hh>

#include <nexthop.hh>

#include <nexthop.hh>

#include <nexthop.hh>

#include <nexthop.hh>

#include <nexthop.hh>

#include <nexthop.hh>

#include <nexthop.hh>

#include <nexthop.hh>

#include <nexthop.hh>

#include <nexthop.hh>

#include <popen.hh>

#include <popen.hh>

#include <selector.hh>

Selector event type masks.

#include <selector.hh>

#include <selector.hh>

#include <service.hh>

Enumeration of states objects derived from ServiceBase may be in.

#include <service.hh>

Get text description of enumerated service status.

Parameters:

#include <status_codes.h>

 Explanation of Process States
 -----------------------------
    +-------------> PROC_NULL
    |                   |
    |                   | (1)
    |                   V
    |             PROC_STARTUP
    |                   |
    |                   | (2)
    |                   V
    |             PROC_NOT_READY
    |                |     ^
    |(9)         (3) |     | (4)
    |                V     |
    |               PROC_READY
    |               /        \
    |           (5)/          \(6)
    |             V            V
    |      PROC_SHUTDOWN  PROC_FAILED
    |             \           /
    |           (7)\         /(8)
    |               \       /
    |                V     V
    |               PROC_DONE
    |                   |
    |                   |
    |                   |
    |                   V
    +-------------------+
 Events/Actions
 --------------
 (1) Register with finder.
 (2) External dependencies satisfied, ready to be configured.
 (3) Finished processing any config changes, ready for other
     processes that depend on this process to be configured.
 (4) Received a config change that needs to be processed before other
     processes that depend on this process are configured.
 (5) Received a request for a clean shutdown.
 (6) Something failed, this process is no longer functioning correctly.
 (7) The shutdown has completed.
 (8) The process has completed the cleanup after the failure.
 (9) Deregister with finder.

 States
 ------
 PROC_NULL        Process is not registered with finder.  It may or may
                  not be running.

 PROC_STARTUP     Process is registered with finder, but is waiting
                  on some other processes before it is ready to be
                  configured.

 PROC_NOT_READY   For any reason, the process is not ready for processes
                  that depend on this process to be configured or
                  reconfigured.  A common reason is that this
                  process just received a config change, and is
                  still in the process of making the config change
                  active.

 PROC_READY       Process is running normally.  Processes that depend
                  on the state of this process can be configured or
                  reconfigured.

 PROC_SHUTDOWN    Process has received a shutdown request is shutting
                  down cleanly.  Normally the process will terminate by
                  itself after being in this state.

 PROC_FAILED      Process has suffered a fatal error, and is in the
                  process of cleaning up the mess.  Normally the process
                  will terminate by itself after being in this state.

 PROC_DONE        The process has completed operation, but is still
                  capable of responding to XRLs.

 Notes
 -----

 A process may spend zero time in PROC_STARTUP, PROC_NOT_READY,
 PROC_READY, PROC_SHUTDOWN, PROC_FAILED, or PROC_DONE states.  For
 example, a process may effectively go directly from PROC_NULL to
 PROC_READY state on startup if there are no dependencies that need
 to be taken into account.  A process may go from PROC_STARTUP or
 PROC_NOT_READY states to PROC_SHUTDOWN or PROC_FAILED states
 without spending any time in PROC_READY state if required.

 On reconfiguration, a process does not need to go to NOT_READY
 state unless it needs to delay the reconfiguration of processes
 that depend on the completion of this reconfiguration.

 After shutdown or a failure, the process may remain indefinitely in
 PROC_DONE state (e.g., if the process itself shoudn't really exit
 but rather await further instructions).

#include <status_codes.h>

#include <timer.hh>

#include <timer.hh>

#include <timer.hh>

#include <timeval.hh>

Prefix unary minus.

#include <timeval.hh>

Multiply TimeVal by integer.

#include <timeval.hh>

Multiply TimeVal by double.

#include <timeval.hh>

Generate a TimeVal value from a uniform random distribution between specified bounds.

Parameters:

Returns: value chosen from uniform random distribution.

#include <timeval.hh>

Generate a TimeVal value from a uniform random distribution between zero and specified bound.

Parameters:

Returns: value chosen from uniform random distribution.

#include <timeval.hh>

Generate a TimeVal value from a uniform random distribution between the bounds center - factor * center and center + factor * center. If the lower bound is less than TimeVal::ZERO() it is rounded up to TimeVal::ZERO().

Parameters:

Returns: value chosen from uniform random distribution.

#include <token.hh>

Copy a token.

If the token contains token separators, enclose it within quotations.

Parameters:

Returns: the copy of the token with token separators enclosed within quotations.

#include <token.hh>

Pop a token from a token line.

Parameters:

Returns: the first token from the front of the line. Also, token_line is modified to exlude that token.

#include <token.hh>

Test if a character is a token separator.

Currently, the is_space(3) characters and '|' are considered as token separators.

Parameters:

Returns: true if c is a token separator, otherwise false.

#include <token.hh>

Test if a token line contains more tokens.

Parameters:

Returns: true if token_line contains more tokens, otherwise false.

#include <token.hh>

Create a copy of a token line.

Create a copy of a token line, but all tokens with a single space between.

Parameters:

Returns: C++ string copy of char_line, but with all tokens inside with a single space between.

#include <tokenize.hh>

#include <utility.h>

#include <utility.h>

#include <utility.h>

#include <utility.h>

#include <utility.h>

#include <utility.h>

#include <utility.h>

#include <utility.h>

#include <utility.h>

#include <utility.h>

#include <utility.h>

#include <utility.h>

#include <utility.h>

#include <utils.hh>

Template to delete a list of pointers, and the objects pointed to.

Parameters:

#include <utils.hh>

Template to delete an array of pointers, and the objects pointed to.

Parameters:

#include <xlog.h>

The log levels. Typically used only by xlog_enable() and xlog_disable()

#include <xlog.h>

#include <xlog.h>

The messages verbose level. Typically used only by xlog_set_verbose() and xlog_level_set_verbose()

#include <xlog.h>

#include <xlog.h>

The type of add-on functions to process the log messages.

#include <xlog.h>

Initialize the log utility.

As part of the initialization, the preamble string will be set to <process_name><preamble_message> Use in preference to xlog_set_preamble which will be removed.

Parameters:

Returns: 0 on success, otherwise -1.

#include <xlog.h>

Gracefully exit logging.

Returns: 0 on success, otherwise -1.

#include <xlog.h>

Start logging.

Returns: 0 on success, otherwise -1.

#include <xlog.h>

Stop logging.

Returns: 0 on success, otherwise -1.

#include <xlog.h>

Check if xlog is running.

Returns: non-zero if xlog is running, otherwise 0.

#include <xlog.h>

Enable logging for messages of a given type (log_level_t).

By default, all message types are enabled.

Parameters:

Returns: 0 on success, otherwise -1.

#include <xlog.h>

Disable logging for messages of a given type (log_level_t).

Note: XLOG_LEVEL_FATAL cannot be disabled.

Parameters:

Returns: 0 on success, otherwise -1.

#include <xlog.h>

Set the preamble string for the log entries.

Parameters:

#include <xlog.h>

Get process name as set with xlog_init.

Returns: pointer to name on success, NULL otherwise.

#include <xlog.h>

Set the level of verbosity (xlog_verbose_t) for the log entries.

Applies for all type of messages except for XLOG_LEVEL_FATAL which always is set to the most verbose level.

Parameters:

#include <xlog.h>

Set the level of verbosity (xlog_verbose_t) for the log entries of messages of a given type (xlog_level_t).

Note: XLOG_LEVEL_FATAL verbosity cannot be changed, and is always set to the most verbose level.

Parameters:

#include <xlog.h>

Add a file descriptor to the set of output streams.

Parameters:

Returns: 0 on success, otherwise -1.

#include <xlog.h>

Remove a file descriptor from the set of output streams.

Parameters:

Returns: 0 on success, otherwise -1.

#include <xlog.h>

Add a processing function and an object to the set of output streams.

Parameters:

Returns: 0 on success, otherwise -1.

#include <xlog.h>

Remove a processing function and an object from the set of output streams.

Parameters:

Returns: 0 on success, otherwise -1.

#include <xlog.h>

Add default output stream to list of output streams.

XXX: right now the default is '/dev/stderr', but it should eventually be: `/dev/console' if the process has sufficient permissions, and `/dev/stderr' otherwise.

Returns: 0 on success, otherwise -1.

#include <xlog.h>

Remove the default output stream from the set of output streams.

Returns: 0 on success, otherwise -1.

#include <xlog.h>

A marker that can be used to indicate code that is not yet implemented and hence should not be run.

Note that it cannot be conditionally disabled and logs error through the standard XLOG mechanism. Always calls XLOG_FATAL.

#include <xlog.h>

Compute the current local time and return it as a string.

The return string has the format: Year/Month/Day Hour:Minute:Second.Microsecond Example: 2002/02/05 20:22:09.808632 Note that the returned string uses statically allocated memory, and does not need to be de-allocated.

Returns: a statically allocated string with the local time using the format described above.

#include <xlog.h>

A local implementation of vasprintf(3).

If vasprintf(3) is available, it is called instead.

Parameters:

Returns: (From FreeBSD vasprintf(3) manual page): The number of characters printed (not including the trailing '\0' used to end output to strings). Also, set the value pointed to by ret to be a pointer to a buffer sufficiently large to hold the formatted string. This pointer should be passed to free(3) to release the allocated storage when it is no longer needed. If sufficient space cannot be allocated, will return -1 and set ret to be a NULL pointer.

#include <xlog.h>

A local implementation of asprintf(3).

Parameters:

Returns: (From FreeBSD asprintf(3) manual page): The number of characters printed (not including the trailing '\0' used to end output to strings). Also, set ret to be a pointer to a buffer sufficiently large to hold the formatted string. This pointer should be passed to free(3) to release the allocated storage when it is no longer needed. If sufficient space cannot be allocated, will return -1 and set ret to be a NULL pointer.

#include <xorp.h>

#include <xorp.h>

#include <xorp.h>