Home | History | Annotate | Download | only in radius
      1 /*
      2  * RADIUS client
      3  * Copyright (c) 2002-2009, Jouni Malinen <j (at) 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 */
    260