diff options
Diffstat (limited to 'lib/include')
| -rw-r--r-- | lib/include/radsec/radsec-impl.h | 175 | ||||
| -rw-r--r-- | lib/include/radsec/radsec.h | 226 | ||||
| -rw-r--r-- | lib/include/radsec/request-impl.h | 2 | ||||
| -rw-r--r-- | lib/include/radsec/request.h | 15 |
4 files changed, 289 insertions, 129 deletions
diff --git a/lib/include/radsec/radsec-impl.h b/lib/include/radsec/radsec-impl.h index e472703..7da00dd 100644 --- a/lib/include/radsec/radsec-impl.h +++ b/lib/include/radsec/radsec-impl.h @@ -1,5 +1,5 @@ /** @file libradsec-impl.h - @brief Libraray internal header file for libradsec. */ + @brief Libraray internal header file for libradsec. */ /* Copyright 2010-2013 NORDUnet A/S. All rights reserved. See LICENSE for licensing information. */ @@ -7,19 +7,26 @@ #ifndef _RADSEC_RADSEC_IMPL_H_ #define _RADSEC_RADSEC_IMPL_H_ 1 +#include <assert.h> #include <event2/util.h> #include <confuse.h> #if defined(RS_ENABLE_TLS) #include <openssl/ssl.h> #endif +#include "compat.h" -/* Constants. */ +/**************/ +/* Constants. */ #define RS_HEADER_LEN 4 +#define RS_CONN_MAGIC_BASE 0xAE004711u +#define RS_CONN_MAGIC_GENERIC 0x843AEF47u +#define RS_CONN_MAGIC_LISTENER 0xDCB04783u -/* Data types. */ +/***************/ +/* Data types. */ enum rs_cred_type { RS_CRED_NONE = 0, - /* TLS pre-shared keys, RFC 4279. */ + /* TLS pre-shared keys, RFC 4279. */ RS_CRED_TLS_PSK, /* RS_CRED_TLS_DH_PSK, */ /* RS_CRED_TLS_RSA_PSK, */ @@ -32,6 +39,17 @@ enum rs_key_encoding { }; typedef unsigned int rs_key_encoding_t; +enum rs_peer_type { + RS_PEER_TYPE_CLIENT = 1, + RS_PEER_TYPE_SERVER = 2 +}; + +enum rs_conn_subtype { + RS_CONN_OBJTYPE_BASE = 1, + RS_CONN_OBJTYPE_GENERIC, + RS_CONN_OBJTYPE_LISTENER, +}; + #if defined (__cplusplus) extern "C" { #endif @@ -41,7 +59,6 @@ struct rs_credentials { char *identity; char *secret; enum rs_key_encoding secret_encoding; - unsigned int secret_len; }; struct rs_error { @@ -49,105 +66,161 @@ struct rs_error { char buf[1024]; }; -/** Configuration object for a connection. */ +/** Configuration object for a connection. */ struct rs_peer { - struct rs_connection *conn; + enum rs_peer_type type; + struct rs_conn_base *connbase; /**< For error handling. */ struct rs_realm *realm; char *hostname; char *service; - char *secret; /* RADIUS secret. */ + char *secret; /* RADIUS secret. */ struct evutil_addrinfo *addr_cache; + char *cacertfile; + char *cacertpath; + char *certfile; + char *certkeyfile; + struct rs_credentials *transport_cred; struct rs_peer *next; }; -/** Configuration object for a RADIUS realm. */ +/** Configuration object for a RADIUS realm. */ struct rs_realm { char *name; enum rs_conn_type type; int timeout; int retries; - char *cacertfile; - char *cacertpath; - char *certfile; - char *certkeyfile; - struct rs_credentials *transport_cred; + struct rs_listener *listeners; + struct rs_peer *local_addr; struct rs_peer *peers; struct rs_realm *next; }; -/** Top configuration object. */ +/** Top configuration object. */ struct rs_config { struct rs_realm *realms; cfg_t *cfg; }; +/** Libradsec context. */ struct rs_context { struct rs_config *config; + struct rs_realm *realms; struct rs_alloc_scheme alloc_scheme; struct rs_error *err; + struct event_base *evb; }; -struct rs_connection { +/** Base class for a connection. */ +struct rs_conn_base { + uint32_t magic; /* Must be one of RS_CONN_MAGIC_*. */ struct rs_context *ctx; - struct rs_realm *realm; /* Owned by ctx. */ - struct event_base *evb; /* Event base. */ - struct event *tev; /* Timeout event. */ - struct rs_conn_callbacks callbacks; - void *user_data; + struct rs_realm *realm; /* Owned by ctx. */ + enum rs_conn_type transport; + /** For a listener, allowed client addr/port pairs. + For an outgoing connection, set of configured servers. + For an incoming connection, the peer (as the only entry). */ struct rs_peer *peers; - struct rs_peer *active_peer; - struct rs_error *err; struct timeval timeout; - char is_connecting; /* FIXME: replace with a single state member */ - char is_connected; /* FIXME: replace with a single state member */ - int fd; /* Socket. */ - int tryagain; /* For server failover. */ - int nextid; /* Next RADIUS packet identifier. */ - /* TCP transport specifics. */ - struct bufferevent *bev; /* Buffer event. */ - /* UDP transport specifics. */ - struct event *wev; /* Write event (for UDP). */ - struct event *rev; /* Read event (for UDP). */ - struct rs_packet *out_queue; /* Queue for outgoing UDP packets. */ + int tryagain; /* For server failover. */ + void *user_data; + struct rs_error *err; + int fd; /* Socket. */ + /* TCP transport specifics. */ + struct bufferevent *bev; /* Buffer event. */ + /* UDP transport specifics. */ + struct event *wev; /* Write event (for UDP). */ + struct event *rev; /* Read event (for UDP). */ +}; + +enum rs_conn_state { + RS_CONN_STATE_UNDEFINED = 0, + RS_CONN_STATE_CONNECTING, + RS_CONN_STATE_CONNECTED, +}; + +/** A generic connection. */ +struct rs_connection { + struct rs_conn_base base_; + struct event *tev; /* Timeout event. */ + struct rs_conn_callbacks callbacks; + enum rs_conn_state state; + struct rs_peer *active_peer; + struct rs_message *out_queue; /* Queue for outgoing UDP packets. */ #if defined(RS_ENABLE_TLS) - /* TLS specifics. */ + /* TLS specifics. */ SSL_CTX *tls_ctx; SSL *tls_ssl; #endif }; -enum rs_packet_flags { - RS_PACKET_HEADER_READ, - RS_PACKET_RECEIVED, - RS_PACKET_SENT, +/** A listening connection. Spawns generic connections when peers + connect to it. */ +struct rs_listener { + struct rs_conn_base base_; + struct evconnlistener *evlistener; + struct rs_listener_callbacks callbacks; + struct rs_listener *next; +}; + +enum rs_message_flags { + RS_MESSAGE_HEADER_READ, + RS_MESSAGE_RECEIVED, + RS_MESSAGE_SENT, }; struct radius_packet; -struct rs_packet { +struct rs_message { struct rs_connection *conn; unsigned int flags; uint8_t hdr[RS_HEADER_LEN]; - struct radius_packet *rpkt; /* FreeRADIUS object. */ - struct rs_packet *next; /* Used for UDP output queue. */ + struct radius_packet *rpkt; /* FreeRADIUS object. */ + struct rs_message *next; /* Used for UDP output queue. */ }; #if defined (__cplusplus) } #endif -/* Convenience macros. */ -#define rs_calloc(h, nmemb, size) \ - (h->alloc_scheme.calloc ? h->alloc_scheme.calloc : calloc)(nmemb, size) -#define rs_malloc(h, size) \ - (h->alloc_scheme.malloc ? h->alloc_scheme.malloc : malloc)(size) -#define rs_free(h, ptr) \ - (h->alloc_scheme.free ? h->alloc_scheme.free : free)(ptr) -#define rs_realloc(h, realloc, ptr, size) \ - (h->alloc_scheme.realloc ? h->alloc_scheme.realloc : realloc)(ptr, size) +/***********************/ +/* Convenience macros. */ + +/* Memory allocation. */ +#define rs_calloc(h, nmemb, size) ((h)->alloc_scheme.calloc != NULL \ + ? (h)->alloc_scheme.calloc : calloc)((nmemb), (size)) +#define rs_malloc(h, size) ((h)->alloc_scheme.malloc != NULL \ + ? (h)->alloc_scheme.malloc : malloc)((size)) +#define rs_free(h, ptr) ((h)->alloc_scheme.free != NULL \ + ? (h)->alloc_scheme.free : free)((ptr)) +#define rs_realloc(h, ptr, size) ((h)->alloc_scheme.realloc != NULL \ + ? (h)->alloc_scheme.realloc : realloc)((ptr), (size)) #define min(a, b) ((a) < (b) ? (a) : (b)) #define max(a, b) ((a) > (b) ? (a) : (b)) +/* Basic CPP-based classes, proudly borrowed from Tor. */ +#if defined(__GNUC__) && __GNUC__ > 3 + #define STRUCT_OFFSET(tp, member) __builtin_offsetof(tp, member) +#else + #define STRUCT_OFFSET(tp, member) \ + ((off_t) (((char*)&((tp*)0)->member)-(char*)0)) +#endif +#define SUBTYPE_P(p, subtype, basemember) \ + ((void*) (((char*)(p)) - STRUCT_OFFSET(subtype, basemember))) +#define DOWNCAST(to, ptr) ((to*)SUBTYPE_P(ptr, to, base_)) +#define TO_BASE_CONN(c) (&((c)->base_)) +static struct rs_connection *TO_GENERIC_CONN (struct rs_conn_base *); +static struct rs_listener *TO_LISTENER_CONN (struct rs_conn_base *); +static INLINE struct rs_connection *TO_GENERIC_CONN (struct rs_conn_base *b) +{ + assert (b->magic == RS_CONN_MAGIC_GENERIC); + return DOWNCAST (struct rs_connection, b); +} +static INLINE struct rs_listener *TO_LISTENER_CONN (struct rs_conn_base *b) +{ + assert (b->magic == RS_CONN_MAGIC_LISTENER); + return DOWNCAST (struct rs_listener, b); +} + #endif /* _RADSEC_RADSEC_IMPL_H_ */ /* Local Variables: */ diff --git a/lib/include/radsec/radsec.h b/lib/include/radsec/radsec.h index d6150bf..6b319d3 100644 --- a/lib/include/radsec/radsec.h +++ b/lib/include/radsec/radsec.h @@ -1,5 +1,5 @@ /** \file radsec.h - \brief Public interface for libradsec. */ + \brief Public interface for libradsec. */ /* Copyright 2010-2013 NORDUnet A/S. All rights reserved. See LICENSE for licensing information. */ @@ -22,6 +22,7 @@ #ifdef HAVE_STDINT_H #include <stdint.h> #endif +#include "compat.h" enum rs_error_code { RSE_OK = 0, @@ -38,7 +39,7 @@ enum rs_error_code { RSE_BADAUTH = 12, RSE_INTERNAL = 13, RSE_SSLERR = 14, /* OpenSSL error. */ - RSE_INVALID_PKT = 15, + RSE_INVALID_MSG = 15, RSE_TIMEOUT_CONN = 16, /* Connection timeout. */ RSE_INVAL = 17, /* Invalid argument. */ RSE_TIMEOUT_IO = 18, /* I/O timeout. */ @@ -71,7 +72,7 @@ enum rs_error_code { RSE_MAX = RSE_CERT }; -enum rs_conn_type { +enum rs_conn_type { /* FIXME: Rename rs_transport_type? */ RS_CONN_TYPE_NONE = 0, RS_CONN_TYPE_UDP, RS_CONN_TYPE_TCP, @@ -118,10 +119,27 @@ typedef enum rs_attr_type_t { extern "C" { #endif +/* Backwards compatible with 0.0.2. */ +#define RSE_INVALID_PKT RSE_INVALID_MSG +#define rs_packet rs_message +#define rs_conn_packet_received_cb rs_conn_message_received_cb +#define rs_conn_packet_sent_cb rs_conn_message_sent_cb +#define rs_conn_receive_packet rs_conn_receive_message +#define rs_dump_packet rs_dump_message +#define rs_packet_append_avp rs_message_append_avp +#define rs_packet_avps rs_message_avps +#define rs_packet_code rs_message_code +#define rs_packet_create rs_message_create +#define rs_packet_create_authn_request rs_message_create_authn_request +#define rs_packet_destroy rs_message_destroy +#define rs_packet_send rs_message_send + /* Data types. */ struct rs_context; /* radsec-impl.h */ +struct rs_conn_base; /* radsec-impl.h */ struct rs_connection; /* radsec-impl.h */ -struct rs_packet; /* radsec-impl.h */ +struct rs_listener; /* radsec-impl.h */ +struct rs_message; /* radsec-impl.h */ struct rs_conn; /* radsec-impl.h */ struct rs_error; /* radsec-impl.h */ struct rs_peer; /* radsec-impl.h */ @@ -142,18 +160,30 @@ struct rs_alloc_scheme { typedef void (*rs_conn_connected_cb) (void *user_data /* FIXME: peer? */ ); typedef void (*rs_conn_disconnected_cb) (void *user_data /* FIXME: reason? */ ); -typedef void (*rs_conn_packet_received_cb) (struct rs_packet *packet, - void *user_data); -typedef void (*rs_conn_packet_sent_cb) (void *user_data); +typedef void (*rs_conn_message_received_cb) (struct rs_message *message, + void *user_data); +typedef void (*rs_conn_message_sent_cb) (void *user_data); struct rs_conn_callbacks { - /** Callback invoked when the connection has been established. */ + /** Callback invoked when an outgoing connection has been established. */ rs_conn_connected_cb connected_cb; /** Callback invoked when the connection has been torn down. */ rs_conn_disconnected_cb disconnected_cb; - /** Callback invoked when a packet was received. */ - rs_conn_packet_received_cb received_cb; - /** Callback invoked when a packet was successfully sent. */ - rs_conn_packet_sent_cb sent_cb; + /** Callback invoked when a message was received. */ + rs_conn_message_received_cb received_cb; + /** Callback invoked when a message was successfully sent. */ + rs_conn_message_sent_cb sent_cb; +}; + +typedef struct rs_peer *(*rs_listener_client_filter_cb) + (const struct rs_listener *listener, void *user_data); +typedef void (*rs_listener_new_conn_cb) + (struct rs_connection *conn, void *user_data); +typedef void (*rs_listener_error_cb) + (struct rs_connection *conn, void *user_data); +struct rs_listener_callbacks { + rs_listener_client_filter_cb client_filter_cb; + rs_listener_new_conn_cb new_conn_cb; + rs_listener_error_cb error_cb; }; typedef struct value_pair rs_avp; @@ -193,18 +223,36 @@ int rs_context_set_alloc_scheme(struct rs_context *ctx, accessed using \a rs_err_ctx_pop. */ int rs_context_read_config(struct rs_context *ctx, const char *config_file); +int rs_context_print_config (struct rs_context *ctx, char **buf_out); + +/*************/ +/* Listener. */ +/*************/ +int rs_listener_create (struct rs_context *ctx, + struct rs_listener **listener, + const char *config); +void rs_listener_set_callbacks (struct rs_listener *listener, + const struct rs_listener_callbacks *cb, + void *user_data); +int rs_listener_listen (struct rs_listener *listener); +int rs_listener_dispatch (const struct rs_listener *listener); +int rs_listener_close (struct rs_listener *l); +struct event_base *rs_listener_get_eventbase (const struct rs_listener *l); +int rs_listener_get_fd (const struct rs_listener *l); + /****************/ /* Connection. */ /****************/ /** Create a connection. \a conn is the address of a pointer to an \a rs_connection, the output. Free the connection using \a rs_conn_destroy. Note that a connection must not be freed before - all packets associated with the connection have been freed. A - packet is associated with a connection when it's created (\a - rs_packet_create) or received (\a rs_conn_receive_packet). + all messages associated with the connection have been freed. A + message is associated with a connection when it's created + (\a rs_message_create) or received (\a rs_conn_receive_message). + + If \a config is not NULL it should be the name of a realm found in + a config file that has already been read using \a rs_context_read_config. - If \a config is not NULL it should be the name of a configuration - found in the config file read in using \a rs_context_read_config. \return On success, RSE_OK (0) is returned. On error, !0 is returned and a struct \a rs_error is pushed on the error stack for the context. The error can be accessed using \a @@ -223,10 +271,10 @@ int rs_conn_add_listener(struct rs_connection *conn, int rs_conn_disconnect (struct rs_connection *conn); /** Disconnect and free memory allocated for connection \a conn. Note - that a connection must not be freed before all packets associated - with the connection have been freed. A packet is associated with - a connection when it's created (\a rs_packet_create) or received - (\a rs_conn_receive_packet). \return RSE_OK (0) on success, !0 * + that a connection must not be freed before all messages associated + with the connection have been freed. A message is associated with + a connection when it's created (\a rs_message_create) or received + (\a rs_conn_receive_message). \return RSE_OK (0) on success, !0 * on error. On error, errno is set appropriately. */ int rs_conn_destroy(struct rs_connection *conn); @@ -238,7 +286,8 @@ int rs_conn_set_eventbase(struct rs_connection *conn, struct event_base *eb); /** Register callbacks \a cb for connection \a conn. */ void rs_conn_set_callbacks(struct rs_connection *conn, - struct rs_conn_callbacks *cb); + struct rs_conn_callbacks *cb, + void *user_data); /** Remove callbacks for connection \a conn. */ void rs_conn_del_callbacks(struct rs_connection *conn); @@ -261,88 +310,115 @@ int rs_conn_get_current_peer(struct rs_connection *conn, If \a req_msg is not NULL, a successfully received RADIUS message is verified against it. If \a pkt_out is not NULL it will upon - return contain a pointer to an \a rs_packet containing the new + return contain a pointer to an \a rs_message containing the new message. \return On error or if the connect (TCP only) or read times out, \a pkt_out will not be changed and one or more errors are pushed on \a conn (available through \a rs_err_conn_pop). */ -int rs_conn_receive_packet(struct rs_connection *conn, - struct rs_packet *request, - struct rs_packet **pkt_out); +int rs_conn_receive_message(struct rs_connection *conn, + struct rs_message *request, + struct rs_message **pkt_out); + +/** Run the dispatcher for the event base associated with \a conn. A + * wrapper around event_base_dispatch() for not having to hand out the + * event base. */ +int rs_conn_dispatch(struct rs_connection *conn); + +#if 0 +/** Get the event base associated with connection \a conn. + * \return struct event_base*. */ +struct event_base *rs_conn_get_evb(const struct rs_connection *conn); +#endif +#define rs_conn_fd rs_conn_get_fd /* Old name. */ /** Get the file descriptor associated with connection \a conn. * \return File descriptor. */ -int rs_conn_fd(struct rs_connection *conn); +int rs_conn_get_fd(struct rs_connection *conn); /** Set the timeout value for connection \a conn. */ void rs_conn_set_timeout(struct rs_connection *conn, struct timeval *tv); /* Peer -- client and server. */ -int rs_peer_create(struct rs_connection *conn, struct rs_peer **peer_out); +/** Create a peer and add it to list of peers held by \a conn. */ +int rs_peer_create_for_conn (struct rs_connection *conn, + struct rs_peer **peer_out); +/** Create a peer and add it to list of peers held by \a listener. */ +int rs_peer_create_for_listener (struct rs_listener *listener, + struct rs_peer **peer_out); +/** Set RADIUS secret for \a peer. Free resurces with \a rs_peer_free_secret. */ +int rs_peer_set_secret(struct rs_peer *peer, const char *secret); +/** Free resources allocated by \a rs_peer_set_secret. */ +void rs_peer_free_secret (struct rs_peer *peer); int rs_peer_set_address(struct rs_peer *peer, const char *hostname, const char *service); -int rs_peer_set_secret(struct rs_peer *peer, const char *secret); +void rs_peer_free_address (struct rs_peer *peer); void rs_peer_set_timeout(struct rs_peer *peer, int timeout); void rs_peer_set_retries(struct rs_peer *peer, int retries); /************/ -/* Packet. */ +/* Message. */ /************/ -/** Create a packet associated with connection \a conn. */ -int rs_packet_create(struct rs_connection *conn, struct rs_packet **pkt_out); - -/** Free all memory allocated for packet \a pkt. */ -void rs_packet_destroy(struct rs_packet *pkt); - -/** Send packet \a pkt on the connection associated with \a pkt. - \a user_data is passed to the \a rs_conn_packet_received_cb callback - registered with the connection. If no callback is registered with - the connection, the event loop is run by \a rs_packet_send and it - blocks until the full packet has been sent. Note that sending can - fail in several ways, f.ex. if the transmission protocol in use - is connection oriented (\a RS_CONN_TYPE_TCP and \a RS_CONN_TYPE_TLS) - and the connection can not be established. Also note that no - retransmission is done, something that is required for connectionless - transport protocols (\a RS_CONN_TYPE_UDP and \a RS_CONN_TYPE_DTLS). - The "request" API with \a rs_request_send can help with this. +/** Create a message associated with connection \a conn. */ +int rs_message_create(struct rs_connection *conn, struct rs_message **pkt_out); + +/** Free all memory allocated for message \a msg. */ +void rs_message_destroy(struct rs_message *msg); + +/** Send \a msg on the connection associated with \a msg. + If no callback is registered with the connection + (\a rs_conn_set_callbacks), the event loop is run by + \a rs_message_send and it blocks until the message has been + succesfully sent. + + Note that sending can fail in several ways, f.ex. if the + transmission protocol in use is connection oriented + (\a RS_CONN_TYPE_TCP and \a RS_CONN_TYPE_TLS) and the connection + can not be established. + + Also note that no retransmission is being done. This is required + for connectionless transport protocols (\a RS_CONN_TYPE_UDP and + \a RS_CONN_TYPE_DTLS). The "request" API with \a rs_request_send can + help with this. \return On success, RSE_OK (0) is returned. On error, !0 is returned and a struct \a rs_error is pushed on the error stack for the connection. The error can be accessed using \a rs_err_conn_pop. */ -int rs_packet_send(struct rs_packet *pkt, void *user_data); - -/** Create a RADIUS authentication request packet associated with - connection \a conn. Optionally, User-Name and User-Password - attributes are added to the packet using the data in \a user_name - and \a user_pw. */ -int rs_packet_create_authn_request(struct rs_connection *conn, - struct rs_packet **pkt, - const char *user_name, - const char *user_pw); - -/*** Append \a tail to packet \a pkt. */ +int rs_message_send(struct rs_message *msg); + +/** Create a RADIUS authentication request message associated with + connection \a conn. Optionally, User-Name and User-Password + attributes are added to the message using the data in \a user_name + and \a user_pw. + FIXME: describe what RADIUS shared secret is being used */ +int rs_message_create_authn_request(struct rs_connection *conn, + struct rs_message **msg, + const char *user_name, + const char *user_pw); + +/*** Append \a tail to message \a msg. */ int -rs_packet_append_avp(struct rs_packet *pkt, - unsigned int attribute, unsigned int vendor, - const void *data, size_t data_len); +rs_message_append_avp(struct rs_message *msg, + unsigned int attribute, unsigned int vendor, + const void *data, size_t data_len); -/*** Get pointer to \a pkt attribute value pairs. */ +/*** Get pointer to \a msg attribute value pairs. */ void -rs_packet_avps(struct rs_packet *pkt, rs_avp ***vps); +rs_message_avps(struct rs_message *msg, rs_avp ***vps); -/*** Get RADIUS packet type of \a pkt. */ +/*** Get RADIUS message type of \a msg. */ unsigned int -rs_packet_code(struct rs_packet *pkt); +rs_message_code(struct rs_message *msg); -/*** Get RADIUS AVP from \a pkt. */ +/*** Get RADIUS AVP from \a msg. */ rs_const_avp * -rs_packet_find_avp(struct rs_packet *pkt, unsigned int attr, unsigned int vendor); +rs_message_find_avp(struct rs_message *msg, unsigned int attr, + unsigned int vendor); -/*** Set packet identifier in \a pkt; returns old identifier */ +/*** Set packet identifier in \a msg; returns old identifier */ int -rs_packet_set_id (struct rs_packet *pkt, int id); +rs_message_set_id (struct rs_message *msg, int id); /************/ /* Config. */ @@ -381,9 +457,17 @@ int rs_err_conn_push_fl(struct rs_connection *conn, int line, const char *fmt, ...); +int rs_err_connbase_push_fl(struct rs_conn_base *connbase, + int code, + const char *file, + int line, + const char *fmt, + ...); /** Pop the first error from the error FIFO associated with connection - \a conn or NULL if there are no errors in the FIFO. */ + \a conn or NULL if there are no errors in the FIFO. */ struct rs_error *rs_err_conn_pop(struct rs_connection *conn); +struct rs_error *rs_err_connbase_pop(struct rs_conn_base *connbase); +struct rs_error *rs_err_listener_pop(struct rs_listener *l); int rs_err_conn_peek_code (struct rs_connection *conn); void rs_err_free(struct rs_error *err); diff --git a/lib/include/radsec/request-impl.h b/lib/include/radsec/request-impl.h index 97335e5..685a666 100644 --- a/lib/include/radsec/request-impl.h +++ b/lib/include/radsec/request-impl.h @@ -12,7 +12,7 @@ struct rs_request { struct rs_connection *conn; struct event *timer; - struct rs_packet *req_msg; + struct rs_message *req_msg; struct rs_conn_callbacks saved_cb; void *saved_user_data; }; diff --git a/lib/include/radsec/request.h b/lib/include/radsec/request.h index d4c72b3..c686de3 100644 --- a/lib/include/radsec/request.h +++ b/lib/include/radsec/request.h @@ -7,6 +7,10 @@ #ifndef _RADSEC_REQUEST_H_ #define _RADSEC_REQUEST_H_ 1 +/* Backwards compatible with 0.0.2. */ +#define rs_request_add_reqpkt rs_request_add_reqmsg +#define rs_request_get_reqpkt rs_request_get_reqmsg + struct rs_request; #if defined (__cplusplus) @@ -16,9 +20,8 @@ extern "C" { /** Create a request associated with connection \a conn. */ int rs_request_create(struct rs_connection *conn, struct rs_request **req_out); -/** Add RADIUS request message \a req_msg to request \a req. - FIXME: Rename to rs_request_add_reqmsg? */ -void rs_request_add_reqpkt(struct rs_request *req, struct rs_packet *req_msg); +/** Add RADIUS request message \a req_msg to request \a req. */ +void rs_request_add_reqmsg(struct rs_request *req, struct rs_message *req_msg); /** Create a request associated with connection \a conn containing a newly created RADIUS authentication message, possibly with \a @@ -33,15 +36,15 @@ int rs_request_create_authn(struct rs_connection *conn, response is put in \a resp_msg (if not NULL). NOTE: At present, no more than one outstanding request to a given realm is supported. This will change in a future version. */ -int rs_request_send(struct rs_request *req, struct rs_packet **resp_msg); +int rs_request_send(struct rs_request *req, struct rs_message **resp_msg); /** Free all memory allocated by request \a req including any request - packet associated with the request. Note that a request must be + message associated with the request. Note that a request must be freed before its associated connection can be freed. */ void rs_request_destroy(struct rs_request *req); /** Return request message in request \a req. */ -struct rs_packet *rs_request_get_reqmsg(const struct rs_request *req); +struct rs_message *rs_request_get_reqmsg(const struct rs_request *req); #if defined (__cplusplus) } |