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));
1103 radius->auth_sock = sel_sock;
1105 radius->acct_sock = sel_sock;
1113 struct radius_client_data *radius = eloop_ctx;
1114 struct hostapd_radius_servers *conf = radius->conf;
1117 if (radius->auth_sock >= 0 && conf->auth_servers &&
1121 radius_change_server(radius, conf->auth_server, oserv,
1122 radius->auth_serv_sock,
1123 radius->auth_serv_sock6, 1);
1126 if (radius->acct_sock >= 0 && conf->acct_servers &&
1130 radius_change_server(radius, conf->acct_server, oserv,
1131 radius->acct_serv_sock,
1132 radius->acct_serv_sock6, 0);
1137 radius_retry_primary_timer, radius,
1158 static void radius_close_auth_sockets(struct radius_client_data *radius)
1160 radius->auth_sock = -1;
1162 if (radius->auth_serv_sock >= 0) {
1163 eloop_unregister_read_sock(radius->auth_serv_sock);
1164 close(radius->auth_serv_sock);
1165 radius->auth_serv_sock = -1;
1168 if (radius->auth_serv_sock6 >= 0) {
1169 eloop_unregister_read_sock(radius->auth_serv_sock6);
1170 close(radius->auth_serv_sock6);
1171 radius->auth_serv_sock6 = -1;
1177 static void radius_close_acct_sockets(struct radius_client_data *radius)
1179 radius->acct_sock = -1;
1181 if (radius->acct_serv_sock >= 0) {
1182 eloop_unregister_read_sock(radius->acct_serv_sock);
1183 close(radius->acct_serv_sock);
1184 radius->acct_serv_sock = -1;
1187 if (radius->acct_serv_sock6 >= 0) {
1188 eloop_unregister_read_sock(radius->acct_serv_sock6);
1189 close(radius->acct_serv_sock6);
1190 radius->acct_serv_sock6 = -1;
1196 static int radius_client_init_auth(struct radius_client_data *radius)
1198 struct hostapd_radius_servers *conf = radius->conf;
1201 radius_close_auth_sockets(radius);
1203 radius->auth_serv_sock = socket(PF_INET, SOCK_DGRAM, 0);
1204 if (radius->auth_serv_sock < 0)
1208 radius_client_disable_pmtu_discovery(radius->auth_serv_sock);
1213 radius->auth_serv_sock6 = socket(PF_INET6, SOCK_DGRAM, 0);
1214 if (radius->auth_serv_sock6 < 0)
1224 radius_change_server(radius, conf->auth_server, NULL,
1225 radius->auth_serv_sock, radius->auth_serv_sock6,
1228 if (radius->auth_serv_sock >= 0 &&
1229 eloop_register_read_sock(radius->auth_serv_sock,
1230 radius_client_receive, radius,
1233 radius_close_auth_sockets(radius);
1238 if (radius->auth_serv_sock6 >= 0 &&
1239 eloop_register_read_sock(radius->auth_serv_sock6,
1240 radius_client_receive, radius,
1243 radius_close_auth_sockets(radius);
1252 static int radius_client_init_acct(struct radius_client_data *radius)
1254 struct hostapd_radius_servers *conf = radius->conf;
1257 radius_close_acct_sockets(radius);
1259 radius->acct_serv_sock = socket(PF_INET, SOCK_DGRAM, 0);
1260 if (radius->acct_serv_sock < 0)
1264 radius_client_disable_pmtu_discovery(radius->acct_serv_sock);
1269 radius->acct_serv_sock6 = socket(PF_INET6, SOCK_DGRAM, 0);
1270 if (radius->acct_serv_sock6 < 0)
1280 radius_change_server(radius, conf->acct_server, NULL,
1281 radius->acct_serv_sock, radius->acct_serv_sock6,
1284 if (radius->acct_serv_sock >= 0 &&
1285 eloop_register_read_sock(radius->acct_serv_sock,
1286 radius_client_receive, radius,
1289 radius_close_acct_sockets(radius);
1294 if (radius->acct_serv_sock6 >= 0 &&
1295 eloop_register_read_sock(radius->acct_serv_sock6,
1296 radius_client_receive, radius,
1299 radius_close_acct_sockets(radius);
1321 struct radius_client_data *radius;
1323 radius = os_zalloc(sizeof(struct radius_client_data));
1324 if (radius == NULL)
1327 radius->ctx = ctx;
1328 radius->conf = conf;
1329 radius->auth_serv_sock = radius->acct_serv_sock =
1330 radius->auth_serv_sock6 = radius->acct_serv_sock6 =
1331 radius->auth_sock = radius->acct_sock = -1;
1333 if (conf->auth_server && radius_client_init_auth(radius)) {
1334 radius_client_deinit(radius);
1338 if (conf->acct_server && radius_client_init_acct(radius)) {
1339 radius_client_deinit(radius);
1345 radius_retry_primary_timer, radius,
1348 return radius;
1354 * @radius: RADIUS client context from radius_client_init()
1356 void radius_client_deinit(struct radius_client_data *radius)
1358 if (!radius)
1361 radius_close_auth_sockets(radius);
1362 radius_close_acct_sockets(radius);
1364 eloop_cancel_timeout(radius_retry_primary_timer, radius, NULL);
1366 radius_client_flush(radius, 0);
1367 os_free(radius->auth_handlers);
1368 os_free(radius->acct_handlers);
1369 os_free(radius);
1375 * @radius: RADIUS client context from radius_client_init()
1383 void radius_client_flush_auth(struct radius_client_data *radius,
1389 entry = radius->msgs;
1393 hostapd_logger(radius->ctx, addr,
1402 radius->msgs = entry->next;
1407 radius->num_msgs--;
1514 * @radius: RADIUS client context from radius_client_init()
1519 int radius_client_get_mib(struct radius_client_data *radius, char *buf,
1522 struct hostapd_radius_servers *conf = radius->conf;
1533 radius : NULL);
1543 radius : NULL);
1551 void radius_client_reconfig(struct radius_client_data *radius,
1554 if (radius)
1555 radius->conf = conf;