From: Arran Cudbard-Bell <a.cudbardb@freeradius.org>
Date: Fri, 11 Jan 2013 15:27:51 +0000 (+0000)
Subject: Add documentation to modules.h
X-Git-Tag: release_3_0_0_beta1~1324
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=5cea788fd3972a5849524fb83765bfbd37a9de5b;p=thirdparty%2Ffreeradius-server.git

Add documentation to modules.h

Add proper return code type rlm_rcode_t, and update signatures of all module functions that return rcodes
---

diff --git a/src/include/modules.h b/src/include/modules.h
index 3518e1d51f8..0ad885e0b1c 100644
--- a/src/include/modules.h
+++ b/src/include/modules.h
@@ -1,8 +1,7 @@
 /*
- * module.h	Interface to the RADIUS module system.
- *
- * Version:	$Id$
- *
+ * @file modules.h
+ * @brief Interface to the RADIUS module system.
+ * @version $Id$
  */
 
 #ifndef RADIUS_MODULES_H
@@ -17,76 +16,146 @@ RCSIDH(modules_h, "$Id$")
 extern "C" {
 #endif
 
-typedef int (*packetmethod)(void *instance, REQUEST *request);
-
+/** Return codes indicating the result of the module call
+ *
+ * All module functions must return one of the codes listed below (apart from
+ * RLM_MODULE_NUMCODES, which is used to check for validity).
+ */
+typedef enum rlm_rcodes {
+	RLM_MODULE_REJECT = 0,	//!< Immediately reject the request.
+	RLM_MODULE_FAIL,	//!< Module failed, don't reply.
+	RLM_MODULE_OK,		//!< The module is OK, continue.
+	RLM_MODULE_HANDLED,	//!< The module handled the request, so stop.
+	RLM_MODULE_INVALID,	//!< The module considers the request invalid.
+	RLM_MODULE_USERLOCK,	//!< Reject the request (user is locked out).
+	RLM_MODULE_NOTFOUND,	//!< User not found.
+	RLM_MODULE_NOOP,	//!< Module succeeded without doing anything.
+	RLM_MODULE_UPDATED,	//!< OK (pairs modified).
+	RLM_MODULE_NUMCODES,	//!< How many valid return codes there are.
+	RLM_MODULE_UNKNOWN	//!< Error resolving rcode (should not be
+				//!< returned by modules).
+} rlm_rcode_t;
+
+/** The different section components of the server
+ *
+ * Used as indexes in the methods array in the module_t struct. 
+ */
 typedef enum rlm_components {
-  RLM_COMPONENT_AUTH = 0,
-  RLM_COMPONENT_AUTZ,		/* 1 */
-  RLM_COMPONENT_PREACCT,	/* 2 */
-  RLM_COMPONENT_ACCT,		/* 3 */
-  RLM_COMPONENT_SESS,		/* 4 */
-  RLM_COMPONENT_PRE_PROXY,	/* 5 */
-  RLM_COMPONENT_POST_PROXY,	/* 6 */
-  RLM_COMPONENT_POST_AUTH,	/* 7 */
+	RLM_COMPONENT_AUTH = 0,	//!< 0 methods index for authenticate section.
+	RLM_COMPONENT_AUTZ,	//!< 1 methods index for authorize section.
+	RLM_COMPONENT_PREACCT,	//!< 2 methods index for preacct section.
+	RLM_COMPONENT_ACCT,	//!< 3 methods index for accounting section.
+	RLM_COMPONENT_SESS,	//!< 4 methods index for checksimul section.
+	RLM_COMPONENT_PRE_PROXY,//!< 5 methods index for preproxy section.
+	RLM_COMPONENT_POST_PROXY, //!< 6 methods index for postproxy section.
+	RLM_COMPONENT_POST_AUTH,//!< 7 methods index for postauth section.
 #ifdef WITH_COA
-  RLM_COMPONENT_RECV_COA,	/* 8 */
-  RLM_COMPONENT_SEND_COA,	/* 9 */
+	RLM_COMPONENT_RECV_COA,	//!< 8 methods index for recvcoa section.
+	RLM_COMPONENT_SEND_COA,	//!< 9 methods index for sendcoa section.
 #endif
-  RLM_COMPONENT_COUNT		/* 8 / 10: How many components are there */
+	RLM_COMPONENT_COUNT	//!< 10 how many components there are.
 } rlm_components_t;
 
+/** Map a section name, to a section typename, to an attribute number
+ * 
+ * Used by modules.c to define the mappings between names, types and control
+ * attributes.
+ */
 typedef struct section_type_value_t {
         const char      *section;
         const char      *typename;
         int             attr;
 } section_type_value_t;
 
+/** Mappings between section names, typenames and control attributes
+ *
+ * Defined in modules.c.
+ */
 extern const section_type_value_t section_type_value[];
 
-#define RLM_TYPE_THREAD_SAFE		(0 << 0)
-#define RLM_TYPE_THREAD_UNSAFE		(1 << 0)
-#define RLM_TYPE_CHECK_CONFIG_SAFE	(1 << 1)
-#define RLM_TYPE_HUP_SAFE		(1 << 2)
+#define RLM_TYPE_THREAD_SAFE		(0 << 0) //!< Module is threadsafe.
+#define RLM_TYPE_THREAD_UNSAFE		(1 << 0) //!< Module is not threadsafe,
+						 //!< server will protect calls
+						 //!< with mutex.
+#define RLM_TYPE_CHECK_CONFIG_SAFE	(1 << 1) //!< Is ok to instantiate 
+						 //!< module when server is
+						 //!< started with -C.
+#define RLM_TYPE_HUP_SAFE		(1 << 2) //!< Module can be
+						 //!< re-instantiated on HUP.
 
 #define RLM_MODULE_MAGIC_NUMBER ((uint32_t) (0xf4ee4ad3))
 #define RLM_MODULE_INIT RLM_MODULE_MAGIC_NUMBER
 
+/** Module section callback
+ * 
+ * Is called when the module is listed in a particular section of a virtual
+ * server, and the request has reached the module call.
+ *
+ * @param [in] instance created in instantiated, holds module config.
+ * @param [in,out] request being processed.
+ * @return the appropriate rcode.
+ */
+typedef rlm_rcode_t (*packetmethod)(void *instance, REQUEST *request);
+
+/** Module instantiation callback
+ * 
+ * Is called once per module instance. Is not called when new threads are
+ * spawned. Modules that require separate thread contexts should use the
+ * connection pool API.
+ *
+ * @param [in] mod_cs Module instance's configuration section.
+ * @param [out] instance Module instance's configuration structure, should be
+ *		alloced by by callback and freed by detach.
+ * @return -1 if instantiation failed, else 0.
+ */
+typedef int (*instantiate_t)(CONF_SECTION *mod_cs, void **instance);
+
+/** Module detach callback
+ * 
+ * Is called just before the server exits, and after re-instantiation on HUP,
+ * to free the old module instance.
+ *
+ * Detach should close all handles associated with the module instance, and
+ * free any memory allocated during instantiate.
+ *
+ * @param [in] instance to free.
+ * @return -1 if detach failed, else 0.
+ */
+typedef int (*detach_t)(void *instance);
+
+/** Metadata exported by the module
+ * 
+ * This determines the capabilities of the module, and maps internal functions
+ * within the module to different sections.
+ */
 typedef struct module_t {
-	uint32_t 	magic;	/* may later be opaque struct */
-	const char	*name;
-	int		type;
-	int		(*instantiate)(CONF_SECTION *mod_cs, void **instance);
-	int		(*detach)(void *instance);
-	packetmethod	methods[RLM_COMPONENT_COUNT];
+	uint32_t 	magic;	//!< Used to validate module struct.
+	const char	*name;	//!< The name of the module (without rlm_ 
+				//!< prefix).
+	int		type;	//!< One or more of the RLM_TYPE_* constants.
+	instantiate_t	instantiate;	//!< Function to use for instantiation.
+	detach_t	detach;	//!< Function to use to free module instance.
+	packetmethod	methods[RLM_COMPONENT_COUNT]; //!< Pointers to the
+				//!< various section functions, ordering
+				//!< determined which function is mapped to
+				//!< which section.
+						      
 } module_t;
 
-typedef enum rlm_rcodes {
-	RLM_MODULE_REJECT,	/* immediately reject the request */
-	RLM_MODULE_FAIL,	/* module failed, don't reply */
-	RLM_MODULE_OK,		/* the module is OK, continue */
-	RLM_MODULE_HANDLED,	/* the module handled the request, so stop. */
-	RLM_MODULE_INVALID,	/* the module considers the request invalid. */
-	RLM_MODULE_USERLOCK,	/* reject the request (user is locked out) */
-	RLM_MODULE_NOTFOUND,	/* user not found */
-	RLM_MODULE_NOOP,	/* module succeeded without doing anything */
-	RLM_MODULE_UPDATED,	/* OK (pairs modified) */
-	RLM_MODULE_NUMCODES	/* How many return codes there are */
-} rlm_rcodes_t;
-
 int setup_modules(int, CONF_SECTION *);
 int detach_modules(void);
 int module_hup(CONF_SECTION *modules);
-int module_authorize(int type, REQUEST *request);
-int module_authenticate(int type, REQUEST *request);
-int module_preacct(REQUEST *request);
-int module_accounting(int type, REQUEST *request);
+rlm_rcode_t module_authorize(int type, REQUEST *request);
+rlm_rcode_t module_authenticate(int type, REQUEST *request);
+rlm_rcode_t module_preacct(REQUEST *request);
+rlm_rcode_t module_accounting(int type, REQUEST *request);
 int module_checksimul(int type, REQUEST *request, int maxsimul);
-int module_pre_proxy(int type, REQUEST *request);
-int module_post_proxy(int type, REQUEST *request);
-int module_post_auth(int type, REQUEST *request);
+rlm_rcode_t module_pre_proxy(int type, REQUEST *request);
+rlm_rcode_t module_post_proxy(int type, REQUEST *request);
+rlm_rcode_t module_post_auth(int type, REQUEST *request);
 #ifdef WITH_COA
-int module_recv_coa(int type, REQUEST *request);
-int module_send_coa(int type, REQUEST *request);
+rlm_rcode_t module_recv_coa(int type, REQUEST *request);
+rlm_rcode_t module_send_coa(int type, REQUEST *request);
 #define MODULE_NULL_COA_FUNCS ,NULL,NULL
 #else
 #define MODULE_NULL_COA_FUNCS
@@ -94,7 +163,7 @@ int module_send_coa(int type, REQUEST *request);
 
 char *module_failure_msg(REQUEST *request, const char *fmt, ...);
 
-int indexed_modcall(int comp, int idx, REQUEST *request);
+rlm_rcode_t indexed_modcall(int comp, int idx, REQUEST *request);
 
 /*
  *	For now, these are strongly tied together.
diff --git a/src/main/modules.c b/src/main/modules.c
index 948dede0eab..bee23563f75 100644
--- a/src/main/modules.c
+++ b/src/main/modules.c
@@ -278,7 +278,7 @@ static int virtual_server_idx(const char *name)
 
 static virtual_server_t *virtual_server_find(const char *name)
 {
-	int rcode;
+	rlm_rcode_t rcode;
 	virtual_server_t *server;
 
 	rcode = virtual_server_idx(name);
@@ -747,9 +747,9 @@ static indexed_modcallable *new_sublist(rbtree_t *components, int comp, int idx)
 	return c;
 }
 
-int indexed_modcall(int comp, int idx, REQUEST *request)
+rlm_rcode_t indexed_modcall(int comp, int idx, REQUEST *request)
 {
-	int rcode;
+	rlm_rcode_t rcode;
 	modcallable *list = NULL;
 	virtual_server_t *server;
 
@@ -1636,7 +1636,7 @@ int setup_modules(int reload, CONF_SECTION *config)
  *	Call all authorization modules until one returns
  *	somethings else than RLM_MODULE_OK
  */
-int module_authorize(int autz_type, REQUEST *request)
+rlm_rcode_t module_authorize(int autz_type, REQUEST *request)
 {
 	return indexed_modcall(RLM_COMPONENT_AUTZ, autz_type, request);
 }
@@ -1644,7 +1644,7 @@ int module_authorize(int autz_type, REQUEST *request)
 /*
  *	Authenticate a user/password with various methods.
  */
-int module_authenticate(int auth_type, REQUEST *request)
+rlm_rcode_t module_authenticate(int auth_type, REQUEST *request)
 {
 	return indexed_modcall(RLM_COMPONENT_AUTH, auth_type, request);
 }
@@ -1653,7 +1653,7 @@ int module_authenticate(int auth_type, REQUEST *request)
 /*
  *	Do pre-accounting for ALL configured sessions
  */
-int module_preacct(REQUEST *request)
+rlm_rcode_t module_preacct(REQUEST *request)
 {
 	return indexed_modcall(RLM_COMPONENT_PREACCT, 0, request);
 }
@@ -1661,7 +1661,7 @@ int module_preacct(REQUEST *request)
 /*
  *	Do accounting for ALL configured sessions
  */
-int module_accounting(int acct_type, REQUEST *request)
+rlm_rcode_t module_accounting(int acct_type, REQUEST *request)
 {
 	return indexed_modcall(RLM_COMPONENT_ACCT, acct_type, request);
 }
@@ -1675,7 +1675,7 @@ int module_accounting(int acct_type, REQUEST *request)
  */
 int module_checksimul(int sess_type, REQUEST *request, int maxsimul)
 {
-	int rcode;
+	rlm_rcode_t rcode;
 
 	if(!request->username)
 		return 0;
@@ -1699,7 +1699,7 @@ int module_checksimul(int sess_type, REQUEST *request, int maxsimul)
 /*
  *	Do pre-proxying for ALL configured sessions
  */
-int module_pre_proxy(int type, REQUEST *request)
+rlm_rcode_t module_pre_proxy(int type, REQUEST *request)
 {
 	return indexed_modcall(RLM_COMPONENT_PRE_PROXY, type, request);
 }
@@ -1707,7 +1707,7 @@ int module_pre_proxy(int type, REQUEST *request)
 /*
  *	Do post-proxying for ALL configured sessions
  */
-int module_post_proxy(int type, REQUEST *request)
+rlm_rcode_t module_post_proxy(int type, REQUEST *request)
 {
 	return indexed_modcall(RLM_COMPONENT_POST_PROXY, type, request);
 }
@@ -1716,18 +1716,18 @@ int module_post_proxy(int type, REQUEST *request)
 /*
  *	Do post-authentication for ALL configured sessions
  */
-int module_post_auth(int postauth_type, REQUEST *request)
+rlm_rcode_t module_post_auth(int postauth_type, REQUEST *request)
 {
 	return indexed_modcall(RLM_COMPONENT_POST_AUTH, postauth_type, request);
 }
 
 #ifdef WITH_COA
-int module_recv_coa(int recv_coa_type, REQUEST *request)
+rlm_rcode_t module_recv_coa(int recv_coa_type, REQUEST *request)
 {
 	return indexed_modcall(RLM_COMPONENT_RECV_COA, recv_coa_type, request);
 }
 
-int module_send_coa(int send_coa_type, REQUEST *request)
+rlm_rcode_t module_send_coa(int send_coa_type, REQUEST *request)
 {
 	return indexed_modcall(RLM_COMPONENT_SEND_COA, send_coa_type, request);
 }
diff --git a/src/modules/rlm_acctlog/rlm_acctlog.c b/src/modules/rlm_acctlog/rlm_acctlog.c
index b69d905c6a1..14bc1e83b0f 100644
--- a/src/modules/rlm_acctlog/rlm_acctlog.c
+++ b/src/modules/rlm_acctlog/rlm_acctlog.c
@@ -29,11 +29,11 @@ RCSID("$Id$")
 #include <freeradius-devel/modules.h>
 
 typedef struct rlm_acctlog_t {
-    char        *acctstart;
-    char        *acctstop;
-	char		*acctupdate;
-    char        *accton;
-	char		*acctoff;
+	char	*acctstart;
+	char	*acctstop;
+	char	*acctupdate;
+	char	*accton;
+	char	*acctoff;
 
 } rlm_acctlog_t;
 
@@ -74,7 +74,7 @@ static int acctlog_instantiate(CONF_SECTION *conf, void **instance)
 
 }
 
-static int do_acctlog_acct(void *instance, REQUEST *request)
+static rlm_rcode_t do_acctlog_acct(void *instance, REQUEST *request)
 {
 	rlm_acctlog_t *inst;
 	VALUE_PAIR *pair;
@@ -85,13 +85,13 @@ static int do_acctlog_acct(void *instance, REQUEST *request)
 
 	inst = (rlm_acctlog_t*) instance;
 
-    if ((pair = pairfind(request->packet->vps, PW_ACCT_STATUS_TYPE, 0, TAG_ANY)) != NULL) {
-        acctstatustype = pair->vp_integer;
-    } else {
-        radius_xlat(logstr, sizeof(logstr), "packet has no accounting status type. [user '%{User-Name}', nas '%{NAS-IP-Address}']", request, NULL, NULL);
-        radlog(L_ERR, "rlm_acctlog (%s)", logstr);
-        return RLM_MODULE_INVALID;
-    }
+	if ((pair = pairfind(request->packet->vps, PW_ACCT_STATUS_TYPE, 0, TAG_ANY)) != NULL) {
+		acctstatustype = pair->vp_integer;
+	} else {
+		radius_xlat(logstr, sizeof(logstr), "packet has no accounting status type. [user '%{User-Name}', nas '%{NAS-IP-Address}']", request, NULL, NULL);
+		radlog(L_ERR, "rlm_acctlog (%s)", logstr);
+		return RLM_MODULE_INVALID;
+	}
 
 	switch (acctstatustype) {
 		case PW_STATUS_START:
diff --git a/src/modules/rlm_always/rlm_always.c b/src/modules/rlm_always/rlm_always.c
index 33a9920030b..a149f974d08 100644
--- a/src/modules/rlm_always/rlm_always.c
+++ b/src/modules/rlm_always/rlm_always.c
@@ -29,10 +29,10 @@ RCSID("$Id$")
  *	going to return.
  */
 typedef struct rlm_always_t {
-	char	*rcode_str;
-	int	rcode;
-	int	simulcount;
-	int	mpp;
+	char		*rcode_str;
+	rlm_rcode_t	rcode;
+	int		simulcount;
+	int		mpp;
 } rlm_always_t;
 
 /*
@@ -55,7 +55,7 @@ static const CONF_PARSER module_config[] = {
   { NULL, -1, 0, NULL, NULL }		/* end the list */
 };
 
-static int str2rcode(const char *s)
+static rlm_rcode_t str2rcode(const char *s)
 {
 	if(!strcasecmp(s, "reject"))
 		return RLM_MODULE_REJECT;
@@ -78,7 +78,7 @@ static int str2rcode(const char *s)
 	else {
 		radlog(L_ERR|L_CONS,
 			"rlm_always: Unknown module rcode '%s'.\n", s);
-		return -1;
+		return RLM_MODULE_UNKNOWN;
 	}
 }
 
@@ -108,7 +108,7 @@ static int always_instantiate(CONF_SECTION *conf, void **instance)
 	 *	Convert the rcode string to an int, and get rid of it
 	 */
 	data->rcode = str2rcode(data->rcode_str);
-	if (data->rcode == -1) {
+	if (data->rcode == RLM_MODULE_UNKNOWN) {
 		free(data);
 		return -1;
 	}
@@ -122,11 +122,8 @@ static int always_instantiate(CONF_SECTION *conf, void **instance)
  *	Just return the rcode ... this function is autz, auth, acct, and
  *	preacct!
  */
-static int always_return(void *instance, REQUEST *request)
+static rlm_rcode_t always_return(void *instance, UNUSED REQUEST *request)
 {
-	/* quiet the compiler */
-	request = request;
-
 	return ((struct rlm_always_t *)instance)->rcode;
 }
 
@@ -134,7 +131,7 @@ static int always_return(void *instance, REQUEST *request)
 /*
  *	checksimul fakes some other variables besides the rcode...
  */
-static int always_checksimul(void *instance, REQUEST *request)
+static rlm_rcode_t always_checksimul(void *instance, REQUEST *request)
 {
 	struct rlm_always_t *inst = instance;
 
diff --git a/src/modules/rlm_attr_filter/rlm_attr_filter.c b/src/modules/rlm_attr_filter/rlm_attr_filter.c
index 329a8b86d8b..628ce7cc35b 100644
--- a/src/modules/rlm_attr_filter/rlm_attr_filter.c
+++ b/src/modules/rlm_attr_filter/rlm_attr_filter.c
@@ -168,8 +168,8 @@ static int attr_filter_instantiate(CONF_SECTION *conf, void **instance)
 /*
  *	Common attr_filter checks
  */
-static int attr_filter_common(void *instance, REQUEST *request,
-			      RADIUS_PACKET *packet)
+static rlm_rcode_t attr_filter_common(void *instance, REQUEST *request,
+			      	      RADIUS_PACKET *packet)
 {
 	struct attr_filter_instance *inst = instance;
 	VALUE_PAIR	*vp;
@@ -339,34 +339,34 @@ static int attr_filter_common(void *instance, REQUEST *request,
 	return RLM_MODULE_UPDATED;
 }
 
-static int attr_filter_preacct(void *instance, REQUEST *request)
+static rlm_rcode_t attr_filter_preacct(void *instance, REQUEST *request)
 {
 	return attr_filter_common(instance, request, request->packet);
 }
 
-static int attr_filter_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t attr_filter_accounting(void *instance, REQUEST *request)
 {
 	return attr_filter_common(instance, request, request->reply);
 }
 
 #ifdef WITH_PROXY
-static int attr_filter_preproxy(void *instance, REQUEST *request)
+static rlm_rcode_t attr_filter_preproxy(void *instance, REQUEST *request)
 {
 	return attr_filter_common(instance, request, request->proxy);
 }
 
-static int attr_filter_postproxy(void *instance, REQUEST *request)
+static rlm_rcode_t attr_filter_postproxy(void *instance, REQUEST *request)
 {
 	return attr_filter_common(instance, request, request->proxy_reply);
 }
 #endif
 
-static int attr_filter_postauth(void *instance, REQUEST *request)
+static rlm_rcode_t attr_filter_postauth(void *instance, REQUEST *request)
 {
 	return attr_filter_common(instance, request, request->reply);
 }
 
-static int attr_filter_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t attr_filter_authorize(void *instance, REQUEST *request)
 {
 	return attr_filter_common(instance, request, request->packet);
 }
diff --git a/src/modules/rlm_attr_rewrite/rlm_attr_rewrite.c b/src/modules/rlm_attr_rewrite/rlm_attr_rewrite.c
index aa51c127908..4dd476ef8b3 100644
--- a/src/modules/rlm_attr_rewrite/rlm_attr_rewrite.c
+++ b/src/modules/rlm_attr_rewrite/rlm_attr_rewrite.c
@@ -150,10 +150,10 @@ static int attr_rewrite_instantiate(CONF_SECTION *conf, void **instance)
 	return 0;
 }
 
-static int do_attr_rewrite(void *instance, REQUEST *request)
+static rlm_rcode_t do_attr_rewrite(void *instance, REQUEST *request)
 {
 	rlm_attr_rewrite_t *data = (rlm_attr_rewrite_t *) instance;
-	int ret = RLM_MODULE_NOOP;
+	rlm_rcode_t rcode = RLM_MODULE_NOOP;
 	VALUE_PAIR *attr_vp = NULL;
 	VALUE_PAIR *tmp = NULL;
 	regex_t preg;
@@ -180,13 +180,13 @@ static int do_attr_rewrite(void *instance, REQUEST *request)
 		/* new_attribute = yes */
 		if (!radius_xlat(replace_STR, sizeof(replace_STR), data->replace, request, NULL, NULL)) {
 			DEBUG2("%s: xlat on replace string failed.", data->name);
-			return ret;
+			return rcode;
 		}
 		attr_vp = pairmake(data->attribute,replace_STR,0);
 		if (attr_vp == NULL){
 			DEBUG2("%s: Could not add new attribute %s with value '%s'", data->name,
 				data->attribute,replace_STR);
-			return ret;
+			return rcode;
 		}
 		switch(data->searchin){
 			case RLM_REGEX_INPACKET:
@@ -221,7 +221,7 @@ static int do_attr_rewrite(void *instance, REQUEST *request)
 				break;
 		}
 		DEBUG2("%s: Added attribute %s with value '%s'", data->name,data->attribute,replace_STR);
-		ret = RLM_MODULE_OK;
+		rcode = RLM_MODULE_OK;
 	} else {
 		int replace_len = 0;
 
@@ -264,11 +264,11 @@ do_again:
 			attr_vp = pairfind(tmp, data->da->attr, data->da->vendor, TAG_ANY);
 		if (attr_vp == NULL) {
 			DEBUG2("%s: Could not find value pair for attribute %s", data->name,data->attribute);
-			return ret;
+			return rcode;
 		}
 		if (attr_vp->vp_strvalue == NULL || attr_vp->length == 0){
 			DEBUG2("%s: Attribute %s string value NULL or of zero length", data->name,data->attribute);
-			return ret;
+			return rcode;
 		}
 		cflags |= REG_EXTENDED;
 		if (data->nocase)
@@ -276,13 +276,13 @@ do_again:
 
 		if (!radius_xlat(search_STR, sizeof(search_STR), data->search, request, NULL, NULL) && data->search_len != 0) {
 			DEBUG2("%s: xlat on search string failed.", data->name);
-			return ret;
+			return rcode;
 		}
 
 		if ((err = regcomp(&preg,search_STR,cflags))) {
 			regerror(err, &preg, err_msg, MAX_STRING_LEN);
 			DEBUG2("%s: regcomp() returned error: %s", data->name,err_msg);
-			return ret;
+			return rcode;
 		}
 
 		if ((attr_vp->type == PW_TYPE_IPADDR) &&
@@ -311,7 +311,7 @@ do_again:
 				regfree(&preg);
 				radlog(L_ERR, "%s: match failure for attribute %s with value '%s'", data->name,
 						data->attribute, attr_vp->vp_strvalue);
-				return ret;
+				return rcode;
 			}
 			if (pmatch[0].rm_so == -1)
 				break;
@@ -324,7 +324,7 @@ do_again:
 				regfree(&preg);
 				DEBUG2("%s: Replacement out of limits for attribute %s with value '%s'", data->name,
 						data->attribute, attr_vp->vp_strvalue);
-				return ret;
+				return rcode;
 			}
 
 			memcpy(ptr, ptr2,len);
@@ -369,7 +369,7 @@ do_again:
 				if (data->replace_len != 0 &&
 				radius_xlat(replace_STR, sizeof(replace_STR), data->replace, request, NULL, NULL) == 0) {
 					DEBUG2("%s: xlat on replace string failed.", data->name);
-					return ret;
+					return rcode;
 				}
 				replace_len = (data->replace_len != 0) ? strlen(replace_STR) : 0;
 				done_xlat = 1;
@@ -380,7 +380,7 @@ do_again:
 				regfree(&preg);
 				DEBUG2("%s: Replacement out of limits for attribute %s with value '%s'", data->name,
 						data->attribute, attr_vp->vp_strvalue);
-				return ret;
+				return rcode;
 			}
 			if (replace_len){
 				memcpy(ptr, replace_STR, replace_len);
@@ -394,7 +394,7 @@ do_again:
 		if (counter >= MAX_STRING_LEN){
 			DEBUG2("%s: Replacement out of limits for attribute %s with value '%s'", data->name,
 					data->attribute, attr_vp->vp_strvalue);
-			return ret;
+			return rcode;
 		}
 		memcpy(ptr, ptr2, len);
 		ptr[len] = '\0';
@@ -403,11 +403,11 @@ do_again:
 				data->attribute, attr_vp->vp_strvalue, new_str);
 		if (pairparsevalue(attr_vp, new_str) == NULL) {
 			DEBUG2("%s: Could not write value '%s' into attribute %s: %s", data->name, new_str, data->attribute, fr_strerror());
-			return ret;
+			return rcode;
 		}
 
 to_do_again:
-		ret = RLM_MODULE_OK;
+		rcode = RLM_MODULE_OK;
 
 		if (tmp != NULL){
 			tmp = attr_vp->next;
@@ -416,47 +416,47 @@ to_do_again:
 		}
 	}
 
-	return ret;
+	return rcode;
 }
 
-static int attr_rewrite_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t attr_rewrite_accounting(void *instance, REQUEST *request)
 {
 	return do_attr_rewrite(instance, request);
 }
 
-static int attr_rewrite_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t attr_rewrite_authorize(void *instance, REQUEST *request)
 {
 	return do_attr_rewrite(instance, request);
 }
 
-static int attr_rewrite_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t attr_rewrite_authenticate(void *instance, REQUEST *request)
 {
 	return do_attr_rewrite(instance, request);
 }
 
-static int attr_rewrite_preacct(void *instance, REQUEST *request)
+static rlm_rcode_t attr_rewrite_preacct(void *instance, REQUEST *request)
 {
 	return do_attr_rewrite(instance, request);
 }
 
-static int attr_rewrite_checksimul(void *instance, REQUEST *request)
+static rlm_rcode_t attr_rewrite_checksimul(void *instance, REQUEST *request)
 {
 	return do_attr_rewrite(instance, request);
 }
 
 #ifdef WITH_PROXY
-static int attr_rewrite_preproxy(void *instance, REQUEST *request)
+static rlm_rcode_t attr_rewrite_preproxy(void *instance, REQUEST *request)
 {
 	return do_attr_rewrite(instance, request);
 }
 
-static int attr_rewrite_postproxy(void *instance, REQUEST *request)
+static rlm_rcode_t attr_rewrite_postproxy(void *instance, REQUEST *request)
 {
 	return do_attr_rewrite(instance, request);
 }
 #endif
 
-static int attr_rewrite_postauth(void *instance, REQUEST *request)
+static rlm_rcode_t attr_rewrite_postauth(void *instance, REQUEST *request)
 {
 	return do_attr_rewrite(instance, request);
 }
diff --git a/src/modules/rlm_cache/rlm_cache.c b/src/modules/rlm_cache/rlm_cache.c
index 50e08a706c4..db23766214c 100644
--- a/src/modules/rlm_cache/rlm_cache.c
+++ b/src/modules/rlm_cache/rlm_cache.c
@@ -663,7 +663,7 @@ static int cache_instantiate(CONF_SECTION *conf, void **instance)
  *	If you want to cache something different in different sections,
  *	configure another cache module.
  */
-static int cache_it(void *instance, REQUEST *request)
+static rlm_rcode_t cache_it(void *instance, REQUEST *request)
 {
 	rlm_cache_entry_t *c;
 	rlm_cache_t *inst = instance;
diff --git a/src/modules/rlm_chap/rlm_chap.c b/src/modules/rlm_chap/rlm_chap.c
index 2a7116c8cc7..77383cb6a99 100644
--- a/src/modules/rlm_chap/rlm_chap.c
+++ b/src/modules/rlm_chap/rlm_chap.c
@@ -31,7 +31,7 @@ RCSID("$Id$")
 #include <freeradius-devel/radiusd.h>
 #include <freeradius-devel/modules.h>
 
-static int chap_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t chap_authorize(void *instance, REQUEST *request)
 {
 
 	/* quiet the compiler */
@@ -60,7 +60,7 @@ static int chap_authorize(void *instance, REQUEST *request)
  *	from the database. The authentication code only needs to check
  *	the password, the rest is done here.
  */
-static int chap_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t chap_authenticate(void *instance, REQUEST *request)
 {
 	VALUE_PAIR *passwd_item, *chap;
 	uint8_t pass_str[MAX_STRING_LEN];
diff --git a/src/modules/rlm_checkval/rlm_checkval.c b/src/modules/rlm_checkval/rlm_checkval.c
index a219894c8d2..116194e06e0 100644
--- a/src/modules/rlm_checkval/rlm_checkval.c
+++ b/src/modules/rlm_checkval/rlm_checkval.c
@@ -189,10 +189,10 @@ static int checkval_instantiate(CONF_SECTION *conf, void **instance)
 	return 0;
 }
 
-static int do_checkval(void *instance, REQUEST *request)
+static rlm_rcode_t do_checkval(void *instance, REQUEST *request)
 {
 	rlm_checkval_t *data = (rlm_checkval_t *) instance;
-	int ret=RLM_MODULE_NOOP;
+	rlm_rcode_t rcode = RLM_MODULE_NOOP;
 	VALUE_PAIR *chk_vp, *item_vp;
 	VALUE_PAIR *tmp;
 	char found = 0;
@@ -209,9 +209,9 @@ static int do_checkval(void *instance, REQUEST *request)
 	if (!(item_vp = pairfind(request->packet->vps, data->item_attr->attr, data->item_attr->vendor, TAG_ANY))){
 		DEBUG2("rlm_checkval: Could not find item named %s in request", data->item_name);
 		if (data->notfound_reject)
-			ret = RLM_MODULE_REJECT;
+			rcode = RLM_MODULE_REJECT;
 		else
-			ret = RLM_MODULE_NOTFOUND;
+			rcode = RLM_MODULE_NOTFOUND;
 	}
 	if (item_vp)
 		DEBUG2("rlm_checkval: Item Name: %s, Value: %s",data->item_name, item_vp->vp_strvalue);
@@ -220,7 +220,7 @@ static int do_checkval(void *instance, REQUEST *request)
 		if (!(chk_vp = pairfind(tmp, data->chk_attr->attr, data->chk_attr->vendor, TAG_ANY))){
 			if (!found){
 				DEBUG2("rlm_checkval: Could not find attribute named %s in check pairs",data->check_name);
-				ret = RLM_MODULE_NOTFOUND;
+				rcode = RLM_MODULE_NOTFOUND;
 			}
 			break;
 		}
@@ -237,28 +237,28 @@ static int do_checkval(void *instance, REQUEST *request)
 		if (data->dat_type == PW_TYPE_STRING ||
 		    data->dat_type == PW_TYPE_OCTETS) {
 			if (item_vp->length != chk_vp->length)
-				ret = RLM_MODULE_REJECT;
+				rcode = RLM_MODULE_REJECT;
 			else{
 				if (!memcmp(item_vp->vp_strvalue,
 					    chk_vp->vp_strvalue,
 					    (size_t) chk_vp->length))
-					ret = RLM_MODULE_OK;
+					rcode = RLM_MODULE_OK;
 				else
-					ret = RLM_MODULE_REJECT;
+					rcode = RLM_MODULE_REJECT;
 			}
 		} else if (data->dat_type == PW_TYPE_DATE) {
 			if (item_vp->vp_date == chk_vp->vp_date)
-				ret = RLM_MODULE_OK;
+				rcode = RLM_MODULE_OK;
 			else
-				ret = RLM_MODULE_REJECT;
+				rcode = RLM_MODULE_REJECT;
 		} else if (data->dat_type == PW_TYPE_INTEGER) {
 			if (item_vp->vp_integer == chk_vp->vp_integer)
-				ret = RLM_MODULE_OK;
+				rcode = RLM_MODULE_OK;
 			else
-				ret = RLM_MODULE_REJECT;
+				rcode = RLM_MODULE_REJECT;
 		}
 #ifdef HAVE_REGEX_H
-		if (ret == RLM_MODULE_REJECT &&
+		if (rcode == RLM_MODULE_REJECT &&
 		    chk_vp->operator == T_OP_REG_EQ) {
 			regex_t reg;
 			int err;
@@ -272,17 +272,17 @@ static int do_checkval(void *instance, REQUEST *request)
 				return RLM_MODULE_FAIL;
 			}
 			if (regexec(&reg, (char *)item_vp->vp_strvalue,0, NULL, 0) == 0)
-				ret = RLM_MODULE_OK;
+				rcode = RLM_MODULE_OK;
 			else
-				ret = RLM_MODULE_REJECT;
+				rcode = RLM_MODULE_REJECT;
 			regfree(&reg);
 		}
 #endif
 		tmp = chk_vp->next;
-	} while (ret == RLM_MODULE_REJECT &&
+	} while (rcode == RLM_MODULE_REJECT &&
 		 tmp != NULL);
 
-	if (ret == RLM_MODULE_REJECT) {
+	if (rcode == RLM_MODULE_REJECT) {
 		if (!item_vp && data->notfound_reject){
 			char module_fmsg[MAX_STRING_LEN];
 			VALUE_PAIR *module_fmsg_vp;
@@ -304,17 +304,17 @@ static int do_checkval(void *instance, REQUEST *request)
 	}
 
 
-	return ret;
+	return rcode;
 }
 
 /*
  */
-static int checkval_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t checkval_authorize(void *instance, REQUEST *request)
 {
 	return do_checkval(instance,request);
 }
 
-static int checkval_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t checkval_accounting(void *instance, REQUEST *request)
 {
 	return do_checkval(instance,request);
 }
diff --git a/src/modules/rlm_counter/rlm_counter.c b/src/modules/rlm_counter/rlm_counter.c
index a03d086e60f..2219a251c4c 100644
--- a/src/modules/rlm_counter/rlm_counter.c
+++ b/src/modules/rlm_counter/rlm_counter.c
@@ -169,7 +169,7 @@ static int counter_cmp(void *instance,
 }
 
 
-static int add_defaults(rlm_counter_t *inst)
+static rlm_rcode_t add_defaults(rlm_counter_t *inst)
 {
 	datum key_datum;
 	datum time_datum;
@@ -207,10 +207,10 @@ static int add_defaults(rlm_counter_t *inst)
 	return RLM_MODULE_OK;
 }
 
-static int reset_db(rlm_counter_t *inst)
+static rlm_rcode_t reset_db(rlm_counter_t *inst)
 {
 	int cache_size = inst->cache_size;
-	int ret;
+	rlm_rcode_t rcode;
 
 	DEBUG2("rlm_counter: reset_db: Closing database");
 	gdbm_close(inst->gdbm);
@@ -235,9 +235,9 @@ static int reset_db(rlm_counter_t *inst)
 	/*
 	 * Add defaults
 	 */
-	ret = add_defaults(inst);
-	if (ret != RLM_MODULE_OK)
-		return ret;
+	rcode = add_defaults(inst);
+	if (rcode != RLM_MODULE_OK)
+		return rcode;
 
 	DEBUG2("rlm_counter: reset_db ended");
 
@@ -574,14 +574,15 @@ static int counter_instantiate(CONF_SECTION *conf, void **instance)
 /*
  *	Write accounting information to this modules database.
  */
-static int counter_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t counter_accounting(void *instance, REQUEST *request)
 {
 	rlm_counter_t *inst = instance;
 	datum key_datum;
 	datum count_datum;
 	VALUE_PAIR *key_vp, *count_vp, *proto_vp, *uniqueid_vp;
 	rad_counter counter;
-	int rcode;
+	rlm_rcode_t rcode;
+	int ret;
 	int acctstatustype = 0;
 	time_t diff;
 
@@ -604,16 +605,14 @@ static int counter_accounting(void *instance, REQUEST *request)
 	 *	the counters.
 	 */
 	if (inst->reset_time && (inst->reset_time <= request->timestamp)) {
-		int ret;
-
 		DEBUG("rlm_counter: Time to reset the database.");
 		inst->last_reset = inst->reset_time;
 		find_next_reset(inst,request->timestamp);
 		pthread_mutex_lock(&inst->mutex);
-		ret = reset_db(inst);
+		rcode = reset_db(inst);
 		pthread_mutex_unlock(&inst->mutex);
-		if (ret != RLM_MODULE_OK)
-			return ret;
+		if (rcode != RLM_MODULE_OK)
+			return rcode;
 	}
 	/*
 	 * Check if we need to watch out for a specific service-type. If yes then check it
@@ -731,9 +730,9 @@ static int counter_accounting(void *instance, REQUEST *request)
 
 	DEBUG("rlm_counter: Storing new value in database.");
 	pthread_mutex_lock(&inst->mutex);
-	rcode = gdbm_store(inst->gdbm, key_datum, count_datum, GDBM_REPLACE);
+	ret = gdbm_store(inst->gdbm, key_datum, count_datum, GDBM_REPLACE);
 	pthread_mutex_unlock(&inst->mutex);
-	if (rcode < 0) {
+	if (ret < 0) {
 		radlog(L_ERR, "rlm_counter: Failed storing data to %s: %s",
 				inst->filename, gdbm_strerror(gdbm_errno));
 		return RLM_MODULE_FAIL;
@@ -749,10 +748,10 @@ static int counter_accounting(void *instance, REQUEST *request)
  *	from the database. The authentication code only needs to check
  *	the password, the rest is done here.
  */
-static int counter_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t counter_authorize(void *instance, REQUEST *request)
 {
 	rlm_counter_t *inst = instance;
-	int ret=RLM_MODULE_NOOP;
+	rlm_rcode_t rcode = RLM_MODULE_NOOP;
 	datum key_datum;
 	datum count_datum;
 	rad_counter counter;
@@ -770,15 +769,15 @@ static int counter_authorize(void *instance, REQUEST *request)
 	 *	the counters.
 	 */
 	if (inst->reset_time && (inst->reset_time <= request->timestamp)) {
-		int ret2;
+		rlm_rcode_t rcode2;
 
 		inst->last_reset = inst->reset_time;
 		find_next_reset(inst,request->timestamp);
 		pthread_mutex_lock(&inst->mutex);
-		ret2 = reset_db(inst);
+		rcode2 = reset_db(inst);
 		pthread_mutex_unlock(&inst->mutex);
-		if (ret2 != RLM_MODULE_OK)
-			return ret2;
+		if (rcode2 != RLM_MODULE_OK)
+			return rcode2;
 	}
 
 
@@ -790,7 +789,7 @@ static int counter_authorize(void *instance, REQUEST *request)
 	key_vp = (inst->key_attr == PW_USER_NAME) ? request->username : pairfind(request->packet->vps, inst->key_attr, 0, TAG_ANY);
 	if (key_vp == NULL) {
 		DEBUG2("rlm_counter: Could not find Key value pair");
-		return ret;
+		return rcode;
 	}
 
 	/*
@@ -798,7 +797,7 @@ static int counter_authorize(void *instance, REQUEST *request)
 	 */
 	if ((check_vp= pairfind(request->config_items, inst->check_attr, 0, TAG_ANY)) == NULL) {
 		DEBUG2("rlm_counter: Could not find Check item value pair");
-		return ret;
+		return rcode;
 	}
 
 	key_datum.dptr = key_vp->vp_strvalue;
@@ -879,7 +878,7 @@ static int counter_authorize(void *instance, REQUEST *request)
 			}
 		}
 
-		ret=RLM_MODULE_OK;
+		rcode = RLM_MODULE_OK;
 
 		DEBUG2("rlm_counter: (Check item - counter) is greater than zero");
 		DEBUG2("rlm_counter: Authorized user %s, check_item=%d, counter=%d",
@@ -902,13 +901,13 @@ static int counter_authorize(void *instance, REQUEST *request)
 		module_fmsg_vp = pairmake("Module-Failure-Message", module_fmsg, T_OP_EQ);
 		pairadd(&request->packet->vps, module_fmsg_vp);
 
-		ret=RLM_MODULE_REJECT;
+		rcode = RLM_MODULE_REJECT;
 
 		DEBUG2("rlm_counter: Rejected user %s, check_item=%d, counter=%d",
 				key_vp->vp_strvalue,check_vp->vp_integer,counter.user_counter);
 	}
 
-	return ret;
+	return rcode;
 }
 
 static int counter_detach(void *instance)
diff --git a/src/modules/rlm_cram/rlm_cram.c b/src/modules/rlm_cram/rlm_cram.c
index 4e166383fe3..7f6e58e5b48 100644
--- a/src/modules/rlm_cram/rlm_cram.c
+++ b/src/modules/rlm_cram/rlm_cram.c
@@ -135,7 +135,7 @@ static void calc_sha1_digest(uint8_t *buffer, const uint8_t *challenge,
 }
 
 
-static int cram_authenticate(UNUSED void * instance, REQUEST *request)
+static rlm_rcode_t cram_authenticate(UNUSED void * instance, REQUEST *request)
 {
 	VALUE_PAIR *authtype, *challenge, *response, *password;
 	uint8_t buffer[64];
diff --git a/src/modules/rlm_dbm/rlm_dbm.c b/src/modules/rlm_dbm/rlm_dbm.c
index 341c214b24e..13c801c6ec3 100644
--- a/src/modules/rlm_dbm/rlm_dbm.c
+++ b/src/modules/rlm_dbm/rlm_dbm.c
@@ -298,7 +298,7 @@ static int rlm_dbm_instantiate(CONF_SECTION *conf, void **instance) {
 	*instance = inst;
 	return 0;
 }
-static int rlm_dbm_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t rlm_dbm_authorize(void *instance, REQUEST *request)
 {
         VALUE_PAIR      *namepair;
         VALUE_PAIR      *request_pairs;
diff --git a/src/modules/rlm_detail/rlm_detail.c b/src/modules/rlm_detail/rlm_detail.c
index dffaac0adc9..2416ec25698 100644
--- a/src/modules/rlm_detail/rlm_detail.c
+++ b/src/modules/rlm_detail/rlm_detail.c
@@ -183,8 +183,8 @@ static int detail_instantiate(CONF_SECTION *conf, void **instance)
 /*
  *	Do detail, compatible with old accounting
  */
-static int do_detail(void *instance, REQUEST *request, RADIUS_PACKET *packet,
-		     int compat)
+static rlm_rcode_t do_detail(void *instance, REQUEST *request, RADIUS_PACKET *packet,
+			     int compat)
 {
 	int		outfd;
 	char		timestamp[256];
@@ -520,7 +520,7 @@ static int do_detail(void *instance, REQUEST *request, RADIUS_PACKET *packet,
 /*
  *	Accounting - write the detail files.
  */
-static int detail_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t detail_accounting(void *instance, REQUEST *request)
 {
 #ifdef WITH_DETAIL
 	if (request->listener->type == RAD_LISTEN_DETAIL &&
@@ -537,7 +537,7 @@ static int detail_accounting(void *instance, REQUEST *request)
 /*
  *	Incoming Access Request - write the detail files.
  */
-static int detail_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t detail_authorize(void *instance, REQUEST *request)
 {
 	return do_detail(instance,request,request->packet, FALSE);
 }
@@ -545,7 +545,7 @@ static int detail_authorize(void *instance, REQUEST *request)
 /*
  *	Outgoing Access-Request Reply - write the detail files.
  */
-static int detail_postauth(void *instance, REQUEST *request)
+static rlm_rcode_t detail_postauth(void *instance, REQUEST *request)
 {
 	return do_detail(instance,request,request->reply, FALSE);
 }
@@ -554,7 +554,7 @@ static int detail_postauth(void *instance, REQUEST *request)
 /*
  *	Incoming CoA - write the detail files.
  */
-static int detail_recv_coa(void *instance, REQUEST *request)
+static rlm_rcode_t detail_recv_coa(void *instance, REQUEST *request)
 {
 	return do_detail(instance,request,request->packet, FALSE);
 }
@@ -562,7 +562,7 @@ static int detail_recv_coa(void *instance, REQUEST *request)
 /*
  *	Outgoing CoA - write the detail files.
  */
-static int detail_send_coa(void *instance, REQUEST *request)
+static rlm_rcode_t detail_send_coa(void *instance, REQUEST *request)
 {
 	return do_detail(instance,request,request->reply, FALSE);
 }
@@ -572,7 +572,7 @@ static int detail_send_coa(void *instance, REQUEST *request)
  *	Outgoing Access-Request to home server - write the detail files.
  */
 #ifdef WITH_PROXY
-static int detail_pre_proxy(void *instance, REQUEST *request)
+static rlm_rcode_t detail_pre_proxy(void *instance, REQUEST *request)
 {
 	if (request->proxy &&
 	    request->proxy->vps) {
@@ -586,7 +586,7 @@ static int detail_pre_proxy(void *instance, REQUEST *request)
 /*
  *	Outgoing Access-Request Reply - write the detail files.
  */
-static int detail_post_proxy(void *instance, REQUEST *request)
+static rlm_rcode_t detail_post_proxy(void *instance, REQUEST *request)
 {
 	if (request->proxy_reply &&
 	    request->proxy_reply->vps) {
@@ -601,7 +601,7 @@ static int detail_post_proxy(void *instance, REQUEST *request)
 	 *	it's doing normal accounting.
 	 */
 	if (!request->proxy_reply) {
-		int rcode;
+		rlm_rcode_t rcode;
 
 		rcode = detail_accounting(instance, request);
 		if (rcode == RLM_MODULE_OK) {
diff --git a/src/modules/rlm_digest/rlm_digest.c b/src/modules/rlm_digest/rlm_digest.c
index 423454bee70..cc2a2478fa2 100644
--- a/src/modules/rlm_digest/rlm_digest.c
+++ b/src/modules/rlm_digest/rlm_digest.c
@@ -179,9 +179,9 @@ static int digest_fix(REQUEST *request)
 	return RLM_MODULE_OK;
 }
 
-static int digest_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t digest_authorize(void *instance, REQUEST *request)
 {
-	int rcode;
+	rlm_rcode_t rcode;
 
 	/* quiet the compiler */
 	instance = instance;
@@ -211,7 +211,7 @@ static int digest_authorize(void *instance, REQUEST *request)
 /*
  *	Perform all of the wondrous variants of digest authentication.
  */
-static int digest_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t digest_authenticate(void *instance, REQUEST *request)
 {
 	int i;
 	size_t a1_len, a2_len, kd_len;
diff --git a/src/modules/rlm_dynamic_clients/rlm_dynamic_clients.c b/src/modules/rlm_dynamic_clients/rlm_dynamic_clients.c
index 565bd1b54da..5893ff4a656 100644
--- a/src/modules/rlm_dynamic_clients/rlm_dynamic_clients.c
+++ b/src/modules/rlm_dynamic_clients/rlm_dynamic_clients.c
@@ -31,7 +31,8 @@ RCSID("$Id$")
 /*
  *	Find the client definition.
  */
-static int dynamic_client_authorize(UNUSED void *instance, REQUEST *request)
+static rlm_rcode_t dynamic_client_authorize(UNUSED void *instance,
+					    REQUEST *request)
 {
 	size_t length;
 	const char *value;
@@ -91,7 +92,7 @@ static int dynamic_client_authorize(UNUSED void *instance, REQUEST *request)
 	return RLM_MODULE_OK;
 }
 #else
-static int dynamic_client_authorize(UNUSED void *instance, REQUEST *request)
+static rlm_rcode_t dynamic_client_authorize(UNUSED void *instance, REQUEST *request)
 {
 	RDEBUG("Dynamic clients are unsupported in this build.");
 	return RLM_MODULE_FAIL;
diff --git a/src/modules/rlm_eap/rlm_eap.c b/src/modules/rlm_eap/rlm_eap.c
index b49f1f06239..87b2c52b495 100644
--- a/src/modules/rlm_eap/rlm_eap.c
+++ b/src/modules/rlm_eap/rlm_eap.c
@@ -276,12 +276,12 @@ static int eap_instantiate(CONF_SECTION *cs, void **instance)
 /*
  *	For backwards compatibility.
  */
-static int eap_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t eap_authenticate(void *instance, REQUEST *request)
 {
 	rlm_eap_t	*inst;
 	EAP_HANDLER	*handler;
 	eap_packet_t	*eap_packet;
-	int		rcode;
+	rlm_rcode_t	rcode;
 
 	inst = (rlm_eap_t *) instance;
 
@@ -488,7 +488,7 @@ static int eap_authenticate(void *instance, REQUEST *request)
  * to check for user existance & get their configured values.
  * It Handles EAP-START Messages, User-Name initilization.
  */
-static int eap_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t eap_authorize(void *instance, REQUEST *request)
 {
 	rlm_eap_t	*inst;
 	int		status;
@@ -563,7 +563,7 @@ static int eap_authorize(void *instance, REQUEST *request)
  *	If we're proxying EAP, then there may be magic we need
  *	to do.
  */
-static int eap_post_proxy(void *inst, REQUEST *request)
+static rlm_rcode_t eap_post_proxy(void *inst, REQUEST *request)
 {
 	size_t		i;
 	size_t		len;
@@ -581,7 +581,7 @@ static int eap_post_proxy(void *inst, REQUEST *request)
 	 */
 	handler = request_data_get(request, inst, REQUEST_DATA_EAP_HANDLER);
 	if (handler != NULL) {
-		int		rcode;
+		rlm_rcode_t rcode;
 		eap_tunnel_data_t *data;
 
 		/*
@@ -722,7 +722,7 @@ static int eap_post_proxy(void *inst, REQUEST *request)
 }
 #endif
 
-static int eap_post_auth(void *instance, REQUEST *request)
+static rlm_rcode_t eap_post_auth(void *instance, REQUEST *request)
 {
 	rlm_eap_t	*inst = instance;
 	VALUE_PAIR	*vp;
diff --git a/src/modules/rlm_eap2/rlm_eap2.c b/src/modules/rlm_eap2/rlm_eap2.c
index dd518ffff62..a1c23fec17b 100644
--- a/src/modules/rlm_eap2/rlm_eap2.c
+++ b/src/modules/rlm_eap2/rlm_eap2.c
@@ -857,13 +857,13 @@ static int eap_vp2data(VALUE_PAIR *vps, void **data, int *data_len)
 /*
  *	Do EAP.
  */
-static int eap_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t eap_authenticate(void *instance, REQUEST *request)
 {
 	rlm_eap_t	*inst;
 	EAP_HANDLER	*handler;
 	void		*data;
 	int		data_len;
-	int		rcode;
+	rlm_rcode_t	rcode;
 	VALUE_PAIR	*vp;
 
 	inst = (rlm_eap_t *) instance;
diff --git a/src/modules/rlm_example/rlm_example.c b/src/modules/rlm_example/rlm_example.c
index 68c5bf9e340..c009b1f7b51 100644
--- a/src/modules/rlm_example/rlm_example.c
+++ b/src/modules/rlm_example/rlm_example.c
@@ -103,7 +103,7 @@ static int example_instantiate(CONF_SECTION *conf, void **instance)
  *	from the database. The authentication code only needs to check
  *	the password, the rest is done here.
  */
-static int example_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t example_authorize(void *instance, REQUEST *request)
 {
 	VALUE_PAIR *state;
 	VALUE_PAIR *reply;
@@ -143,7 +143,7 @@ static int example_authorize(void *instance, REQUEST *request)
 /*
  *	Authenticate the user with the given password.
  */
-static int example_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t example_authenticate(void *instance, REQUEST *request)
 {
 	/* quiet the compiler */
 	instance = instance;
@@ -155,7 +155,7 @@ static int example_authenticate(void *instance, REQUEST *request)
 /*
  *	Massage the request before recording it or proxying it
  */
-static int example_preacct(void *instance, REQUEST *request)
+static rlm_rcode_t example_preacct(void *instance, REQUEST *request)
 {
 	/* quiet the compiler */
 	instance = instance;
@@ -167,7 +167,7 @@ static int example_preacct(void *instance, REQUEST *request)
 /*
  *	Write accounting information to this modules database.
  */
-static int example_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t example_accounting(void *instance, REQUEST *request)
 {
 	/* quiet the compiler */
 	instance = instance;
@@ -186,7 +186,7 @@ static int example_accounting(void *instance, REQUEST *request)
  *	max. number of logins, do a second pass and validate all
  *	logins by querying the terminal server (using eg. SNMP).
  */
-static int example_checksimul(void *instance, REQUEST *request)
+static rlm_rcode_t example_checksimul(void *instance, REQUEST *request)
 {
   instance = instance;
 
diff --git a/src/modules/rlm_exec/rlm_exec.c b/src/modules/rlm_exec/rlm_exec.c
index 869c8ffd3b6..edb9f653bbb 100644
--- a/src/modules/rlm_exec/rlm_exec.c
+++ b/src/modules/rlm_exec/rlm_exec.c
@@ -267,7 +267,7 @@ static int exec_instantiate(CONF_SECTION *conf, void **instance)
 /*
  *  Dispatch an exec method
  */
-static int exec_dispatch(void *instance, REQUEST *request)
+static rlm_rcode_t exec_dispatch(void *instance, REQUEST *request)
 {
 	rlm_exec_t *inst = (rlm_exec_t *) instance;
 	int result;
@@ -382,7 +382,7 @@ static int exec_dispatch(void *instance, REQUEST *request)
  *
  *	Then, call exec_dispatch.
  */
-static int exec_postauth(void *instance, REQUEST *request)
+static rlm_rcode_t exec_postauth(void *instance, REQUEST *request)
 {
 	int result;
 	int exec_wait = 0;
@@ -445,7 +445,7 @@ static int exec_postauth(void *instance, REQUEST *request)
  *
  *	Then, call exec_dispatch.
  */
-static int exec_accounting(void *instance, REQUEST *request)
+static  rlm_rcode_t exec_accounting(void *instance, REQUEST *request)
 {
 	int result;
 	int exec_wait = 0;
diff --git a/src/modules/rlm_expiration/rlm_expiration.c b/src/modules/rlm_expiration/rlm_expiration.c
index 3eb9caa56b1..e20a20b48d3 100644
--- a/src/modules/rlm_expiration/rlm_expiration.c
+++ b/src/modules/rlm_expiration/rlm_expiration.c
@@ -58,7 +58,7 @@ static const CONF_PARSER module_config[] = {
 /*
  *      Check if account has expired, and if user may login now.
  */
-static int expiration_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t expiration_authorize(void *instance, REQUEST *request)
 {
 	rlm_expiration_t *data = (rlm_expiration_t *)instance;
 	VALUE_PAIR *vp, *check_item = NULL;
diff --git a/src/modules/rlm_fastusers/rlm_fastusers.c b/src/modules/rlm_fastusers/rlm_fastusers.c
index 88189fc5983..f2cda30419d 100644
--- a/src/modules/rlm_fastusers/rlm_fastusers.c
+++ b/src/modules/rlm_fastusers/rlm_fastusers.c
@@ -526,7 +526,7 @@ static int fastuser_instantiate(CONF_SECTION *conf, void **instance)
  *	for this user from the database. The main code only
  *	needs to check the password, the rest is done here.
  */
-static int fastuser_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t fastuser_authorize(void *instance, REQUEST *request)
 {
 
 	VALUE_PAIR	*namepair;
@@ -686,7 +686,7 @@ static int fastuser_authorize(void *instance, REQUEST *request)
 /*
  *	Authentication - unused.
  */
-static int fastuser_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t fastuser_authenticate(void *instance, REQUEST *request)
 {
 	instance = instance;
 	request = request;
@@ -700,7 +700,7 @@ static int fastuser_authenticate(void *instance, REQUEST *request)
  *
  *	This function is mostly a copy of file_authorize
  */
-static int fastuser_preacct(void *instance, REQUEST *request)
+static rlm_rcode_t fastuser_preacct(void *instance, REQUEST *request)
 {
 	VALUE_PAIR	*namepair;
 	const char	*name;
@@ -795,7 +795,7 @@ static int fastuser_detach(void *instance)
 /*
  *	This function is unused
  */
-static int fastuser_accounting(void *instance UNUSED, REQUEST *request UNUSED)
+static rlm_rcode_t fastuser_accounting(void *instance UNUSED, REQUEST *request UNUSED)
 {
 	/*
 	 * FIXME: should re rather return RLM_MODULE_NOOP here?
diff --git a/src/modules/rlm_files/rlm_files.c b/src/modules/rlm_files/rlm_files.c
index 0ef8867373a..fa00e6cd993 100644
--- a/src/modules/rlm_files/rlm_files.c
+++ b/src/modules/rlm_files/rlm_files.c
@@ -409,7 +409,7 @@ static int file_instantiate(CONF_SECTION *conf, void **instance)
 /*
  *	Common code called by everything below.
  */
-static int file_common(struct file_instance *inst, REQUEST *request,
+static rlm_rcode_t file_common(struct file_instance *inst, REQUEST *request,
 		       const char *filename, fr_hash_table_t *ht,
 		       VALUE_PAIR *request_pairs, VALUE_PAIR **reply_pairs)
 {
@@ -513,7 +513,7 @@ static int file_common(struct file_instance *inst, REQUEST *request,
  *	for this user from the database. The main code only
  *	needs to check the password, the rest is done here.
  */
-static int file_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t file_authorize(void *instance, REQUEST *request)
 {
 	struct file_instance *inst = instance;
 
@@ -527,7 +527,7 @@ static int file_authorize(void *instance, REQUEST *request)
  *	config_items. Reply items are Not Recommended(TM) in acct_users,
  *	except for Fallthrough, which should work
  */
-static int file_preacct(void *instance, REQUEST *request)
+static rlm_rcode_t file_preacct(void *instance, REQUEST *request)
 {
 	struct file_instance *inst = instance;
 
@@ -536,7 +536,7 @@ static int file_preacct(void *instance, REQUEST *request)
 }
 
 #ifdef WITH_PROXY
-static int file_preproxy(void *instance, REQUEST *request)
+static rlm_rcode_t file_preproxy(void *instance, REQUEST *request)
 {
 	struct file_instance *inst = instance;
 
@@ -545,7 +545,7 @@ static int file_preproxy(void *instance, REQUEST *request)
 			   request->packet->vps, &request->proxy->vps);
 }
 
-static int file_postproxy(void *instance, REQUEST *request)
+static rlm_rcode_t file_postproxy(void *instance, REQUEST *request)
 {
 	struct file_instance *inst = instance;
 
@@ -555,7 +555,7 @@ static int file_postproxy(void *instance, REQUEST *request)
 }
 #endif
 
-static int file_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t file_authenticate(void *instance, REQUEST *request)
 {
 	struct file_instance *inst = instance;
 
@@ -564,7 +564,7 @@ static int file_authenticate(void *instance, REQUEST *request)
 			   request->packet->vps, &request->reply->vps);
 }
 
-static int file_postauth(void *instance, REQUEST *request)
+static rlm_rcode_t file_postauth(void *instance, REQUEST *request)
 {
 	struct file_instance *inst = instance;
 
diff --git a/src/modules/rlm_ippool/rlm_ippool.c b/src/modules/rlm_ippool/rlm_ippool.c
index 10a308ab706..06b398257b3 100644
--- a/src/modules/rlm_ippool/rlm_ippool.c
+++ b/src/modules/rlm_ippool/rlm_ippool.c
@@ -310,7 +310,7 @@ static int ippool_instantiate(CONF_SECTION *conf, void **instance)
  *	Check for an Accounting-Stop
  *	If we find one and we have allocated an IP to this nas/port combination, deallocate it.
  */
-static int ippool_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t ippool_accounting(void *instance, REQUEST *request)
 {
 	rlm_ippool_t *data = (rlm_ippool_t *)instance;
 	datum key_datum;
@@ -434,7 +434,7 @@ static int ippool_accounting(void *instance, REQUEST *request)
 	return RLM_MODULE_OK;
 }
 
-static int ippool_postauth(void *instance, REQUEST *request)
+static rlm_rcode_t ippool_postauth(void *instance, REQUEST *request)
 {
 	rlm_ippool_t *data = (rlm_ippool_t *) instance;
 	int delete = 0;
diff --git a/src/modules/rlm_jradius/rlm_jradius.c b/src/modules/rlm_jradius/rlm_jradius.c
index bd31b218baa..61117eb5b97 100644
--- a/src/modules/rlm_jradius/rlm_jradius.c
+++ b/src/modules/rlm_jradius/rlm_jradius.c
@@ -926,7 +926,8 @@ static int read_request(JRADIUS *inst, JRSOCK *jrsock, REQUEST *p)
   return 0;
 }
 
-static int rlm_jradius_call(char func, void *instance, REQUEST *req, int isproxy)
+static rlm_rcode_t rlm_jradius_call(char func, void *instance, REQUEST *req,
+				    int isproxy)
 {
   JRADIUS        * inst    = instance;
   RADIUS_PACKET  * request = req->packet;
@@ -1054,52 +1055,52 @@ static int rlm_jradius_call(char func, void *instance, REQUEST *req, int isproxy
   return exitstatus;
 }
 
-static int jradius_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t jradius_authenticate(void *instance, REQUEST *request)
 {
   return rlm_jradius_call(JRADIUS_authenticate, instance, request, 0);
 }
 
-static int jradius_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t jradius_authorize(void *instance, REQUEST *request)
 {
   return rlm_jradius_call(JRADIUS_authorize, instance, request, 0);
 }
 
-static int jradius_preacct(void *instance, REQUEST *request)
+static rlm_rcode_t jradius_preacct(void *instance, REQUEST *request)
 {
   return rlm_jradius_call(JRADIUS_preacct, instance, request, 0);
 }
 
-static int jradius_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t jradius_accounting(void *instance, REQUEST *request)
 {
   return rlm_jradius_call(JRADIUS_accounting, instance, request, 0);
 }
 
-static int jradius_checksimul(void *instance, REQUEST *request)
+static rlm_rcode_t jradius_checksimul(void *instance, REQUEST *request)
 {
   return rlm_jradius_call(JRADIUS_checksimul, instance, request, 0);
 }
 
-static int jradius_pre_proxy(void *instance, REQUEST *request)
+static rlm_rcode_t jradius_pre_proxy(void *instance, REQUEST *request)
 {
   return rlm_jradius_call(JRADIUS_pre_proxy, instance, request, 1);
 }
 
-static int jradius_post_proxy(void *instance, REQUEST *request)
+static rlm_rcode_t jradius_post_proxy(void *instance, REQUEST *request)
 {
   return rlm_jradius_call(JRADIUS_post_proxy, instance, request, 1);
 }
 
-static int jradius_post_auth(void *instance, REQUEST *request)
+static rlm_rcode_t jradius_post_auth(void *instance, REQUEST *request)
 {
   return rlm_jradius_call(JRADIUS_post_auth, instance, request, 0);
 }
 
 #ifdef WITH_COA
-static int jradius_recv_coa(void *instance, REQUEST *request)
+static rlm_rcode_t jradius_recv_coa(void *instance, REQUEST *request)
 {
   return rlm_jradius_call(JRADIUS_recv_coa, instance, request, 0);
 }
-static int jradius_send_coa(void *instance, REQUEST *request)
+static rlm_rcode_t jradius_send_coa(void *instance, REQUEST *request)
 {
   return rlm_jradius_call(JRADIUS_send_coa, instance, request, 0);
 }
diff --git a/src/modules/rlm_krb5/rlm_krb5.c b/src/modules/rlm_krb5/rlm_krb5.c
index 42132624367..9617e5cf81d 100644
--- a/src/modules/rlm_krb5/rlm_krb5.c
+++ b/src/modules/rlm_krb5/rlm_krb5.c
@@ -79,8 +79,8 @@ static int krb5_build_auth_context(rlm_krb5_t *inst,
 	return 0;
 }
 
-static int verify_krb5_tgt(krb5_context context, rlm_krb5_t *inst,
-			   const char *user, krb5_ccache ccache)
+static rlm_rcode_t verify_krb5_tgt(krb5_context context, rlm_krb5_t *inst,
+			   	   const char *user, krb5_ccache ccache)
 {
 	int rcode;
 	int ret;
@@ -274,7 +274,7 @@ static int krb5_detach(void *instance)
  *  Validate userid/passwd (MIT)
  */
 #ifndef HEIMDAL_KRB5
-static int krb5_auth(void *instance, REQUEST *request)
+static rlm_rcode_t krb5_auth(void *instance, REQUEST *request)
 {
 	rlm_krb5_t *inst = instance;
 	int ret;
@@ -407,7 +407,7 @@ static int krb5_auth(void *instance, REQUEST *request)
 /*
  *  validate user/pass (Heimdal)
  */
-static int krb5_auth(void *instance, REQUEST *request)
+static rlm_rcode_t krb5_auth(void *instance, REQUEST *request)
 {
 	rlm_krb5_t *inst = instance;
 
diff --git a/src/modules/rlm_ldap/rlm_ldap.c b/src/modules/rlm_ldap/rlm_ldap.c
index e0462b5560a..b4e3559be8b 100644
--- a/src/modules/rlm_ldap/rlm_ldap.c
+++ b/src/modules/rlm_ldap/rlm_ldap.c
@@ -985,7 +985,8 @@ free_urldesc:
 }
 
 
-static char *get_userdn(LDAP_CONN **pconn, REQUEST *request, int *module_rcode)
+static char *get_userdn(LDAP_CONN **pconn, REQUEST *request,
+			rlm_rcode_t *module_rcode)
 {
 	int		rcode;
 	VALUE_PAIR	*vp;
@@ -1079,7 +1080,8 @@ static int ldap_groupcmp(void *instance, REQUEST *request,
 			 UNUSED VALUE_PAIR **reply_pairs)
 {
 	ldap_instance   *inst = instance;
-	int		i, rcode, found, module_rcode;
+	int		i, rcode, found;
+	rlm_rcode_t	module_rcode;
 	LDAPMessage     *result = NULL;
 	LDAPMessage     *entry = NULL;
 	int		ldap_errno;
@@ -1824,7 +1826,7 @@ free_result:
 /** Check if user is authorized for remote access
  *
  */
-static int ldap_authorize(void *instance, REQUEST * request)
+static rlm_rcode_t ldap_authorize(void *instance, REQUEST * request)
 {
 	int rcode;
 	int module_rcode = RLM_MODULE_OK;
@@ -2041,9 +2043,9 @@ free_socket:
 /** Check the user's password against ldap database
  *
  */
-static int ldap_authenticate(void *instance, REQUEST * request)
+static rlm_rcode_t ldap_authenticate(void *instance, REQUEST * request)
 {
-	int		module_rcode;
+	rlm_rcode_t	module_rcode;
 	const char	*user_dn;
 	ldap_instance	*inst = instance;
 	LDAP_CONN	*conn;
@@ -2117,10 +2119,10 @@ static int ldap_authenticate(void *instance, REQUEST * request)
 /** Modify user's object in LDAP
  *
  */
-static int user_modify(ldap_instance *inst, REQUEST *request,
-		       ldap_acct_section_t *section)
+static rlm_rcode_t user_modify(ldap_instance *inst, REQUEST *request,
+			       ldap_acct_section_t *section)
 {
-	int		module_rcode = RLM_MODULE_OK;
+	rlm_rcode_t	module_rcode = RLM_MODULE_OK;
 	int		ldap_errno, rcode, msg_id;
 	LDAPMessage	*result = NULL;
 	
@@ -2406,7 +2408,7 @@ static int user_modify(ldap_instance *inst, REQUEST *request,
 }
 
 
-static int ldap_accounting(void *instance, REQUEST * request) {
+static rlm_rcode_t ldap_accounting(void *instance, REQUEST * request) {
 	ldap_instance *inst = instance;		
 
 	if (inst->accounting) {
@@ -2420,7 +2422,7 @@ static int ldap_accounting(void *instance, REQUEST * request) {
 /** Check the user's password against ldap database
  *
  */
-static int ldap_postauth(void *instance, REQUEST * request)
+static rlm_rcode_t ldap_postauth(void *instance, REQUEST * request)
 {
 	ldap_instance	*inst = instance;
 
diff --git a/src/modules/rlm_linelog/rlm_linelog.c b/src/modules/rlm_linelog/rlm_linelog.c
index 111f770fa12..f802e43fc48 100644
--- a/src/modules/rlm_linelog/rlm_linelog.c
+++ b/src/modules/rlm_linelog/rlm_linelog.c
@@ -225,7 +225,7 @@ static size_t linelog_escape_func(UNUSED REQUEST *request,
 	return len;
 }
 
-static int do_linelog(void *instance, REQUEST *request)
+static rlm_rcode_t do_linelog(void *instance, REQUEST *request)
 {
 	int fd = -1;
 	char buffer[4096];
diff --git a/src/modules/rlm_logintime/rlm_logintime.c b/src/modules/rlm_logintime/rlm_logintime.c
index cbee046b960..2fdffaf10fe 100644
--- a/src/modules/rlm_logintime/rlm_logintime.c
+++ b/src/modules/rlm_logintime/rlm_logintime.c
@@ -158,7 +158,7 @@ static int time_of_day(void *instance,
 /*
  *      Check if account has expired, and if user may login now.
  */
-static int logintime_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t logintime_authorize(void *instance, REQUEST *request)
 {
 	rlm_logintime_t *data = (rlm_logintime_t *)instance;
 	VALUE_PAIR *check_item = NULL;
diff --git a/src/modules/rlm_mschap/rlm_mschap.c b/src/modules/rlm_mschap/rlm_mschap.c
index d6fc4ed5efa..7a403fd8920 100644
--- a/src/modules/rlm_mschap/rlm_mschap.c
+++ b/src/modules/rlm_mschap/rlm_mschap.c
@@ -1267,7 +1267,7 @@ static void mppe_chap2_gen_keys128(uint8_t *nt_hashhash,uint8_t *response,
  *	it later. Add Auth-Type attribute if present in module
  *	configuration (usually Auth-Type must be "MS-CHAP")
  */
-static int mschap_authorize(void * instance, REQUEST *request)
+static rlm_rcode_t mschap_authorize(void * instance, REQUEST *request)
 {
 #define inst ((rlm_mschap_t *)instance)
 	VALUE_PAIR *challenge = NULL;
@@ -1322,7 +1322,7 @@ static int mschap_authorize(void * instance, REQUEST *request)
  *	If MS-CHAP2 succeeds we MUST return
  *	PW_MSCHAP2_SUCCESS
  */
-static int mschap_authenticate(void * instance, REQUEST *request)
+static rlm_rcode_t mschap_authenticate(void * instance, REQUEST *request)
 {
 #define inst ((rlm_mschap_t *)instance)
 	VALUE_PAIR *challenge = NULL;
diff --git a/src/modules/rlm_opendirectory/rlm_opendirectory.c b/src/modules/rlm_opendirectory/rlm_opendirectory.c
index cbb2e3a8603..9c9c48599ad 100644
--- a/src/modules/rlm_opendirectory/rlm_opendirectory.c
+++ b/src/modules/rlm_opendirectory/rlm_opendirectory.c
@@ -268,7 +268,7 @@ static long od_check_passwd(const char *uname, const char *password)
  *	Check the users password against the standard UNIX
  *	password table.
  */
-static int od_authenticate(UNUSED void *instance, REQUEST *request)
+static rlm_rcode_t od_authenticate(UNUSED void *instance, REQUEST *request)
 {
 	char *name, *passwd;
 	int		ret;
@@ -331,7 +331,7 @@ static int od_authenticate(UNUSED void *instance, REQUEST *request)
 /*
  *	member of the radius group?
  */
-static int od_authorize(UNUSED void *instance, REQUEST *request)
+static rlm_rcode_t od_authorize(UNUSED void *instance, REQUEST *request)
 {
 	char *name = NULL;
 	struct passwd *userdata = NULL;
diff --git a/src/modules/rlm_otp/rlm_otp.c b/src/modules/rlm_otp/rlm_otp.c
index efb32937798..c9aa8dcb723 100644
--- a/src/modules/rlm_otp/rlm_otp.c
+++ b/src/modules/rlm_otp/rlm_otp.c
@@ -168,8 +168,7 @@ otp_instantiate(CONF_SECTION *conf, void **instance)
 
 
 /* Generate a challenge to be presented to the user. */
-static int
-otp_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t otp_authorize(void *instance, REQUEST *request)
 {
   otp_option_t *inst = (otp_option_t *) instance;
 
@@ -276,8 +275,7 @@ otp_authorize(void *instance, REQUEST *request)
 
 
 /* Verify the response entered by the user. */
-static int
-otp_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t otp_authenticate(void *instance, REQUEST *request)
 {
   otp_option_t *inst = (otp_option_t *) instance;
 
diff --git a/src/modules/rlm_pam/rlm_pam.c b/src/modules/rlm_pam/rlm_pam.c
index c126c41a10d..db3078c6a3d 100644
--- a/src/modules/rlm_pam/rlm_pam.c
+++ b/src/modules/rlm_pam/rlm_pam.c
@@ -227,7 +227,7 @@ static int pam_pass(const char *name, const char *passwd, const char *pamauth)
 }
 
 /* translate between function declarations */
-static int pam_auth(void *instance, REQUEST *request)
+static rlm_rcode_t pam_auth(void *instance, REQUEST *request)
 {
 	int	r;
 	VALUE_PAIR *pair;
diff --git a/src/modules/rlm_pap/rlm_pap.c b/src/modules/rlm_pap/rlm_pap.c
index fb46d0ec2fd..5c970615c37 100644
--- a/src/modules/rlm_pap/rlm_pap.c
+++ b/src/modules/rlm_pap/rlm_pap.c
@@ -248,7 +248,7 @@ static void normify(REQUEST *request, VALUE_PAIR *vp, size_t min_length)
  *	This isn't strictly necessary, but it does make the
  *	server simpler to configure.
  */
-static int pap_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t pap_authorize(void *instance, REQUEST *request)
 {
 	rlm_pap_t *inst = instance;
 	int auth_type = FALSE;
@@ -452,12 +452,12 @@ static int pap_authorize(void *instance, REQUEST *request)
 /*
  *	Authenticate the user via one of any well-known password.
  */
-static int pap_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t pap_authenticate(void *instance, REQUEST *request)
 {
 	VALUE_PAIR *vp;
 	VALUE_PAIR *module_fmsg_vp;
 	char module_fmsg[MAX_STRING_LEN];
-	int rc = RLM_MODULE_INVALID;
+	rlm_rcode_t rc = RLM_MODULE_INVALID;
 	int (*auth_func)(REQUEST *, VALUE_PAIR *, char *) = NULL;
 
 	/* Shut the compiler up */
diff --git a/src/modules/rlm_passwd/rlm_passwd.c b/src/modules/rlm_passwd/rlm_passwd.c
index d61df930231..4a4d93b515d 100644
--- a/src/modules/rlm_passwd/rlm_passwd.c
+++ b/src/modules/rlm_passwd/rlm_passwd.c
@@ -527,7 +527,7 @@ static void addresult (struct passwd_instance * inst, REQUEST *request, VALUE_PA
 	}
 }
 
-static int passwd_map(void *instance, REQUEST *request)
+static rlm_rcode_t passwd_map(void *instance, REQUEST *request)
 {
 #define inst ((struct passwd_instance *)instance)
 	char buffer[1024];
diff --git a/src/modules/rlm_perl/rlm_perl.c b/src/modules/rlm_perl/rlm_perl.c
index 2520c3c06e6..3bb8461d7c0 100644
--- a/src/modules/rlm_perl/rlm_perl.c
+++ b/src/modules/rlm_perl/rlm_perl.c
@@ -848,7 +848,7 @@ static int rlmperl_call(void *instance, REQUEST *request, char *function_name)
  *	from the database. The authentication code only needs to check
  *	the password, the rest is done here.
  */
-static int perl_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t perl_authorize(void *instance, REQUEST *request)
 {
 	return rlmperl_call(instance, request,
 			    ((PERL_INST *)instance)->func_authorize);
@@ -857,7 +857,7 @@ static int perl_authorize(void *instance, REQUEST *request)
 /*
  *	Authenticate the user with the given password.
  */
-static int perl_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t perl_authenticate(void *instance, REQUEST *request)
 {
 	return rlmperl_call(instance, request,
 			    ((PERL_INST *)instance)->func_authenticate);
@@ -865,7 +865,7 @@ static int perl_authenticate(void *instance, REQUEST *request)
 /*
  *	Massage the request before recording it or proxying it
  */
-static int perl_preacct(void *instance, REQUEST *request)
+static rlm_rcode_t perl_preacct(void *instance, REQUEST *request)
 {
 	return rlmperl_call(instance, request,
 			    ((PERL_INST *)instance)->func_preacct);
@@ -873,7 +873,7 @@ static int perl_preacct(void *instance, REQUEST *request)
 /*
  *	Write accounting information to this modules database.
  */
-static int perl_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t perl_accounting(void *instance, REQUEST *request)
 {
 	VALUE_PAIR	*pair;
 	int 		acctstatustype=0;
@@ -917,7 +917,7 @@ static int perl_accounting(void *instance, REQUEST *request)
 /*
  *	Check for simultaneouse-use
  */
-static int perl_checksimul(void *instance, REQUEST *request)
+static rlm_rcode_t perl_checksimul(void *instance, REQUEST *request)
 {
 	return rlmperl_call(instance, request,
 			((PERL_INST *)instance)->func_checksimul);
@@ -927,7 +927,7 @@ static int perl_checksimul(void *instance, REQUEST *request)
 /*
  *	Pre-Proxy request
  */
-static int perl_pre_proxy(void *instance, REQUEST *request)
+static rlm_rcode_t perl_pre_proxy(void *instance, REQUEST *request)
 {
 	return rlmperl_call(instance, request,
 			((PERL_INST *)instance)->func_pre_proxy);
@@ -935,7 +935,7 @@ static int perl_pre_proxy(void *instance, REQUEST *request)
 /*
  *	Post-Proxy request
  */
-static int perl_post_proxy(void *instance, REQUEST *request)
+static rlm_rcode_t perl_post_proxy(void *instance, REQUEST *request)
 {
 	return rlmperl_call(instance, request,
 			((PERL_INST *)instance)->func_post_proxy);
@@ -945,7 +945,7 @@ static int perl_post_proxy(void *instance, REQUEST *request)
 /*
  *	Pre-Auth request
  */
-static int perl_post_auth(void *instance, REQUEST *request)
+static rlm_rcode_t perl_post_auth(void *instance, REQUEST *request)
 {
 	return rlmperl_call(instance, request,
 			((PERL_INST *)instance)->func_post_auth);
@@ -954,7 +954,7 @@ static int perl_post_auth(void *instance, REQUEST *request)
 /*
  *	Recv CoA request
  */
-static int perl_recv_coa(void *instance, REQUEST *request)
+static rlm_rcode_t perl_recv_coa(void *instance, REQUEST *request)
 {
 	return rlmperl_call(instance, request,
 			((PERL_INST *)instance)->func_recv_coa);
@@ -962,7 +962,7 @@ static int perl_recv_coa(void *instance, REQUEST *request)
 /*
  *	Send CoA request
  */
-static int perl_send_coa(void *instance, REQUEST *request)
+static rlm_rcode_t perl_send_coa(void *instance, REQUEST *request)
 {
 	return rlmperl_call(instance, request,
 			((PERL_INST *)instance)->func_send_coa);
diff --git a/src/modules/rlm_policy/rlm_policy.c b/src/modules/rlm_policy/rlm_policy.c
index f092ad18a20..1e9019721a9 100644
--- a/src/modules/rlm_policy/rlm_policy.c
+++ b/src/modules/rlm_policy/rlm_policy.c
@@ -154,50 +154,50 @@ policy_named_t *rlm_policy_find(rbtree_t *head, const char *name)
  *	from the database. The authentication code only needs to check
  *	the password, the rest is done here.
  */
-static int policy_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t policy_authorize(void *instance, REQUEST *request)
 {
 	return rlm_policy_evaluate((rlm_policy_t *) instance, request,
 				   "authorize");
 }
 
 
-static int policy_preacct(void *instance, REQUEST *request)
+static rlm_rcode_t policy_preacct(void *instance, REQUEST *request)
 {
 	return rlm_policy_evaluate((rlm_policy_t *) instance, request,
 				   "preacct");
 }
 
-static int policy_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t policy_accounting(void *instance, REQUEST *request)
 {
 	return rlm_policy_evaluate((rlm_policy_t *) instance, request,
 				   "accounting");
 }
 
-static int policy_post_auth(void *instance, REQUEST *request)
+static rlm_rcode_t policy_post_auth(void *instance, REQUEST *request)
 {
 	return rlm_policy_evaluate((rlm_policy_t *) instance, request,
 				   "post-auth");
 }
 
-static int policy_pre_proxy(void *instance, REQUEST *request)
+static rlm_rcode_t policy_pre_proxy(void *instance, REQUEST *request)
 {
 	return rlm_policy_evaluate((rlm_policy_t *) instance, request,
 				   "pre-proxy");
 }
 
-static int policy_post_proxy(void *instance, REQUEST *request)
+static rlm_rcode_t policy_post_proxy(void *instance, REQUEST *request)
 {
 	return rlm_policy_evaluate((rlm_policy_t *) instance, request,
 				   "post-proxy");
 }
 
 #ifdef WITH_COA
-static int policy_recv_coa(void *instance, REQUEST *request)
+static rlm_rcode_t policy_recv_coa(void *instance, REQUEST *request)
 {
 	return rlm_policy_evaluate((rlm_policy_t *) instance, request,
 				   "recv-coa");
 }
-static int policy_send_coa(void *instance, REQUEST *request)
+static rlm_rcode_t policy_send_coa(void *instance, REQUEST *request)
 {
 	return rlm_policy_evaluate((rlm_policy_t *) instance, request,
 				   "send-coa");
diff --git a/src/modules/rlm_preprocess/rlm_preprocess.c b/src/modules/rlm_preprocess/rlm_preprocess.c
index a3e3a90cb1d..f9180c42518 100644
--- a/src/modules/rlm_preprocess/rlm_preprocess.c
+++ b/src/modules/rlm_preprocess/rlm_preprocess.c
@@ -589,7 +589,7 @@ static int preprocess_instantiate(CONF_SECTION *conf, void **instance)
 /*
  *	Preprocess a request.
  */
-static int preprocess_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t preprocess_authorize(void *instance, REQUEST *request)
 {
 	int r;
 	rlm_preprocess_t *data = (rlm_preprocess_t *) instance;
@@ -676,7 +676,7 @@ static int preprocess_authorize(void *instance, REQUEST *request)
 /*
  *	Preprocess a request before accounting
  */
-static int preprocess_preaccounting(void *instance, REQUEST *request)
+static rlm_rcode_t preprocess_preaccounting(void *instance, REQUEST *request)
 {
 	int r;
 	VALUE_PAIR *vp;
diff --git a/src/modules/rlm_python/rlm_python.c b/src/modules/rlm_python/rlm_python.c
index adaf653e05e..dcdad51ed25 100644
--- a/src/modules/rlm_python/rlm_python.c
+++ b/src/modules/rlm_python/rlm_python.c
@@ -654,7 +654,7 @@ static int python_detach(void *instance)
 	return ret;
 }
 
-#define A(x) static int python_##x(void *instance, REQUEST *request) { \
+#define A(x) static rlm_rcode_t python_##x(void *instance, REQUEST *request) { \
   return python_function(request, ((struct rlm_python_t *)instance)->x.function, #x); \
 }
 
diff --git a/src/modules/rlm_radutmp/rlm_radutmp.c b/src/modules/rlm_radutmp/rlm_radutmp.c
index 65fe9212827..59dafb01a65 100644
--- a/src/modules/rlm_radutmp/rlm_radutmp.c
+++ b/src/modules/rlm_radutmp/rlm_radutmp.c
@@ -179,7 +179,7 @@ static NAS_PORT *nas_port_find(NAS_PORT *nas_port_list, uint32_t nasaddr, unsign
 /*
  *	Store logins in the RADIUS utmp file.
  */
-static int radutmp_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t radutmp_accounting(void *instance, REQUEST *request)
 {
 	struct radutmp	ut, u;
 	VALUE_PAIR	*vp;
@@ -559,7 +559,7 @@ static int radutmp_accounting(void *instance, REQUEST *request)
  *	max. number of logins, do a second pass and validate all
  *	logins by querying the terminal server (using eg. SNMP).
  */
-static int radutmp_checksimul(void *instance, REQUEST *request)
+static rlm_rcode_t radutmp_checksimul(void *instance, REQUEST *request)
 {
 	struct radutmp	u;
 	int		fd;
diff --git a/src/modules/rlm_radutmp/rlm_radutmp2.c b/src/modules/rlm_radutmp/rlm_radutmp2.c
index 8ab0f98bc57..9ee24b7dba1 100644
--- a/src/modules/rlm_radutmp/rlm_radutmp2.c
+++ b/src/modules/rlm_radutmp/rlm_radutmp2.c
@@ -708,7 +708,7 @@ static int cache_file(rlm_radutmp_t *inst, radutmp_cache_t *cache)
 /*
  *	Store logins in the RADIUS utmp file.
  */
-static int radutmp_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t radutmp_accounting(void *instance, REQUEST *request)
 {
 	rlm_radutmp_t	*inst = instance;
 	struct radutmp	utmp, u;
@@ -1292,7 +1292,7 @@ static int radutmp_accounting(void *instance, REQUEST *request)
  *	max. number of logins, do a second pass and validate all
  *	logins by querying the terminal server (using eg. SNMP).
  */
-static int radutmp_checksimul(void *instance, REQUEST *request)
+static rlm_rcode_t radutmp_checksimul(void *instance, REQUEST *request)
 {
 	struct radutmp	u;
 	int		fd;
diff --git a/src/modules/rlm_realm/rlm_realm.c b/src/modules/rlm_realm/rlm_realm.c
index 3b68bb994db..6bda294be66 100644
--- a/src/modules/rlm_realm/rlm_realm.c
+++ b/src/modules/rlm_realm/rlm_realm.c
@@ -400,9 +400,9 @@ static int realm_instantiate(CONF_SECTION *conf, void **instance)
  *
  *  This should very nearly duplicate the old proxy_send() code
  */
-static int realm_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t realm_authorize(void *instance, REQUEST *request)
 {
-	int rcode;
+	rlm_rcode_t rcode;
 	REALM *realm;
 
 	/*
@@ -428,7 +428,7 @@ static int realm_authorize(void *instance, REQUEST *request)
  * This does the exact same thing as the realm_authorize, it's just called
  * differently.
  */
-static int realm_preacct(void *instance, REQUEST *request)
+static rlm_rcode_t realm_preacct(void *instance, REQUEST *request)
 {
 	int rcode;
 	const char *name = (char *)request->username->vp_strvalue;
@@ -462,7 +462,7 @@ static int realm_preacct(void *instance, REQUEST *request)
  *	CoA realms via Operator-Name.  Because the realm isn't in a
  *	User-Name, concepts like "prefix" and "suffix' don't matter.
  */
-static int realm_coa(UNUSED void *instance, REQUEST *request)
+static rlm_rcode_t realm_coa(UNUSED void *instance, REQUEST *request)
 {
 	VALUE_PAIR *vp;
 	REALM *realm;
@@ -524,7 +524,7 @@ module_t rlm_realm = {
 	{
 		NULL,			/* authentication */
 		realm_authorize,	/* authorization */
-		realm_preacct,	/* preaccounting */
+		realm_preacct,		/* preaccounting */
 		NULL,			/* accounting */
 		NULL,			/* checksimul */
 		NULL,			/* pre-proxy */
diff --git a/src/modules/rlm_rediswho/rlm_rediswho.c b/src/modules/rlm_rediswho/rlm_rediswho.c
index a37593fe8a6..45c543f03e5 100644
--- a/src/modules/rlm_rediswho/rlm_rediswho.c
+++ b/src/modules/rlm_rediswho/rlm_rediswho.c
@@ -199,9 +199,9 @@ static int rediswho_accounting_all(REDISSOCK **dissocket_p,
 	return RLM_MODULE_OK;
 }
 
-static int rediswho_accounting(void * instance, REQUEST * request)
+static rlm_rcode_t rediswho_accounting(void * instance, REQUEST * request)
 {
-	int rcode;
+	rlm_rcode_t rcode;
 	VALUE_PAIR * vp;
 	DICT_VALUE *dv;
 	CONF_SECTION *cs;
diff --git a/src/modules/rlm_replicate/rlm_replicate.c b/src/modules/rlm_replicate/rlm_replicate.c
index cd139574ae7..a6c4feab694 100644
--- a/src/modules/rlm_replicate/rlm_replicate.c
+++ b/src/modules/rlm_replicate/rlm_replicate.c
@@ -222,7 +222,7 @@ static int replicate_packet(void *instance, REQUEST *request,
 	return rcode;
 }
 #else
-static int replicate_packet(void *instance, REQUEST *request,
+static rlm_rcode_t replicate_packet(void *instance, REQUEST *request,
 			    pair_lists_t list, unsigned int code)
 {
 	RDEBUG("Replication is unsupported in this build.");
@@ -230,43 +230,43 @@ static int replicate_packet(void *instance, REQUEST *request,
 }
 #endif
 
-static int replicate_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t replicate_authorize(void *instance, REQUEST *request)
 {
 	return replicate_packet(instance, request, PAIR_LIST_REQUEST,
 				request->packet->code);
 }
 
-static int replicate_preaccounting(void *instance, REQUEST *request)
+static rlm_rcode_t replicate_preaccounting(void *instance, REQUEST *request)
 {
 	return replicate_packet(instance, request, PAIR_LIST_REQUEST,
 				request->packet->code);
 }
 
-static int replicate_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t replicate_accounting(void *instance, REQUEST *request)
 {
 	return replicate_packet(instance, request, PAIR_LIST_REPLY,
 				request->reply->code);
 }
 
-static int replicate_preproxy(void *instance, REQUEST *request)
+static rlm_rcode_t replicate_preproxy(void *instance, REQUEST *request)
 {
 	return replicate_packet(instance, request, PAIR_LIST_PROXY_REQUEST,
 				request->proxy->code);
 }
 
-static int replicate_postproxy(void *instance, REQUEST *request)
+static rlm_rcode_t replicate_postproxy(void *instance, REQUEST *request)
 {
 	return replicate_packet(instance, request, PAIR_LIST_PROXY_REPLY,
 				request->proxy_reply->code);
 }
 
-static int replicate_postauth(void *instance, REQUEST *request)
+static rlm_rcode_t replicate_postauth(void *instance, REQUEST *request)
 {
 	return replicate_packet(instance, request, PAIR_LIST_REPLY,
 				request->reply->code);
 }
 
-static int replicate_coarequest(void *instance, REQUEST *request)
+static rlm_rcode_t replicate_coarequest(void *instance, REQUEST *request)
 {
 	return replicate_packet(instance, request, PAIR_LIST_REQUEST,
 				request->packet->code);
diff --git a/src/modules/rlm_rest/rlm_rest.c b/src/modules/rlm_rest/rlm_rest.c
index 4765f2fc51d..13c37ddc17e 100644
--- a/src/modules/rlm_rest/rlm_rest.c
+++ b/src/modules/rlm_rest/rlm_rest.c
@@ -294,7 +294,7 @@ static int rlm_rest_instantiate(CONF_SECTION *conf, void **instance)
  *	from the database. The authentication code only needs to check
  *	the password, the rest is done here.
  */
-static int rlm_rest_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t rlm_rest_authorize(void *instance, REQUEST *request)
 {
 	rlm_rest_t *my_instance = instance;
 	rlm_rest_section_t *section = &my_instance->authorize;
@@ -369,7 +369,7 @@ static int rlm_rest_authorize(void *instance, REQUEST *request)
 /*
  *	Authenticate the user with the given password.
  */
-static int rlm_rest_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t rlm_rest_authenticate(void *instance, REQUEST *request)
 {
 	/* quiet the compiler */
 	instance = instance;
@@ -381,12 +381,9 @@ static int rlm_rest_authenticate(void *instance, REQUEST *request)
 /*
  *	Write accounting information to this modules database.
  */
-static int rlm_rest_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t rlm_rest_accounting(UNUSED void *instance,
+				       UNUSED REQUEST *request)
 {
-	/* quiet the compiler */
-	instance = instance;
-	request = request;
-
 	return RLM_MODULE_OK;
 }
 
@@ -400,7 +397,7 @@ static int rlm_rest_accounting(void *instance, REQUEST *request)
  *	max. number of logins, do a second pass and validate all
  *	logins by querying the terminal server (using eg. SNMP).
  */
-static int rlm_rest_checksimul(void *instance, REQUEST *request)
+static rlm_rcode_t rlm_rest_checksimul(void *instance, REQUEST *request)
 {
 	instance = instance;
 
diff --git a/src/modules/rlm_ruby/rlm_ruby.c b/src/modules/rlm_ruby/rlm_ruby.c
index 2ef68b94323..3a0bb2b4208 100644
--- a/src/modules/rlm_ruby/rlm_ruby.c
+++ b/src/modules/rlm_ruby/rlm_ruby.c
@@ -412,7 +412,7 @@ static int ruby_instantiate(CONF_SECTION *conf, void **instance) {
     return ruby_function(NULL, data->func_instantiate, data->pModule_builtin, "instantiate");
 }
 
-#define RLM_RUBY_FUNC(foo) static int ruby_##foo(void *instance, REQUEST *request) \
+#define RLM_RUBY_FUNC(foo) static rlm_rcode_t ruby_##foo(void *instance, REQUEST *request) \
 { \
     return ruby_function(request, \
 			   ((struct rlm_ruby_t *)instance)->func_##foo,((struct rlm_ruby_t *)instance)->pModule_builtin, \
diff --git a/src/modules/rlm_securid/rlm_securid.c b/src/modules/rlm_securid/rlm_securid.c
index 2afccdf8c68..5b930a0c3df 100644
--- a/src/modules/rlm_securid/rlm_securid.c
+++ b/src/modules/rlm_securid/rlm_securid.c
@@ -433,7 +433,7 @@ static int securid_detach(void *instance)
 }
 
 
-static int securid_instantiate(CONF_SECTION *conf, void **instance)
+static rlm_rcode_t securid_instantiate(CONF_SECTION *conf, void **instance)
 {
 	rlm_securid_t *inst;
 
diff --git a/src/modules/rlm_sim_files/rlm_sim_files.c b/src/modules/rlm_sim_files/rlm_sim_files.c
index 4999092575a..cc2826c4190 100644
--- a/src/modules/rlm_sim_files/rlm_sim_files.c
+++ b/src/modules/rlm_sim_files/rlm_sim_files.c
@@ -109,7 +109,7 @@ static int sim_file_instantiate(CONF_SECTION *conf, void **instance)
  *	for this user from the database. The main code only
  *	needs to check the password, the rest is done here.
  */
-static int sim_file_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t sim_file_authorize(void *instance, REQUEST *request)
 {
 	VALUE_PAIR	*namepair;
 	VALUE_PAIR	*reply_tmp;
diff --git a/src/modules/rlm_smsotp/rlm_smsotp.c b/src/modules/rlm_smsotp/rlm_smsotp.c
index b4c62036e6d..c0955eead5e 100644
--- a/src/modules/rlm_smsotp/rlm_smsotp.c
+++ b/src/modules/rlm_smsotp/rlm_smsotp.c
@@ -98,7 +98,7 @@ static int smsotp_instantiate(CONF_SECTION *conf, void **instance)
 /*
  *	Authenticate the user with the given password.
  */
-static int smsotp_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t smsotp_authenticate(void *instance, REQUEST *request)
 {
 	VALUE_PAIR *state;
 	VALUE_PAIR *reply;
@@ -204,7 +204,7 @@ static int smsotp_authenticate(void *instance, REQUEST *request)
  *	from the database. The authentication code only needs to check
  *	the password, the rest is done here.
  */
-static int smsotp_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t smsotp_authorize(void *instance, REQUEST *request)
 {
 	VALUE_PAIR *state;
 	rlm_smsotp_t *opt = instance;
diff --git a/src/modules/rlm_soh/rlm_soh.c b/src/modules/rlm_soh/rlm_soh.c
index ced4cd2a3cd..4140fd66566 100644
--- a/src/modules/rlm_soh/rlm_soh.c
+++ b/src/modules/rlm_soh/rlm_soh.c
@@ -138,7 +138,7 @@ static int soh_instantiate(CONF_SECTION *conf, void **instance) {
 	return 0;
 }
 
-static int soh_postauth(UNUSED void * instance, REQUEST *request)
+static rlm_rcode_t soh_postauth(UNUSED void * instance, REQUEST *request)
 {
 #ifdef WITH_DHCP
 	int rcode;
@@ -196,7 +196,7 @@ static int soh_postauth(UNUSED void * instance, REQUEST *request)
 	return RLM_MODULE_NOOP;
 }
 
-static int soh_authorize(UNUSED void * instance, REQUEST *request)
+static rlm_rcode_t soh_authorize(UNUSED void * instance, REQUEST *request)
 {
 	VALUE_PAIR *vp;
 	int rv;
diff --git a/src/modules/rlm_sometimes/rlm_sometimes.c b/src/modules/rlm_sometimes/rlm_sometimes.c
index 2622b926f36..dd945018827 100644
--- a/src/modules/rlm_sometimes/rlm_sometimes.c
+++ b/src/modules/rlm_sometimes/rlm_sometimes.c
@@ -146,8 +146,8 @@ static int sometimes_instantiate(CONF_SECTION *conf, void **instance)
 /*
  *	A lie!  It always returns!
  */
-static int sometimes_return(void *instance, RADIUS_PACKET *packet,
-			    RADIUS_PACKET *reply)
+static rlm_rcode_t sometimes_return(void *instance, RADIUS_PACKET *packet,
+				    RADIUS_PACKET *reply)
 {
 	uint32_t hash;
 	int value;
@@ -207,24 +207,24 @@ static int sometimes_return(void *instance, RADIUS_PACKET *packet,
 	return inst->rcode;
 }
 
-static int sometimes_packet(void *instance, REQUEST *request)
+static rlm_rcode_t sometimes_packet(void *instance, REQUEST *request)
 {
 	return sometimes_return(instance, request->packet, request->reply);
 }
 
-static int sometimes_reply(void *instance, REQUEST *request)
+static rlm_rcode_t sometimes_reply(void *instance, REQUEST *request)
 {
 	return sometimes_return(instance, request->reply, NULL);
 }
 
-static int sometimes_pre_proxy(void *instance, REQUEST *request)
+static rlm_rcode_t sometimes_pre_proxy(void *instance, REQUEST *request)
 {
 	if (!request->proxy) return RLM_MODULE_NOOP;
 
 	return sometimes_return(instance, request->proxy, request->proxy_reply);
 }
 
-static int sometimes_post_proxy(void *instance, REQUEST *request)
+static rlm_rcode_t sometimes_post_proxy(void *instance, REQUEST *request)
 {
 	if (!request->proxy_reply) return RLM_MODULE_NOOP;
 
diff --git a/src/modules/rlm_sql/rlm_sql.c b/src/modules/rlm_sql/rlm_sql.c
index a3d45cbb788..3a59151d0f0 100644
--- a/src/modules/rlm_sql/rlm_sql.c
+++ b/src/modules/rlm_sql/rlm_sql.c
@@ -1002,7 +1002,7 @@ static int rlm_sql_instantiate(CONF_SECTION * conf, void **instance)
 }
 
 
-static int rlm_sql_authorize(void *instance, REQUEST * request)
+static rlm_rcode_t rlm_sql_authorize(void *instance, REQUEST * request)
 {
 	int ret = RLM_MODULE_NOTFOUND;
 	
@@ -1315,7 +1315,7 @@ static int acct_redundant(SQL_INST *inst, REQUEST *request,
 /*
  *	Accounting: Insert or update session data in our sql table
  */
-static int rlm_sql_accounting(void *instance, REQUEST * request) {
+static rlm_rcode_t rlm_sql_accounting(void *instance, REQUEST * request) {
 	SQL_INST *inst = instance;		
 
 	if (inst->config->accounting) {
@@ -1337,7 +1337,7 @@ static int rlm_sql_accounting(void *instance, REQUEST * request) {
  *        logins by querying the terminal server (using eg. SNMP).
  */
 
-static int rlm_sql_checksimul(void *instance, REQUEST * request) {
+static rlm_rcode_t rlm_sql_checksimul(void *instance, REQUEST * request) {
 	SQLSOCK 	*sqlsocket;
 	SQL_INST	*inst = instance;
 	SQL_ROW		row;
@@ -1516,7 +1516,7 @@ static int rlm_sql_checksimul(void *instance, REQUEST * request) {
 /*
  *	Postauth: Write a record of the authentication attempt
  */
-static int rlm_sql_postauth(void *instance, REQUEST * request) {
+static rlm_rcode_t rlm_sql_postauth(void *instance, REQUEST * request) {
 	SQL_INST *inst = instance;
 	
 	if (inst->config->postauth) {
diff --git a/src/modules/rlm_sqlcounter/rlm_sqlcounter.c b/src/modules/rlm_sqlcounter/rlm_sqlcounter.c
index 053b4f504d8..683c2d67141 100644
--- a/src/modules/rlm_sqlcounter/rlm_sqlcounter.c
+++ b/src/modules/rlm_sqlcounter/rlm_sqlcounter.c
@@ -515,10 +515,10 @@ static int sqlcounter_instantiate(CONF_SECTION *conf, void **instance)
  *	from the database. The authentication code only needs to check
  *	the password, the rest is done here.
  */
-static int sqlcounter_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t sqlcounter_authorize(void *instance, REQUEST *request)
 {
 	rlm_sqlcounter_t *data = (rlm_sqlcounter_t *) instance;
-	int ret=RLM_MODULE_NOOP;
+	int rcode = RLM_MODULE_NOOP;
 	unsigned int counter;
 	DICT_ATTR *dattr;
 	VALUE_PAIR *key_vp, *check_vp;
@@ -553,19 +553,19 @@ static int sqlcounter_authorize(void *instance, REQUEST *request)
 	key_vp = ((data->key_attr->vendor == 0) && (data->key_attr->attr == PW_USER_NAME)) ? request->username : pairfind(request->packet->vps, data->key_attr->attr, data->key_attr->vendor, TAG_ANY);
 	if (key_vp == NULL) {
 		DEBUG2("rlm_sqlcounter: Could not find Key value pair");
-		return ret;
+		return rcode;
 	}
 
 	/*
 	 *      Look for the check item
 	 */
 	if ((dattr = dict_attrbyname(data->check_name)) == NULL) {
-		return ret;
+		return rcode;
 	}
 	/* DEBUG2("rlm_sqlcounter: Found Check item attribute %d", dattr->attr); */
 	if ((check_vp= pairfind(request->config_items, dattr->attr, dattr->vendor, TAG_ANY)) == NULL) {
 		DEBUG2("rlm_sqlcounter: Could not find Check item value pair");
-		return ret;
+		return rcode;
 	}
 
 	/* first, expand %k, %b and %e in query */
@@ -627,7 +627,7 @@ static int sqlcounter_authorize(void *instance, REQUEST *request)
 			reply_item->vp_integer = res;
 		}
 
-		ret=RLM_MODULE_OK;
+		rcode = RLM_MODULE_OK;
 
 		DEBUG2("rlm_sqlcounter: Authorized user %s, check_item=%u, counter=%u",
 				key_vp->vp_strvalue,check_vp->vp_integer,counter);
@@ -651,13 +651,13 @@ static int sqlcounter_authorize(void *instance, REQUEST *request)
 		module_fmsg_vp = pairmake("Module-Failure-Message", module_fmsg, T_OP_EQ);
 		pairadd(&request->packet->vps, module_fmsg_vp);
 
-		ret=RLM_MODULE_REJECT;
+		rcode = RLM_MODULE_REJECT;
 
 		DEBUG2("rlm_sqlcounter: Rejected user %s, check_item=%u, counter=%u",
 				key_vp->vp_strvalue,check_vp->vp_integer,counter);
 	}
 
-	return ret;
+	return rcode;
 }
 
 static int sqlcounter_detach(void *instance)
diff --git a/src/modules/rlm_sqlhpwippool/rlm_sqlhpwippool.c b/src/modules/rlm_sqlhpwippool/rlm_sqlhpwippool.c
index 682b804cffe..170ecf340ca 100644
--- a/src/modules/rlm_sqlhpwippool/rlm_sqlhpwippool.c
+++ b/src/modules/rlm_sqlhpwippool/rlm_sqlhpwippool.c
@@ -348,7 +348,7 @@ static int sqlhpwippool_instantiate(CONF_SECTION *conf, void **instance)
 }
 
 /* assign new IP address, if required */
-static int sqlhpwippool_postauth(void *instance, REQUEST *request)
+static rlm_rcode_t sqlhpwippool_postauth(void *instance, REQUEST *request)
 {
 	VALUE_PAIR *vp;
 	char *pname;       /* name of requested IP pool */
@@ -667,7 +667,7 @@ end_gid:
 	return RLM_MODULE_OK;
 }
 
-static int sqlhpwippool_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t sqlhpwippool_accounting(void *instance, REQUEST *request)
 {
 	VALUE_PAIR *vp;
 	SQLSOCK *sqlsock;
diff --git a/src/modules/rlm_sqlippool/rlm_sqlippool.c b/src/modules/rlm_sqlippool/rlm_sqlippool.c
index 5529a7a6f72..c7479a441d4 100644
--- a/src/modules/rlm_sqlippool/rlm_sqlippool.c
+++ b/src/modules/rlm_sqlippool/rlm_sqlippool.c
@@ -529,7 +529,7 @@ static int do_logging(char *str, int retcode)
 /*
  *	Allocate an IP number from the pool.
  */
-static int sqlippool_postauth(void *instance, REQUEST * request)
+static rlm_rcode_t sqlippool_postauth(void *instance, REQUEST * request)
 {
 	rlm_sqlippool_t * data = (rlm_sqlippool_t *) instance;
 	char allocation[MAX_STRING_LEN];
@@ -823,7 +823,7 @@ static int sqlippool_accounting_off(SQLSOCK * sqlsocket,
  *	If we find one and we have allocated an IP to this nas/port
  *	combination, then deallocate it.
  */
-static int sqlippool_accounting(void * instance, REQUEST * request)
+static rlm_rcode_t sqlippool_accounting(void * instance, REQUEST * request)
 {
 	int rcode;
 	VALUE_PAIR * vp;
diff --git a/src/modules/rlm_unix/rlm_unix.c b/src/modules/rlm_unix/rlm_unix.c
index 4ae163446f5..ca832b3c59e 100644
--- a/src/modules/rlm_unix/rlm_unix.c
+++ b/src/modules/rlm_unix/rlm_unix.c
@@ -320,7 +320,7 @@ static int unix_getpw(UNUSED void *instance, REQUEST *request,
  *	Pull the users password from where-ever, and add it to
  *	the given vp list.
  */
-static int unix_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t unix_authorize(void *instance, REQUEST *request)
 {
 	return unix_getpw(instance, request, &request->config_items);
 }
@@ -329,7 +329,7 @@ static int unix_authorize(void *instance, REQUEST *request)
  *	Pull the users password from where-ever, and add it to
  *	the given vp list.
  */
-static int unix_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t unix_authenticate(void *instance, REQUEST *request)
 {
 #ifdef OSFSIA
 	char		*info[2];
@@ -410,7 +410,7 @@ static char *uue(void *in)
 /*
  *	Unix accounting - write a wtmp file.
  */
-static int unix_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t unix_accounting(void *instance, REQUEST *request)
 {
 	VALUE_PAIR	*vp;
 	FILE		*fp;
diff --git a/src/modules/rlm_utf8/rlm_utf8.c b/src/modules/rlm_utf8/rlm_utf8.c
index 7c58c528b8c..c71073ad02b 100644
--- a/src/modules/rlm_utf8/rlm_utf8.c
+++ b/src/modules/rlm_utf8/rlm_utf8.c
@@ -30,7 +30,7 @@ RCSID("$Id$")
 /*
  *	Reject any non-UTF8 data.
  */
-static int utf8_clean(void *instance, REQUEST *request)
+static rlm_rcode_t utf8_clean(void *instance, REQUEST *request)
 {
 	size_t i, len;
 	VALUE_PAIR *vp, *next;
diff --git a/src/modules/rlm_wimax/rlm_wimax.c b/src/modules/rlm_wimax/rlm_wimax.c
index 4436567b33e..33fa50cb570 100644
--- a/src/modules/rlm_wimax/rlm_wimax.c
+++ b/src/modules/rlm_wimax/rlm_wimax.c
@@ -103,7 +103,7 @@ static int wimax_instantiate(CONF_SECTION *conf, void **instance)
  *	from the database. The authentication code only needs to check
  *	the password, the rest is done here.
  */
-static int wimax_authorize(void *instance, REQUEST *request)
+static rlm_rcode_t wimax_authorize(void *instance, REQUEST *request)
 {
 	VALUE_PAIR *vp;
 
@@ -145,7 +145,7 @@ static int wimax_authorize(void *instance, REQUEST *request)
 /*
  *	Massage the request before recording it or proxying it
  */
-static int wimax_preacct(void *instance, REQUEST *request)
+static rlm_rcode_t wimax_preacct(void *instance, REQUEST *request)
 {
 	return wimax_authorize(instance, request);
 }
@@ -153,7 +153,7 @@ static int wimax_preacct(void *instance, REQUEST *request)
 /*
  *	Write accounting information to this modules database.
  */
-static int wimax_accounting(void *instance, REQUEST *request)
+static rlm_rcode_t wimax_accounting(void *instance, REQUEST *request)
 {
 	/* quiet the compiler */
 	instance = instance;
@@ -165,7 +165,7 @@ static int wimax_accounting(void *instance, REQUEST *request)
 /*
  *	Generate the keys after the user has been authenticated.
  */
-static int wimax_postauth(void *instance, REQUEST *request)
+static rlm_rcode_t wimax_postauth(void *instance, REQUEST *request)
 {
 	rlm_wimax_t *inst = instance;
 	VALUE_PAIR *msk, *emsk, *vp;