/** \file radsec.h
- \brief Public interface for libradsec. */
+ \brief Public interface for libradsec. */
-/* See LICENSE for licensing information. */
+/* Copyright 2010-2013 NORDUnet A/S. All rights reserved.
+ See LICENSE for licensing information. */
#ifndef _RADSEC_RADSEC_H_
#define _RADSEC_RADSEC_H_ 1
#ifdef HAVE_STDINT_H
#include <stdint.h>
#endif
+#include "compat.h"
enum rs_error_code {
RSE_OK = 0,
RSE_INVALID_CTX = 3,
RSE_INVALID_CONN = 4,
RSE_CONN_TYPE_MISMATCH = 5,
- RSE_FR = 6,
RSE_BADADDR = 7,
RSE_NOPEER = 8,
RSE_EVENT = 9, /* libevent error. */
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,
/* Data types. */
struct rs_context; /* radsec-impl.h */
+struct rs_conn_base; /* radsec-impl.h */
struct rs_connection; /* 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 */
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;
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;
typedef const struct value_pair rs_const_avp;
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. */
/****************/
/** 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);
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);
/************/
-/* Message. */
+/* Message. */
/************/
/** 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 message \a msg on the connection associated with \a msg.
- \a user_data is sent to the \a rs_conn_message_received_cb callback
- registered with the connection. If no callback is registered with
- the connection, the event loop is run by \a rs_message_send and it
- blocks until the message has been succesfully sent.
+/** 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.
- \return On success, RSE_OK (0) is returned. On error, !0 is
+ 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_message_send(struct rs_message *msg, void *user_data);
+ the connection. The error can be accessed using \a rs_err_conn_pop. */
+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,
- \a user_pw and \a secret where \secret is the RADIUS shared
- secret. */
+ 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,
- const char *secret);
+ const char *user_pw);
/*** Append \a tail to message \a msg. */
int
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);
projects / radsecproxy.git / blobdiff