ACE RADIUS library

Portable open-source RADIUS stack

Documentation

Parser

Parser is implemented by the following classes:

• RadiusAddress
• RadiusAttribute
• RadiusPacket
• RadiusSecret

An extreme case of "loose parsing" is implemented - all data is stored inside the RadiusPacket in its original form - i.e. in exactly the same format that is transferred over the network. RadiusAttribute class provides iterator functionality and methods for accessing and modifying attribute-specific data.

This approach is possible due to simple and efficient internal structure of the RADIUS protocol. It's advantages are numerous:

• memory management is very simple and efficient;
• we don't waste time for "packet encoding" - packet is constructed immediately as attributes are added to it and is ready to be sent at any time
• the interface is very simple and intuitive

One may argue that this approach is inefficient if application needs to parse RADIUS packet after constructing it or double-parse the incoming packet. However most applications don't work like this and the parser is fast enough to provide decent performance even in bizzare use cases.

Client Stack

Client Stack is implemented by the following classes:

• RadiusClientStack
• RadiusClientConnection

RadiusClientStack provides a simple fully-synchronous RADIUS client stack implementation. Multiple connections with RADIUS servers are supported for high-availability purposes (i.e. if one connection fails another will be used instead).

RadiusClientConnection is an internal class that represents single connection with RADIUS server. Each connection features its own secret key and retransmit settings. It should not be used by applications, since all needed APIs are provided by RadiusClientStack instead.

For a sample RADIUS client application, refer to test/client.cpp.

Applications that need to transmit a lot of RADIUS packets simultaneously may create several threads to execute multiple sendPacket() calls in parallel or provide their own non-blocking implementation of RADIUS client stack (e.g. as in ace-radius-v0.8).

Server Stack

Server Stack is implemented by the following classes:

• RadiusServerStack

RadiusServerStack provides a simple fully-synchronous RADIUS server stack implementation.

For a sample RADIUS server application, refer to test/server.cpp.

Applications that need to process a lot of incoming RADIUS packets may configure RadiusServerStack to operate in non-blocking mode or create several threads to simultaneously build and transmit multiple response packets.

Full class documentation

Full doxygen-generated class documentation is available here.