Lines Matching refs:radius
12 #include "radius.h"
233 radius_change_server(struct radius_client_data *radius,
237 static int radius_client_init_acct(struct radius_client_data *radius);
238 static int radius_client_init_auth(struct radius_client_data *radius);
250 * @radius: RADIUS client context from radius_client_init()
264 int radius_client_register(struct radius_client_data *radius,
277 handlers = &radius->acct_handlers;
278 num = &radius->num_acct_handlers;
280 handlers = &radius->auth_handlers;
281 num = &radius->num_auth_handlers;
302 static int radius_client_handle_send_error(struct radius_client_data *radius,
310 hostapd_logger(radius->ctx, NULL, HOSTAPD_MODULE_RADIUS,
316 radius_client_init_acct(radius);
319 radius_client_init_auth(radius);
329 static int radius_client_retransmit(struct radius_client_data *radius,
333 struct hostapd_radius_servers *conf = radius->conf;
339 s = radius->acct_sock;
347 s = radius->auth_sock;
358 hostapd_logger(radius->ctx, entry->addr, HOSTAPD_MODULE_RADIUS,
365 if (radius_client_handle_send_error(radius, s, entry->msg_type)
385 struct radius_client_data *radius = eloop_ctx;
386 struct hostapd_radius_servers *conf = radius->conf;
395 entry = radius->msgs;
404 prev_num_msgs = radius->num_msgs;
406 radius_client_retransmit(radius, entry, now.sec)) {
410 radius->msgs = entry->next;
415 radius->num_msgs--;
419 if (prev_num_msgs != radius->num_msgs) {
422 entry = radius->msgs;
427 s = entry->msg_type == RADIUS_AUTH ? radius->auth_sock :
428 radius->acct_sock;
445 if (radius->msgs) {
449 radius_client_timer, radius, NULL);
450 hostapd_logger(radius->ctx, NULL, HOSTAPD_MODULE_RADIUS,
459 hostapd_logger(radius->ctx, NULL, HOSTAPD_MODULE_RADIUS,
466 for (entry = radius->msgs; entry; entry = entry->next) {
475 radius_change_server(radius, next, old,
476 radius->auth_serv_sock,
477 radius->auth_serv_sock6, 1);
483 hostapd_logger(radius->ctx, NULL, HOSTAPD_MODULE_RADIUS,
490 for (entry = radius->msgs; entry; entry = entry->next) {
500 radius_change_server(radius, next, old,
501 radius->acct_serv_sock,
502 radius->acct_serv_sock6, 0);
507 static void radius_client_update_timeout(struct radius_client_data *radius)
513 eloop_cancel_timeout(radius_client_timer, radius, NULL);
515 if (radius->msgs == NULL) {
520 for (entry = radius->msgs; entry; entry = entry->next) {
528 eloop_register_timeout(first - now.sec, 0, radius_client_timer, radius,
530 hostapd_logger(radius->ctx, NULL, HOSTAPD_MODULE_RADIUS,
536 static void radius_client_list_add(struct radius_client_data *radius,
569 entry->next = radius->msgs;
570 radius->msgs = entry;
571 radius_client_update_timeout(radius);
573 if (radius->num_msgs >= RADIUS_CLIENT_MAX_ENTRIES) {
585 radius->num_msgs++;
589 static void radius_client_list_del(struct radius_client_data *radius,
597 entry = radius->msgs;
605 radius->msgs = entry->next;
608 hostapd_logger(radius->ctx, addr,
613 radius->num_msgs--;
624 * @radius: RADIUS client context from radius_client_init()
644 int radius_client_send(struct radius_client_data *radius,
648 struct hostapd_radius_servers *conf = radius->conf;
657 radius_client_list_del(radius, msg_type, addr);
661 if (conf->acct_server == NULL || radius->acct_sock < 0) {
662 hostapd_logger(radius->ctx, NULL,
672 s = radius->acct_sock;
675 if (conf->auth_server == NULL || radius->auth_sock < 0) {
676 hostapd_logger(radius->ctx, NULL,
686 s = radius->auth_sock;
690 hostapd_logger(radius->ctx, NULL, HOSTAPD_MODULE_RADIUS,
699 radius_client_handle_send_error(radius, s, msg_type);
701 radius_client_list_add(radius, msg, msg_type, shared_secret,
710 struct radius_client_data *radius = eloop_ctx;
711 struct hostapd_radius_servers *conf = radius->conf;
725 handlers = radius->acct_handlers;
726 num_handlers = radius->num_acct_handlers;
729 handlers = radius->auth_handlers;
730 num_handlers = radius->num_auth_handlers;
739 hostapd_logger(radius->ctx, NULL, HOSTAPD_MODULE_RADIUS,
755 hostapd_logger(radius->ctx, NULL, HOSTAPD_MODULE_RADIUS,
776 req = radius->msgs;
792 hostapd_logger(radius->ctx, NULL, HOSTAPD_MODULE_RADIUS,
803 hostapd_logger(radius->ctx, req->addr, HOSTAPD_MODULE_RADIUS,
814 radius->msgs = req->next;
815 radius->num_msgs--;
842 hostapd_logger(radius->ctx, req->addr, HOSTAPD_MODULE_RADIUS,
857 * @radius: RADIUS client context from radius_client_init()
863 u8 radius_client_get_id(struct radius_client_data *radius)
866 u8 id = radius->next_radius_identifier++;
870 entry = radius->msgs;
874 hostapd_logger(radius->ctx, entry->addr,
882 radius->msgs = entry->next;
900 * @radius: RADIUS client context from radius_client_init()
903 void radius_client_flush(struct radius_client_data *radius, int only_auth)
907 if (!radius)
911 entry = radius->msgs;
918 radius->msgs = entry->next;
923 radius->num_msgs--;
930 if (radius->msgs == NULL)
931 eloop_cancel_timeout(radius_client_timer, radius, NULL);
935 static void radius_client_update_acct_msgs(struct radius_client_data *radius,
941 if (!radius)
944 for (entry = radius->msgs; entry; entry = entry->next) {
956 radius_change_server(struct radius_client_data *radius,
970 struct hostapd_radius_servers *conf = radius->conf;
972 hostapd_logger(radius->ctx, NULL, HOSTAPD_MODULE_RADIUS,
991 radius_client_flush(radius, 1);
994 radius, nserv->shared_secret,
1000 for (entry = radius->msgs; oserv && oserv != nserv && entry;
1010 if (radius->msgs) {
1011 eloop_cancel_timeout(radius_client_timer, radius, NULL);
1013 radius_client_timer, radius, NULL);
1068 wpa_printf(MSG_INFO, "bind[radius]: %s",
1075 wpa_printf(MSG_INFO, "connect[radius]: %s", strerror(errno));
1107 radius->auth_sock = sel_sock;
1109 radius->acct_sock = sel_sock;
1117 struct radius_client_data *radius = eloop_ctx;
1118 struct hostapd_radius_servers *conf = radius->conf;
1121 if (radius->auth_sock >= 0 && conf->auth_servers &&
1125 radius_change_server(radius, conf->auth_server, oserv,
1126 radius->auth_serv_sock,
1127 radius->auth_serv_sock6, 1);
1130 if (radius->acct_sock >= 0 && conf->acct_servers &&
1134 radius_change_server(radius, conf->acct_server, oserv,
1135 radius->acct_serv_sock,
1136 radius->acct_serv_sock6, 0);
1141 radius_retry_primary_timer, radius,
1162 static void radius_close_auth_sockets(struct radius_client_data *radius)
1164 radius->auth_sock = -1;
1166 if (radius->auth_serv_sock >= 0) {
1167 eloop_unregister_read_sock(radius->auth_serv_sock);
1168 close(radius->auth_serv_sock);
1169 radius->auth_serv_sock = -1;
1172 if (radius->auth_serv_sock6 >= 0) {
1173 eloop_unregister_read_sock(radius->auth_serv_sock6);
1174 close(radius->auth_serv_sock6);
1175 radius->auth_serv_sock6 = -1;
1181 static void radius_close_acct_sockets(struct radius_client_data *radius)
1183 radius->acct_sock = -1;
1185 if (radius->acct_serv_sock >= 0) {
1186 eloop_unregister_read_sock(radius->acct_serv_sock);
1187 close(radius->acct_serv_sock);
1188 radius->acct_serv_sock = -1;
1191 if (radius->acct_serv_sock6 >= 0) {
1192 eloop_unregister_read_sock(radius->acct_serv_sock6);
1193 close(radius->acct_serv_sock6);
1194 radius->acct_serv_sock6 = -1;
1200 static int radius_client_init_auth(struct radius_client_data *radius)
1202 struct hostapd_radius_servers *conf = radius->conf;
1205 radius_close_auth_sockets(radius);
1207 radius->auth_serv_sock = socket(PF_INET, SOCK_DGRAM, 0);
1208 if (radius->auth_serv_sock < 0)
1212 radius_client_disable_pmtu_discovery(radius->auth_serv_sock);
1217 radius->auth_serv_sock6 = socket(PF_INET6, SOCK_DGRAM, 0);
1218 if (radius->auth_serv_sock6 < 0)
1228 radius_change_server(radius, conf->auth_server, NULL,
1229 radius->auth_serv_sock, radius->auth_serv_sock6,
1232 if (radius->auth_serv_sock >= 0 &&
1233 eloop_register_read_sock(radius->auth_serv_sock,
1234 radius_client_receive, radius,
1237 radius_close_auth_sockets(radius);
1242 if (radius->auth_serv_sock6 >= 0 &&
1243 eloop_register_read_sock(radius->auth_serv_sock6,
1244 radius_client_receive, radius,
1247 radius_close_auth_sockets(radius);
1256 static int radius_client_init_acct(struct radius_client_data *radius)
1258 struct hostapd_radius_servers *conf = radius->conf;
1261 radius_close_acct_sockets(radius);
1263 radius->acct_serv_sock = socket(PF_INET, SOCK_DGRAM, 0);
1264 if (radius->acct_serv_sock < 0)
1268 radius_client_disable_pmtu_discovery(radius->acct_serv_sock);
1273 radius->acct_serv_sock6 = socket(PF_INET6, SOCK_DGRAM, 0);
1274 if (radius->acct_serv_sock6 < 0)
1284 radius_change_server(radius, conf->acct_server, NULL,
1285 radius->acct_serv_sock, radius->acct_serv_sock6,
1288 if (radius->acct_serv_sock >= 0 &&
1289 eloop_register_read_sock(radius->acct_serv_sock,
1290 radius_client_receive, radius,
1293 radius_close_acct_sockets(radius);
1298 if (radius->acct_serv_sock6 >= 0 &&
1299 eloop_register_read_sock(radius->acct_serv_sock6,
1300 radius_client_receive, radius,
1303 radius_close_acct_sockets(radius);
1325 struct radius_client_data *radius;
1327 radius = os_zalloc(sizeof(struct radius_client_data));
1328 if (radius == NULL)
1331 radius->ctx = ctx;
1332 radius->conf = conf;
1333 radius->auth_serv_sock = radius->acct_serv_sock =
1334 radius->auth_serv_sock6 = radius->acct_serv_sock6 =
1335 radius->auth_sock = radius->acct_sock = -1;
1337 if (conf->auth_server && radius_client_init_auth(radius)) {
1338 radius_client_deinit(radius);
1342 if (conf->acct_server && radius_client_init_acct(radius)) {
1343 radius_client_deinit(radius);
1349 radius_retry_primary_timer, radius,
1352 return radius;
1358 * @radius: RADIUS client context from radius_client_init()
1360 void radius_client_deinit(struct radius_client_data *radius)
1362 if (!radius)
1365 radius_close_auth_sockets(radius);
1366 radius_close_acct_sockets(radius);
1368 eloop_cancel_timeout(radius_retry_primary_timer, radius, NULL);
1370 radius_client_flush(radius, 0);
1371 os_free(radius->auth_handlers);
1372 os_free(radius->acct_handlers);
1373 os_free(radius);
1379 * @radius: RADIUS client context from radius_client_init()
1387 void radius_client_flush_auth(struct radius_client_data *radius,
1393 entry = radius->msgs;
1397 hostapd_logger(radius->ctx, addr,
1406 radius->msgs = entry->next;
1411 radius->num_msgs--;
1518 * @radius: RADIUS client context from radius_client_init()
1523 int radius_client_get_mib(struct radius_client_data *radius, char *buf,
1526 struct hostapd_radius_servers *conf = radius->conf;
1537 radius : NULL);
1547 radius : NULL);
1555 void radius_client_reconfig(struct radius_client_data *radius,
1558 if (radius)
1559 radius->conf = conf;