Disconnect hostapd from building in base
[dragonfly.git] / contrib / hostapd / src / radius / radius_client.h
1 /*
2  * RADIUS client
3  * Copyright (c) 2002-2009, Jouni Malinen <j@w1.fi>
4  *
5  * This software may be distributed under the terms of the BSD license.
6  * See README for more details.
7  */
8
9 #ifndef RADIUS_CLIENT_H
10 #define RADIUS_CLIENT_H
11
12 #include "ip_addr.h"
13
14 struct radius_msg;
15
16 /**
17  * struct hostapd_radius_server - RADIUS server information for RADIUS client
18  *
19  * This structure contains information about a RADIUS server. The values are
20  * mainly for MIB information. The MIB variable prefix (radiusAuth or
21  * radiusAcc) depends on whether this is an authentication or accounting
22  * server.
23  *
24  * radiusAuthClientPendingRequests (or radiusAccClientPendingRequests) is the
25  * number struct radius_client_data::msgs for matching msg_type.
26  */
27 struct hostapd_radius_server {
28         /**
29          * addr - radiusAuthServerAddress or radiusAccServerAddress
30          */
31         struct hostapd_ip_addr addr;
32
33         /**
34          * port - radiusAuthClientServerPortNumber or radiusAccClientServerPortNumber
35          */
36         int port;
37
38         /**
39          * shared_secret - Shared secret for authenticating RADIUS messages
40          */
41         u8 *shared_secret;
42
43         /**
44          * shared_secret_len - Length of shared_secret in octets
45          */
46         size_t shared_secret_len;
47
48         /* Dynamic (not from configuration file) MIB data */
49
50         /**
51          * index - radiusAuthServerIndex or radiusAccServerIndex
52          */
53         int index;
54
55         /**
56          * round_trip_time - radiusAuthClientRoundTripTime or radiusAccClientRoundTripTime
57          * Round-trip time in hundredths of a second.
58          */
59         int round_trip_time;
60
61         /**
62          * requests - radiusAuthClientAccessRequests or radiusAccClientRequests
63          */
64         u32 requests;
65
66         /**
67          * retransmissions - radiusAuthClientAccessRetransmissions or radiusAccClientRetransmissions
68          */
69         u32 retransmissions;
70
71         /**
72          * access_accepts - radiusAuthClientAccessAccepts
73          */
74         u32 access_accepts;
75
76         /**
77          * access_rejects - radiusAuthClientAccessRejects
78          */
79         u32 access_rejects;
80
81         /**
82          * access_challenges - radiusAuthClientAccessChallenges
83          */
84         u32 access_challenges;
85
86         /**
87          * responses - radiusAccClientResponses
88          */
89         u32 responses;
90
91         /**
92          * malformed_responses - radiusAuthClientMalformedAccessResponses or radiusAccClientMalformedResponses
93          */
94         u32 malformed_responses;
95
96         /**
97          * bad_authenticators - radiusAuthClientBadAuthenticators or radiusAccClientBadAuthenticators
98          */
99         u32 bad_authenticators;
100
101         /**
102          * timeouts - radiusAuthClientTimeouts or radiusAccClientTimeouts
103          */
104         u32 timeouts;
105
106         /**
107          * unknown_types - radiusAuthClientUnknownTypes or radiusAccClientUnknownTypes
108          */
109         u32 unknown_types;
110
111         /**
112          * packets_dropped - radiusAuthClientPacketsDropped or radiusAccClientPacketsDropped
113          */
114         u32 packets_dropped;
115 };
116
117 /**
118  * struct hostapd_radius_servers - RADIUS servers for RADIUS client
119  */
120 struct hostapd_radius_servers {
121         /**
122          * auth_servers - RADIUS Authentication servers in priority order
123          */
124         struct hostapd_radius_server *auth_servers;
125
126         /**
127          * num_auth_servers - Number of auth_servers entries
128          */
129         int num_auth_servers;
130
131         /**
132          * auth_server - The current Authentication server
133          */
134         struct hostapd_radius_server *auth_server;
135
136         /**
137          * acct_servers - RADIUS Accounting servers in priority order
138          */
139         struct hostapd_radius_server *acct_servers;
140
141         /**
142          * num_acct_servers - Number of acct_servers entries
143          */
144         int num_acct_servers;
145
146         /**
147          * acct_server - The current Accounting server
148          */
149         struct hostapd_radius_server *acct_server;
150
151         /**
152          * retry_primary_interval - Retry interval for trying primary server
153          *
154          * This specifies a retry interval in sexconds for trying to return to
155          * the primary RADIUS server. RADIUS client code will automatically try
156          * to use the next server when the current server is not replying to
157          * requests. If this interval is set (non-zero), the primary server
158          * will be retried after the specified number of seconds has passed
159          * even if the current used secondary server is still working.
160          */
161         int retry_primary_interval;
162
163         /**
164          * msg_dumps - Whether RADIUS message details are shown in stdout
165          */
166         int msg_dumps;
167
168         /**
169          * client_addr - Client (local) address to use if force_client_addr
170          */
171         struct hostapd_ip_addr client_addr;
172
173         /**
174          * force_client_addr - Whether to force client (local) address
175          */
176         int force_client_addr;
177 };
178
179
180 /**
181  * RadiusType - RADIUS server type for RADIUS client
182  */
183 typedef enum {
184         /**
185          * RADIUS authentication
186          */
187         RADIUS_AUTH,
188
189         /**
190          * RADIUS_ACCT - RADIUS accounting
191          */
192         RADIUS_ACCT,
193
194         /**
195          * RADIUS_ACCT_INTERIM - RADIUS interim accounting message
196          *
197          * Used only with radius_client_send(). This behaves just like
198          * RADIUS_ACCT, but removes any pending interim RADIUS Accounting
199          * messages for the same STA before sending the new interim update.
200          */
201         RADIUS_ACCT_INTERIM
202 } RadiusType;
203
204 /**
205  * RadiusRxResult - RADIUS client RX handler result
206  */
207 typedef enum {
208         /**
209          * RADIUS_RX_PROCESSED - Message processed
210          *
211          * This stops handler calls and frees the message.
212          */
213         RADIUS_RX_PROCESSED,
214
215         /**
216          * RADIUS_RX_QUEUED - Message has been queued
217          *
218          * This stops handler calls, but does not free the message; the handler
219          * that returned this is responsible for eventually freeing the
220          * message.
221          */
222         RADIUS_RX_QUEUED,
223
224         /**
225          * RADIUS_RX_UNKNOWN - Message is not for this handler
226          */
227         RADIUS_RX_UNKNOWN,
228
229         /**
230          * RADIUS_RX_INVALID_AUTHENTICATOR - Message has invalid Authenticator
231          */
232         RADIUS_RX_INVALID_AUTHENTICATOR
233 } RadiusRxResult;
234
235 struct radius_client_data;
236
237 int radius_client_register(struct radius_client_data *radius,
238                            RadiusType msg_type,
239                            RadiusRxResult (*handler)
240                            (struct radius_msg *msg, struct radius_msg *req,
241                             const u8 *shared_secret, size_t shared_secret_len,
242                             void *data),
243                            void *data);
244 int radius_client_send(struct radius_client_data *radius,
245                        struct radius_msg *msg,
246                        RadiusType msg_type, const u8 *addr);
247 u8 radius_client_get_id(struct radius_client_data *radius);
248 void radius_client_flush(struct radius_client_data *radius, int only_auth);
249 struct radius_client_data *
250 radius_client_init(void *ctx, struct hostapd_radius_servers *conf);
251 void radius_client_deinit(struct radius_client_data *radius);
252 void radius_client_flush_auth(struct radius_client_data *radius,
253                               const u8 *addr);
254 int radius_client_get_mib(struct radius_client_data *radius, char *buf,
255                           size_t buflen);
256 void radius_client_reconfig(struct radius_client_data *radius,
257                             struct hostapd_radius_servers *conf);
258
259 #endif /* RADIUS_CLIENT_H */