ACE RADIUS library
Portable open-source RADIUS stack
Parser is implemented by the following classes:
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:
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 is implemented by the following classes:
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 is implemented by the following classes:
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.
This site and project are hosted by
(c) by Alex Agranov, 2004-2009