Add proper return code type rlm_rcode_t, and update signatures of all module functions that return rcodes
/*
- * 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
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
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.
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);
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;
* 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);
}
/*
* 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);
}
/*
* 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);
}
/*
* 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);
}
*/
int module_checksimul(int sess_type, REQUEST *request, int maxsimul)
{
- int rcode;
+ rlm_rcode_t rcode;
if(!request->username)
return 0;
/*
* 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);
}
/*
* 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);
}
/*
* 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);
}
#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;
}
-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;
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:
* 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;
/*
{ 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;
else {
radlog(L_ERR|L_CONS,
"rlm_always: Unknown module rcode '%s'.\n", s);
- return -1;
+ return RLM_MODULE_UNKNOWN;
}
}
* 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;
}
* 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;
}
/*
* 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;
/*
* 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;
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);
}
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;
/* 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:
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;
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)
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) &&
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;
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);
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;
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);
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';
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;
}
}
- 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);
}
* 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;
#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 */
* 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];
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;
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);
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;
}
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;
return RLM_MODULE_FAIL;
}
if (regexec(®, (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(®);
}
#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;
}
- 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);
}
}
-static int add_defaults(rlm_counter_t *inst)
+static rlm_rcode_t add_defaults(rlm_counter_t *inst)
{
datum key_datum;
datum time_datum;
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);
/*
* 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");
/*
* 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;
* 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
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;
* 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;
* 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;
}
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;
}
/*
*/
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;
}
}
- 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",
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)
}
-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];
*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;
/*
* 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];
/*
* 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 &&
/*
* 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);
}
/*
* 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);
}
/*
* 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);
}
/*
* 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);
}
* 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) {
/*
* 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) {
* 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) {
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;
/*
* 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;
/*
* 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;
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;
/*
* 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;
* 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;
* 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;
*/
handler = request_data_get(request, inst, REQUEST_DATA_EAP_HANDLER);
if (handler != NULL) {
- int rcode;
+ rlm_rcode_t rcode;
eap_tunnel_data_t *data;
/*
}
#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;
/*
* 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;
* 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;
/*
* 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;
/*
* 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;
/*
* 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;
* 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;
/*
* 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;
*
* 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;
*
* 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;
/*
* 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;
* 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;
/*
* Authentication - unused.
*/
-static int fastuser_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t fastuser_authenticate(void *instance, REQUEST *request)
{
instance = 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;
/*
* 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?
/*
* 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)
{
* 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;
* 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;
}
#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;
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;
}
#endif
-static int file_authenticate(void *instance, REQUEST *request)
+static rlm_rcode_t file_authenticate(void *instance, REQUEST *request)
{
struct file_instance *inst = instance;
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;
* 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;
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;
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;
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);
}
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;
* 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;
/*
* 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;
}
-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;
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;
/** 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;
/** 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;
/** 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;
}
-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) {
/** 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;
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];
/*
* 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;
* 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;
* 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;
* 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;
/*
* 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;
/* 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;
/* 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;
}
/* 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;
* 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;
/*
* 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 */
}
}
-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];
* 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);
/*
* 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);
/*
* 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);
/*
* 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;
/*
* 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);
/*
* 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);
/*
* 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);
/*
* 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);
/*
* 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);
/*
* 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);
* 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");
/*
* 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;
/*
* 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;
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); \
}
/*
* 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;
* 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;
/*
* 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;
* 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;
*
* 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;
/*
* 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;
* 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;
{
NULL, /* authentication */
realm_authorize, /* authorization */
- realm_preacct, /* preaccounting */
+ realm_preacct, /* preaccounting */
NULL, /* accounting */
NULL, /* checksimul */
NULL, /* pre-proxy */
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;
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.");
}
#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);
* 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;
/*
* 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;
/*
* 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;
}
* 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;
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, \
}
-static int securid_instantiate(CONF_SECTION *conf, void **instance)
+static rlm_rcode_t securid_instantiate(CONF_SECTION *conf, void **instance)
{
rlm_securid_t *inst;
* 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;
/*
* 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;
* 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;
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;
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;
/*
* 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;
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;
}
-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;
/*
* 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) {
* 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;
/*
* 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) {
* 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;
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 */
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);
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)
}
/* 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 */
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;
/*
* 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];
* 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;
* 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);
}
* 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];
/*
* 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;
/*
* 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;
* 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;
/*
* 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);
}
/*
* 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;
/*
* 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;
projects / thirdparty / freeradius-server.git / commitdiff
