1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
/**
* $Id$
*
* @file modules.h
* @brief Interface to the RADIUS module system.
*
* @copyright 2013 The FreeRADIUS server project
*/
#ifndef RADIUS_MODULES_H
#define RADIUS_MODULES_H
RCSIDH(modules_h, "$Id$")
#include <freeradius-devel/conffile.h>
#include <freeradius-devel/features.h>
#ifdef __cplusplus
extern "C" {
#endif
/** The different section components of the server
*
* Used as indexes in the methods array in the module_t struct.
*/
typedef enum rlm_components {
MOD_AUTHENTICATE = 0, //!< 0 methods index for authenticate section.
MOD_AUTHORIZE, //!< 1 methods index for authorize section.
MOD_PREACCT, //!< 2 methods index for preacct section.
MOD_ACCOUNTING, //!< 3 methods index for accounting section.
MOD_SESSION, //!< 4 methods index for checksimul section.
MOD_PRE_PROXY, //!< 5 methods index for preproxy section.
MOD_POST_PROXY, //!< 6 methods index for postproxy section.
MOD_POST_AUTH, //!< 7 methods index for postauth section.
#ifdef WITH_COA
MOD_RECV_COA, //!< 8 methods index for recvcoa section.
MOD_SEND_COA, //!< 9 methods index for sendcoa section.
#endif
MOD_COUNT //!< 10 how many components there are.
} rlm_components_t;
extern const FR_NAME_NUMBER mod_rcode_table[];
/** 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 {
char const *section; //!< Section name e.g. "Authorize".
char const *typename; //!< Type name e.g. "Auth-Type".
int attr; //!< Attribute number.
} 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) //!< Module is threadsafe.
#define RLM_TYPE_THREAD_UNSAFE (1 << 0) //!< Module is not threadsafe.
//!< Server will protect calls
//!< with mutex.
#define RLM_TYPE_HUP_SAFE (1 << 2) //!< Will be restarted on HUP.
//!< Server will instantiated
//!< new instance, and then
//!< destroy old instance.
/* Stop people using different module/library/server versions together */
#define RLM_MODULE_INIT RADIUSD_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 {
uint64_t magic; //!< Used to validate module struct.
char const *name; //!< The name of the module (without rlm_ prefix).
int type; //!< One or more of the RLM_TYPE_* constants.
size_t inst_size; //!< Size of the instance data
CONF_PARSER const *config; //!< Configuration information
instantiate_t bootstrap; //!< register dynamic attrs, etc.
instantiate_t instantiate; //!< Function to use for instantiation.
detach_t detach; //!< Function to use to free module instance.
packetmethod methods[MOD_COUNT]; //!< Pointers to the various section functions.
} module_t;
int modules_init(CONF_SECTION *);
int modules_free(void);
int modules_hup(CONF_SECTION *modules);
rlm_rcode_t process_authorize(int type, REQUEST *request);
rlm_rcode_t process_authenticate(int type, REQUEST *request);
rlm_rcode_t module_preacct(REQUEST *request);
rlm_rcode_t process_accounting(int type, REQUEST *request);
int process_checksimul(int type, REQUEST *request, int maxsimul);
rlm_rcode_t process_pre_proxy(int type, REQUEST *request);
rlm_rcode_t process_post_proxy(int type, REQUEST *request);
rlm_rcode_t process_post_auth(int type, REQUEST *request);
#ifdef WITH_COA
rlm_rcode_t process_recv_coa(int type, REQUEST *request);
rlm_rcode_t process_send_coa(int type, REQUEST *request);
#define MODULE_NULL_COA_FUNCS ,NULL,NULL
#else
#define MODULE_NULL_COA_FUNCS
#endif
rlm_rcode_t indexed_modcall(rlm_components_t comp, int idx, REQUEST *request);
/*
* For now, these are strongly tied together.
*/
int virtual_servers_load(CONF_SECTION *config);
void virtual_servers_free(time_t when);
#ifdef __cplusplus
}
#endif
#endif /* RADIUS_MODULES_H */
|
