7u83
/
freewtp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add business logic of Authentication/Association in SplitMAC mode.

This commit is contained in:
vemax78 2014-04-25 22:05:36 +02:00
parent d4d7649f3b
commit e1023a388e
14 changed files with 498 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
src/ac/ac_dfa_configure.c
View File

@ -3,9 +3,34 @@
#include "capwap_array.h" #include "capwap_array.h"
#include "ac_session.h" #include "ac_session.h"
#include "ac_json.h" #include "ac_json.h"
#include "ac_wlans.h"
#include <json/json.h> #include <json/json.h>
#include <arpa/inet.h> #include <arpa/inet.h>
/* */
static void ac_dfa_state_configure_set_radio_configuration(struct ac_session_t* session, struct ac_json_ieee80211_wtpradio* wtpradio) {
int i;
for (i = 0; i < RADIOID_MAX_COUNT; i++) {
struct ac_json_ieee80211_item* item = &wtpradio->items[i];
if (item->valid) {
struct ac_device* device = &session->wlans->devices[i];
/* Set rates */
if (item->rateset || item->supportedrates) {
if (item->rateset) {
memcpy(device->supportedrates, item->rateset->rateset, item->rateset->ratesetcount);
device->supportedratescount = item->rateset->ratesetcount;
} else if (item->supportedrates) {
memcpy(device->supportedrates, item->supportedrates->supportedrates, item->supportedrates->supportedratescount);
device->supportedratescount = item->supportedrates->supportedratescount;
}
}
}
}
}
/* */ /* */
static struct ac_soap_response* ac_dfa_state_configure_parsing_request(struct ac_session_t* session, struct capwap_parsed_packet* packet) { static struct ac_soap_response* ac_dfa_state_configure_parsing_request(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
int i; int i;
@ -690,6 +715,9 @@ static uint32_t ac_dfa_state_configure_create_response(struct ac_session_t* sess
if (ac_json_ieee80211_parsingjson(&wtpradio, jsonelement)) { if (ac_json_ieee80211_parsingjson(&wtpradio, jsonelement)) {
/* Add IEEE802.11 message elements to packet */ /* Add IEEE802.11 message elements to packet */
ac_json_ieee80211_buildpacket(&wtpradio, txmngpacket); ac_json_ieee80211_buildpacket(&wtpradio, txmngpacket);
/* Retrieve frequency and rates configuration */
ac_dfa_state_configure_set_radio_configuration(session, &wtpradio);
} }
} }

2
src/ac/ac_dfa_run.c
View File

@ -75,7 +75,7 @@ static void execute_ieee80211_wlan_configuration_addwlan(struct ac_session_t* se
/* Get BSSID */ /* Get BSSID */
assignbssid = (struct capwap_80211_assignbssid_element*)capwap_get_message_element_data(packet, CAPWAP_ELEMENT_80211_ASSIGN_BSSID); assignbssid = (struct capwap_80211_assignbssid_element*)capwap_get_message_element_data(packet, CAPWAP_ELEMENT_80211_ASSIGN_BSSID);
if (assignbssid && (assignbssid->radioid == addwlan->radioid) && (assignbssid->wlanid == addwlan->wlanid)) { if (assignbssid && (assignbssid->radioid == addwlan->radioid) && (assignbssid->wlanid == addwlan->wlanid)) {
wlan = ac_wlans_create_bssid(assignbssid->radioid, assignbssid->wlanid, assignbssid->bssid, addwlan); wlan = ac_wlans_create_bssid(&session->wlans->devices[assignbssid->radioid - 1], assignbssid->wlanid, assignbssid->bssid, addwlan);
/* Assign BSSID to session */ /* Assign BSSID to session */
ac_session_data_send_action(session->sessiondata, AC_SESSION_DATA_ACTION_ASSIGN_BSSID, 0, &wlan, sizeof(struct ac_wlan*)); ac_session_data_send_action(session->sessiondata, AC_SESSION_DATA_ACTION_ASSIGN_BSSID, 0, &wlan, sizeof(struct ac_wlan*));

6
src/ac/ac_execute.c
View File

@ -532,6 +532,9 @@ static struct ac_session_t* ac_create_session(struct sockaddr_storage* wtpaddres
memcpy(&session->connection.localaddr, acaddress, sizeof(struct sockaddr_storage)); memcpy(&session->connection.localaddr, acaddress, sizeof(struct sockaddr_storage));
memcpy(&session->connection.remoteaddr, wtpaddress, sizeof(struct sockaddr_storage)); memcpy(&session->connection.remoteaddr, wtpaddress, sizeof(struct sockaddr_storage));
/* */
ac_wlans_init(session);
/* */ /* */
session->count = 2; session->count = 2;
capwap_event_init(&session->changereference); capwap_event_init(&session->changereference);
@ -618,9 +621,6 @@ static struct ac_session_data_t* ac_create_session_data(struct sockaddr_storage*
sessiondata->count = 2; sessiondata->count = 2;
capwap_event_init(&sessiondata->changereference); capwap_event_init(&sessiondata->changereference);
/* */
ac_wlans_init(sessiondata);
/* */ /* */
sessiondata->timeout = capwap_timeout_init(); sessiondata->timeout = capwap_timeout_init();
sessiondata->idtimercontrol = capwap_timeout_createtimer(sessiondata->timeout); sessiondata->idtimercontrol = capwap_timeout_createtimer(sessiondata->timeout);

168
src/ac/ac_ieee80211_data.c
View File

@ -26,6 +26,7 @@ static void ac_ieee80211_mgmt_authentication_packet(struct ac_session_data_t* se
int ielength; int ielength;
struct ieee80211_ie_items ieitems; struct ieee80211_ie_items ieitems;
struct ac_station* station; struct ac_station* station;
struct ac_wlan* wlan;
/* Parsing Information Elements */ /* Parsing Information Elements */
ielength = mgmtlength - (sizeof(struct ieee80211_header) + sizeof(mgmt->authetication)); ielength = mgmtlength - (sizeof(struct ieee80211_header) + sizeof(mgmt->authetication));
@ -35,24 +36,79 @@ static void ac_ieee80211_mgmt_authentication_packet(struct ac_session_data_t* se
/* */ /* */
if (memcmp(mgmt->bssid, mgmt->sa, MACADDRESS_EUI48_LENGTH) && !memcmp(mgmt->bssid, mgmt->da, MACADDRESS_EUI48_LENGTH)) { if (memcmp(mgmt->bssid, mgmt->sa, MACADDRESS_EUI48_LENGTH) && !memcmp(mgmt->bssid, mgmt->da, MACADDRESS_EUI48_LENGTH)) {
station = ac_stations_create_station(sessiondata, radioid, mgmt->bssid, mgmt->sa); station = ac_stations_create_station(sessiondata->session, radioid, mgmt->bssid, mgmt->sa);
if (!station || !station->wlan) {
return;
}
/* */ /* */
capwap_logging_info("Receive IEEE802.11 Authentication Request from %s station", station->addrtext); capwap_logging_info("Receive IEEE802.11 Authentication Request from %s station", station->addrtext);
/* A station is removed if the association does not complete within a given period of time */ /* A station is removed if the association does not complete within a given period of time */
station->timeoutaction = AC_STATION_TIMEOUT_ACTION_DEAUTHENTICATE; station->timeoutaction = AC_STATION_TIMEOUT_ACTION_DEAUTHENTICATE;
station->idtimeout = capwap_timeout_set(sessiondata->timeout, station->idtimeout, AC_STATION_TIMEOUT_ASSOCIATION_COMPLETE, ac_stations_timeout, station, sessiondata); station->idtimeout = capwap_timeout_set(sessiondata->timeout, station->idtimeout, AC_STATION_TIMEOUT_ASSOCIATION_COMPLETE, ac_stations_timeout, station, sessiondata->session);
/* */ /* */
if (station->wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_LOCAL) { wlan = station->wlan;
/* TODO */ if (wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_LOCAL) {
} else if (station->wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_SPLIT) {
/* TODO */ /* TODO */
} else if (wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_SPLIT) {
uint16_t algorithm;
uint16_t transactionseqnumber;
uint16_t responsestatuscode;
uint8_t buffer[IEEE80211_MTU];
struct ieee80211_authentication_params ieee80211_params;
int responselength;
/* Parsing Information Elements */
if (ieee80211_retrieve_information_elements_position(&ieitems, &mgmt->authetication.ie[0], ielength)) {
capwap_logging_info("Invalid IEEE802.11 Authentication Request from %s station", station->addrtext);
return;
}
/* */
algorithm = __le16_to_cpu(mgmt->authetication.algorithm);
transactionseqnumber = __le16_to_cpu(mgmt->authetication.transactionseqnumber);
/* */
responsestatuscode = IEEE80211_STATUS_NOT_SUPPORTED_AUTHENTICATION_ALGORITHM;
if ((algorithm == IEEE80211_AUTHENTICATION_ALGORITHM_OPEN) && (wlan->authmode == CAPWAP_ADD_WLAN_AUTHTYPE_OPEN)) {
if (transactionseqnumber == 1) {
responsestatuscode = IEEE80211_STATUS_SUCCESS;
station->authalgorithm = IEEE80211_AUTHENTICATION_ALGORITHM_OPEN;
} else {
responsestatuscode = IEEE80211_STATUS_UNKNOWN_AUTHENTICATION_TRANSACTION;
}
} else if ((algorithm == IEEE80211_AUTHENTICATION_ALGORITHM_SHARED_KEY) && (wlan->authmode == CAPWAP_ADD_WLAN_AUTHTYPE_WEP)) {
/* TODO */
}
/* Create authentication packet */
memset(&ieee80211_params, 0, sizeof(struct ieee80211_authentication_params));
memcpy(ieee80211_params.bssid, wlan->address, MACADDRESS_EUI48_LENGTH);
memcpy(ieee80211_params.station, mgmt->sa, MACADDRESS_EUI48_LENGTH);
ieee80211_params.algorithm = algorithm;
ieee80211_params.transactionseqnumber = transactionseqnumber + 1;
ieee80211_params.statuscode = responsestatuscode;
responselength = ieee80211_create_authentication_response(buffer, sizeof(buffer), &ieee80211_params);
if (responselength > 0) {
/* Send authentication response */
if (!ac_session_data_send_data_packet(sessiondata, wlan->device->radioid, wlan->wlanid, buffer, responselength, 1)) {
capwap_logging_info("Sent IEEE802.11 Authentication Response to %s station with %d status code", station->addrtext, (int)responsestatuscode);
station->flags |= AC_STATION_FLAGS_AUTHENTICATED;
} else {
capwap_logging_warning("Unable to send IEEE802.11 Authentication Response to %s station", station->addrtext);
ac_stations_delete_station(sessiondata->session, station);
}
} else {
capwap_logging_warning("Unable to create IEEE802.11 Authentication Response to %s station", station->addrtext);
ac_stations_delete_station(sessiondata->session, station);
}
} }
} else if (!memcmp(mgmt->bssid, mgmt->sa, MACADDRESS_EUI48_LENGTH) && memcmp(mgmt->bssid, mgmt->da, MACADDRESS_EUI48_LENGTH)) { } else if (!memcmp(mgmt->bssid, mgmt->sa, MACADDRESS_EUI48_LENGTH) && memcmp(mgmt->bssid, mgmt->da, MACADDRESS_EUI48_LENGTH)) {
station = ac_stations_get_station(sessiondata, radioid, mgmt->bssid, mgmt->da); station = ac_stations_get_station(sessiondata->session, radioid, mgmt->bssid, mgmt->da);
if (station && (station->wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_LOCAL)) { if (station && station->wlan && (station->wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_LOCAL)) {
uint16_t algorithm; uint16_t algorithm;
uint16_t transactionseqnumber; uint16_t transactionseqnumber;
uint16_t statuscode; uint16_t statuscode;
@ -83,6 +139,7 @@ static void ac_ieee80211_mgmt_association_request_packet(struct ac_session_data_
int ielength; int ielength;
struct ieee80211_ie_items ieitems; struct ieee80211_ie_items ieitems;
struct ac_station* station; struct ac_station* station;
struct ac_wlan* wlan;
/* Parsing Information Elements */ /* Parsing Information Elements */
ielength = mgmtlength - (sizeof(struct ieee80211_header) + sizeof(mgmt->associationrequest)); ielength = mgmtlength - (sizeof(struct ieee80211_header) + sizeof(mgmt->associationrequest));
@ -92,11 +149,23 @@ static void ac_ieee80211_mgmt_association_request_packet(struct ac_session_data_
/* Get station */ /* Get station */
if (memcmp(mgmt->bssid, mgmt->sa, MACADDRESS_EUI48_LENGTH) && !memcmp(mgmt->bssid, mgmt->da, MACADDRESS_EUI48_LENGTH)) { if (memcmp(mgmt->bssid, mgmt->sa, MACADDRESS_EUI48_LENGTH) && !memcmp(mgmt->bssid, mgmt->da, MACADDRESS_EUI48_LENGTH)) {
station = ac_stations_get_station(sessiondata, radioid, mgmt->bssid, mgmt->sa); station = ac_stations_get_station(sessiondata->session, radioid, mgmt->bssid, mgmt->sa);
if (!station || !station->wlan) {
return;
}
/* */ /* */
capwap_logging_info("Receive IEEE802.11 Association Request from %s station", station->addrtext); capwap_logging_info("Receive IEEE802.11 Association Request from %s station", station->addrtext);
/* */
wlan = station->wlan;
if (!(station->flags & AC_STATION_FLAGS_AUTHENTICATED)) {
/* Invalid station, delete station */
capwap_logging_info("Receive IEEE802.11 Association Request from %s unauthorized station", station->addrtext);
ac_stations_delete_station(sessiondata->session, station);
return;
}
/* Get Station Info */ /* Get Station Info */
station->capability = __le16_to_cpu(mgmt->associationrequest.capability); station->capability = __le16_to_cpu(mgmt->associationrequest.capability);
station->listeninterval = __le16_to_cpu(mgmt->associationrequest.listeninterval); station->listeninterval = __le16_to_cpu(mgmt->associationrequest.listeninterval);
@ -111,13 +180,76 @@ static void ac_ieee80211_mgmt_association_request_packet(struct ac_session_data_
} }
/* */ /* */
if (station->wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_LOCAL) { if (wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_LOCAL) {
/* TODO */
} else if (station->wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_SPLIT) {
/* TODO */ /* TODO */
} else if (wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_SPLIT) {
int responselength;
struct ieee80211_ie_items ieitems;
struct ieee80211_associationresponse_params ieee80211_params;
uint16_t resultstatuscode;
uint8_t buffer[IEEE80211_MTU];
/* Active Station */ /* Parsing Information Elements */
ac_stations_authorize_station(sessiondata, station); if (ieee80211_retrieve_information_elements_position(&ieitems, &mgmt->associationrequest.ie[0], ielength)) {
capwap_logging_info("Invalid IEEE802.11 Association Request from %s station", station->addrtext);
ac_stations_delete_station(sessiondata->session, station);
return;
}
/* Verify SSID */
if (ieee80211_is_valid_ssid(wlan->ssid, ieitems.ssid, NULL) != IEEE80211_VALID_SSID) {
resultstatuscode = IEEE80211_STATUS_UNSPECIFIED_FAILURE;
} else {
/* Check supported rates */
if (!ieitems.supported_rates || ((ieitems.supported_rates->len + (ieitems.extended_supported_rates ? ieitems.extended_supported_rates->len : 0)) > sizeof(station->supportedrates))) {
resultstatuscode = IEEE80211_STATUS_UNSPECIFIED_FAILURE;
} else {
station->capability = __le16_to_cpu(mgmt->associationrequest.capability);
station->listeninterval = __le16_to_cpu(mgmt->associationrequest.listeninterval);
if (ieee80211_aid_create(wlan->aidbitfield, &station->aid)) {
resultstatuscode = IEEE80211_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA;
} else {
/* Get supported rates */
station->supportedratescount = ieitems.supported_rates->len;
memcpy(station->supportedrates, ieitems.supported_rates->rates, ieitems.supported_rates->len);
if (ieitems.extended_supported_rates) {
station->supportedratescount += ieitems.extended_supported_rates->len;
memcpy(&station->supportedrates[ieitems.supported_rates->len], ieitems.extended_supported_rates->rates, ieitems.extended_supported_rates->len);
}
/* */
resultstatuscode = IEEE80211_STATUS_SUCCESS;
}
}
}
/* Create association response packet */
memset(&ieee80211_params, 0, sizeof(struct ieee80211_authentication_params));
memcpy(ieee80211_params.bssid, wlan->address, ETH_ALEN);
memcpy(ieee80211_params.station, mgmt->sa, ETH_ALEN);
ieee80211_params.capability = wlan->capability;
ieee80211_params.statuscode = resultstatuscode;
ieee80211_params.aid = IEEE80211_AID_FIELD | station->aid;
memcpy(ieee80211_params.supportedrates, wlan->device->supportedrates, wlan->device->supportedratescount);
ieee80211_params.supportedratescount = wlan->device->supportedratescount;
responselength = ieee80211_create_associationresponse_response(buffer, sizeof(buffer), &ieee80211_params);
if (responselength > 0) {
/* Send association response */
if (!ac_session_data_send_data_packet(sessiondata, wlan->device->radioid, wlan->wlanid, buffer, responselength, 1)) {
capwap_logging_info("Sent IEEE802.11 Association Response to %s station with %d status code", station->addrtext, (int)resultstatuscode);
/* Active Station */
station->flags |= AC_STATION_FLAGS_ASSOCIATE;
ac_stations_authorize_station(sessiondata->session, station);
} else {
capwap_logging_warning("Unable to send IEEE802.11 Association Response to %s station", station->addrtext);
ac_stations_delete_station(sessiondata->session, station);
}
} else {
capwap_logging_warning("Unable to create IEEE802.11 Association Response to %s station", station->addrtext);
ac_stations_delete_station(sessiondata->session, station);
}
} }
} }
} }
@ -137,8 +269,8 @@ static void ac_ieee80211_mgmt_association_response_packet(struct ac_session_data
/* Get station */ /* Get station */
if (!memcmp(mgmt->bssid, mgmt->sa, MACADDRESS_EUI48_LENGTH) && memcmp(mgmt->bssid, mgmt->da, MACADDRESS_EUI48_LENGTH)) { if (!memcmp(mgmt->bssid, mgmt->sa, MACADDRESS_EUI48_LENGTH) && memcmp(mgmt->bssid, mgmt->da, MACADDRESS_EUI48_LENGTH)) {
station = ac_stations_get_station(sessiondata, radioid, mgmt->bssid, mgmt->da); station = ac_stations_get_station(sessiondata->session, radioid, mgmt->bssid, mgmt->da);
if (station && (station->wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_LOCAL)) { if (station && station->wlan && (station->wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_LOCAL)) {
capwap_logging_info("Receive IEEE802.11 Association Response to %s station with %d status code", station->addrtext, (int)mgmt->associationresponse.statuscode); capwap_logging_info("Receive IEEE802.11 Association Response to %s station with %d status code", station->addrtext, (int)mgmt->associationresponse.statuscode);
if (mgmt->associationresponse.statuscode == IEEE80211_STATUS_SUCCESS) { if (mgmt->associationresponse.statuscode == IEEE80211_STATUS_SUCCESS) {
@ -157,7 +289,7 @@ static void ac_ieee80211_mgmt_association_response_packet(struct ac_session_data
} }
/* Active Station */ /* Active Station */
ac_stations_authorize_station(sessiondata, station); ac_stations_authorize_station(sessiondata->session, station);
} }
} }
} }
@ -223,10 +355,10 @@ static void ac_ieee80211_mgmt_deauthentication_packet(struct ac_session_data_t*
stationaddress = (memcmp(mgmt->bssid, mgmt->sa, MACADDRESS_EUI48_LENGTH) ? mgmt->sa : mgmt->da); stationaddress = (memcmp(mgmt->bssid, mgmt->sa, MACADDRESS_EUI48_LENGTH) ? mgmt->sa : mgmt->da);
/* Delete station */ /* Delete station */
station = ac_stations_get_station(sessiondata, radioid, NULL, stationaddress); station = ac_stations_get_station(sessiondata->session, radioid, NULL, stationaddress);
if (station) { if (station) {
station->flags &= ~(AC_STATION_FLAGS_AUTHORIZED | AC_STATION_FLAGS_AUTHENTICATED | AC_STATION_FLAGS_ASSOCIATE); station->flags &= ~(AC_STATION_FLAGS_AUTHORIZED | AC_STATION_FLAGS_AUTHENTICATED | AC_STATION_FLAGS_ASSOCIATE);
ac_stations_delete_station(sessiondata, station); ac_stations_delete_station(sessiondata->session, station);
} }
} }

4
src/ac/ac_session.c
View File

@ -2,6 +2,7 @@
#include "ac.h" #include "ac.h"
#include "capwap_dfa.h" #include "capwap_dfa.h"
#include "ac_session.h" #include "ac_session.h"
#include "ac_wlans.h"
#include "ac_backend.h" #include "ac_backend.h"
#include <arpa/inet.h> #include <arpa/inet.h>
@ -530,6 +531,9 @@ static void ac_session_destroy(struct ac_session_t* session) {
capwap_itemlist_free(capwap_itemlist_remove_head(session->packets)); capwap_itemlist_free(capwap_itemlist_remove_head(session->packets));
} }
/* Free WLANS */
ac_wlans_destroy(session);
/* */ /* */
capwap_event_destroy(&session->changereference); capwap_event_destroy(&session->changereference);
capwap_event_destroy(&session->waitpacket); capwap_event_destroy(&session->waitpacket);

8
src/ac/ac_session.h
View File

@ -123,9 +123,6 @@ struct ac_session_data_t {
long count; long count;
capwap_event_t changereference; capwap_event_t changereference;
/* WLAN Reference */
struct ac_wlans* wlans;
/* */ /* */
int enabledtls; int enabledtls;
unsigned short mtu; unsigned short mtu;
@ -161,6 +158,9 @@ struct ac_session_t {
/* Soap */ /* Soap */
struct ac_http_soap_request* soaprequest; struct ac_http_soap_request* soaprequest;
/* WLAN Reference */
struct ac_wlans* wlans;
/* */ /* */
char* wtpid; char* wtpid;
unsigned long state; unsigned long state;
@ -208,7 +208,7 @@ void ac_session_data_close(struct ac_session_data_t* sessiondata);
void ac_session_data_send_action(struct ac_session_data_t* sessiondata, long action, long param, void* data, long length); void ac_session_data_send_action(struct ac_session_data_t* sessiondata, long action, long param, void* data, long length);
void ac_session_data_release_reference(struct ac_session_data_t* sessiondata); void ac_session_data_release_reference(struct ac_session_data_t* sessiondata);
void ac_session_data_send_data_packet(struct ac_session_data_t* sessiondata, uint8_t radioid, uint8_t wlanid, const uint8_t* data, int length, int leavenativeframe); int ac_session_data_send_data_packet(struct ac_session_data_t* sessiondata, uint8_t radioid, uint8_t wlanid, const uint8_t* data, int length, int leavenativeframe);
/* IEEE802.11 Packet */ /* IEEE802.11 Packet */
void ac_ieee80211_packet(struct ac_session_data_t* sessiondata, uint8_t radioid, const struct ieee80211_header* header, int length); void ac_ieee80211_packet(struct ac_session_data_t* sessiondata, uint8_t radioid, const struct ieee80211_header* header, int length);

24
src/ac/ac_session_data.c
View File

@ -15,9 +15,9 @@ static int ac_session_data_action_add_station_status(struct ac_session_data_t* s
struct ac_wlan* wlan; struct ac_wlan* wlan;
struct ac_station* station; struct ac_station* station;
wlan = ac_wlans_get_bssid_with_wlanid(sessiondata, notify->radioid, notify->wlanid); wlan = ac_wlans_get_bssid_with_wlanid(sessiondata->session, notify->radioid, notify->wlanid);
if (wlan) { if (wlan) {
station = ac_stations_get_station(sessiondata, notify->radioid, wlan->bssid, notify->address); station = ac_stations_get_station(sessiondata->session, notify->radioid, wlan->address, notify->address);
if (station) { if (station) {
if (CAPWAP_RESULTCODE_OK(notify->statuscode)) { if (CAPWAP_RESULTCODE_OK(notify->statuscode)) {
capwap_logging_info("Authorized station: %s", station->addrtext); capwap_logging_info("Authorized station: %s", station->addrtext);
@ -27,7 +27,7 @@ static int ac_session_data_action_add_station_status(struct ac_session_data_t* s
capwap_timeout_deletetimer(sessiondata->timeout, station->idtimeout); capwap_timeout_deletetimer(sessiondata->timeout, station->idtimeout);
station->idtimeout = CAPWAP_TIMEOUT_INDEX_NO_SET; station->idtimeout = CAPWAP_TIMEOUT_INDEX_NO_SET;
} else { } else {
ac_stations_delete_station(sessiondata, station); ac_stations_delete_station(sessiondata->session, station);
} }
} }
} }
@ -39,12 +39,12 @@ static int ac_session_data_action_add_station_status(struct ac_session_data_t* s
static int ac_session_data_action_delete_station_status(struct ac_session_data_t* sessiondata, struct ac_notify_delete_station_status* notify) { static int ac_session_data_action_delete_station_status(struct ac_session_data_t* sessiondata, struct ac_notify_delete_station_status* notify) {
struct ac_station* station; struct ac_station* station;
station = ac_stations_get_station(sessiondata, notify->radioid, NULL, notify->address); station = ac_stations_get_station(sessiondata->session, notify->radioid, NULL, notify->address);
if (station) { if (station) {
capwap_logging_info("Deauthorized station: %s with %d result code", station->addrtext, (int)notify->statuscode); capwap_logging_info("Deauthorized station: %s with %d result code", station->addrtext, (int)notify->statuscode);
/* */ /* */
ac_stations_delete_station(sessiondata, station); ac_stations_delete_station(sessiondata->session, station);
} }
return AC_ERROR_ACTION_SESSION; return AC_ERROR_ACTION_SESSION;
@ -59,16 +59,16 @@ static int ac_session_data_action_execute(struct ac_session_data_t* sessiondata,
struct ac_station* station; struct ac_station* station;
/* Delete station */ /* Delete station */
station = ac_stations_get_station(sessiondata, RADIOID_ANY, NULL, (uint8_t*)action->data); station = ac_stations_get_station(sessiondata->session, RADIOID_ANY, NULL, (uint8_t*)action->data);
if (station) { if (station) {
ac_stations_delete_station(sessiondata, station); ac_stations_delete_station(sessiondata->session, station);
} }
break; break;
} }
case AC_SESSION_DATA_ACTION_ASSIGN_BSSID: { case AC_SESSION_DATA_ACTION_ASSIGN_BSSID: {
ac_wlans_assign_bssid(sessiondata, *(struct ac_wlan**)action->data); ac_wlans_assign_bssid(sessiondata->session, *(struct ac_wlan**)action->data);
break; break;
} }
@ -312,9 +312,6 @@ static void ac_session_data_destroy(struct ac_session_data_t* sessiondata) {
/* Free DTLS */ /* Free DTLS */
capwap_crypt_freesession(&sessiondata->dtls); capwap_crypt_freesession(&sessiondata->dtls);
/* Free WLANS */
ac_wlans_destroy(sessiondata);
/* Free resource */ /* Free resource */
while (sessiondata->packets->count > 0) { while (sessiondata->packets->count > 0) {
capwap_itemlist_free(capwap_itemlist_remove_head(sessiondata->packets)); capwap_itemlist_free(capwap_itemlist_remove_head(sessiondata->packets));
@ -492,7 +489,8 @@ void* ac_session_data_thread(void* param) {
} }
/* */ /* */
void ac_session_data_send_data_packet(struct ac_session_data_t* sessiondata, uint8_t radioid, uint8_t wlanid, const uint8_t* data, int length, int leavenativeframe) { int ac_session_data_send_data_packet(struct ac_session_data_t* sessiondata, uint8_t radioid, uint8_t wlanid, const uint8_t* data, int length, int leavenativeframe) {
int result = 0;
struct capwap_list* txfragpacket; struct capwap_list* txfragpacket;
struct capwap_header_data capwapheader; struct capwap_header_data capwapheader;
struct capwap_packet_txmng* txmngpacket; struct capwap_packet_txmng* txmngpacket;
@ -519,9 +517,11 @@ void ac_session_data_send_data_packet(struct ac_session_data_t* sessiondata, uin
/* */ /* */
if (!capwap_crypt_sendto_fragmentpacket(&sessiondata->dtls, sessiondata->connection.socket.socket[sessiondata->connection.socket.type], txfragpacket, &sessiondata->connection.localaddr, &sessiondata->connection.remoteaddr)) { if (!capwap_crypt_sendto_fragmentpacket(&sessiondata->dtls, sessiondata->connection.socket.socket[sessiondata->connection.socket.type], txfragpacket, &sessiondata->connection.localaddr, &sessiondata->connection.remoteaddr)) {
capwap_logging_debug("Warning: error to send data packet"); capwap_logging_debug("Warning: error to send data packet");
result = -1;
} }
/* Free packets manager */ /* Free packets manager */
capwap_list_free(txfragpacket); capwap_list_free(txfragpacket);
capwap_packet_txmng_free(txmngpacket); capwap_packet_txmng_free(txmngpacket);
return result;
} }

292
src/ac/ac_wlans.c
View File

@ -4,18 +4,18 @@
#include "ac_backend.h" #include "ac_backend.h"
/* */ /* */
static void ac_stations_delete_station_from_global_cache(struct ac_session_data_t* sessiondata, uint8_t* address) { static void ac_stations_delete_station_from_global_cache(struct ac_session_t* session, uint8_t* address) {
struct ac_session_data_t* ownersession; struct ac_session_t* ownersession;
ASSERT(sessiondata != NULL); ASSERT(session != NULL);
ASSERT(address != NULL); ASSERT(address != NULL);
/* */ /* */
capwap_rwlock_wrlock(&g_ac.stationslock); capwap_rwlock_wrlock(&g_ac.stationslock);
/* Can delete global reference only if match session handler */ /* Can delete global reference only if match session handler */
ownersession = (struct ac_session_data_t*)capwap_hash_search(g_ac.stations, address); ownersession = (struct ac_session_t*)capwap_hash_search(g_ac.stations, address);
if (ownersession == sessiondata) { if (ownersession == session) {
capwap_hash_delete(g_ac.stations, address); capwap_hash_delete(g_ac.stations, address);
} }
@ -23,18 +23,26 @@ static void ac_stations_delete_station_from_global_cache(struct ac_session_data_
} }
/* */ /* */
static void ac_stations_reset_station(struct ac_session_data_t* sessiondata, struct ac_station* station, struct ac_wlan* wlan) { static void ac_stations_reset_station(struct ac_session_t* session, struct ac_station* station, struct ac_wlan* wlan) {
ASSERT(sessiondata != NULL); ASSERT(session != NULL);
ASSERT(station != NULL); ASSERT(station != NULL);
/* Remove reference from current WLAN */
if (station->wlan) { if (station->wlan) {
if (station->aid) {
if (station->wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_SPLIT) {
ieee80211_aid_free(station->wlan->aidbitfield, station->aid);
}
station->aid = 0;
}
/* Remove reference from current WLAN */
capwap_itemlist_remove(station->wlan->stations, station->wlanitem); capwap_itemlist_remove(station->wlan->stations, station->wlanitem);
} }
/* Remove timers */ /* Remove timers */
if (station->idtimeout != CAPWAP_TIMEOUT_INDEX_NO_SET) { if (station->idtimeout != CAPWAP_TIMEOUT_INDEX_NO_SET) {
capwap_timeout_deletetimer(sessiondata->timeout, station->idtimeout); capwap_timeout_deletetimer(session->sessiondata->timeout, station->idtimeout);
station->idtimeout = CAPWAP_TIMEOUT_INDEX_NO_SET; station->idtimeout = CAPWAP_TIMEOUT_INDEX_NO_SET;
} }
@ -49,21 +57,21 @@ static void ac_stations_reset_station(struct ac_session_data_t* sessiondata, str
} }
/* */ /* */
static void ac_stations_destroy_station(struct ac_session_data_t* sessiondata, struct ac_station* station) { static void ac_stations_destroy_station(struct ac_session_t* session, struct ac_station* station) {
ASSERT(sessiondata != NULL); ASSERT(session != NULL);
ASSERT(station != NULL); ASSERT(station != NULL);
/* */ /* */
capwap_logging_info("Destroy station: %s", station->addrtext); capwap_logging_info("Destroy station: %s", station->addrtext);
/* Remove reference from Global Cache Stations List */ /* Remove reference from Global Cache Stations List */
ac_stations_delete_station_from_global_cache(sessiondata, station->address); ac_stations_delete_station_from_global_cache(session, station->address);
/* Remove reference from WLAN */ /* Remove reference from WLAN */
ac_stations_reset_station(sessiondata, station, NULL); ac_stations_reset_station(session, station, NULL);
/* */ /* */
capwap_hash_delete(sessiondata->wlans->stations, station->address); capwap_hash_delete(session->wlans->stations, station->address);
/* Free station reference with itemlist */ /* Free station reference with itemlist */
capwap_itemlist_free(station->wlanitem); capwap_itemlist_free(station->wlanitem);
@ -79,33 +87,39 @@ static unsigned long ac_wlans_item_gethash(const void* key, unsigned long keysiz
} }
/* */ /* */
void ac_wlans_init(struct ac_session_data_t* sessiondata) { void ac_wlans_init(struct ac_session_t* session) {
ASSERT(sessiondata != NULL); int i;
ASSERT(session != NULL);
ASSERT(session->wlans == NULL);
/* */ /* */
sessiondata->wlans = (struct ac_wlans*)capwap_alloc(sizeof(struct ac_wlans)); session->wlans = (struct ac_wlans*)capwap_alloc(sizeof(struct ac_wlans));
memset(sessiondata->wlans, 0, sizeof(struct ac_wlans)); memset(session->wlans, 0, sizeof(struct ac_wlans));
/* */ /* */
sessiondata->wlans->stations = capwap_hash_create(AC_WLANS_STATIONS_HASH_SIZE, AC_WLANS_STATIONS_KEY_SIZE, ac_wlans_item_gethash, NULL, NULL); session->wlans->stations = capwap_hash_create(AC_WLANS_STATIONS_HASH_SIZE, AC_WLANS_STATIONS_KEY_SIZE, ac_wlans_item_gethash, NULL, NULL);
for (i = 0; i < RADIOID_MAX_COUNT; i++) {
session->wlans->devices[i].radioid = i + 1;
}
} }
/* */ /* */
void ac_wlans_destroy(struct ac_session_data_t* sessiondata) { void ac_wlans_destroy(struct ac_session_t* session) {
int i; int i;
struct capwap_list* items; struct capwap_list* items;
ASSERT(sessiondata != NULL); ASSERT(session != NULL);
ASSERT(sessiondata->wlans != NULL); ASSERT(session->wlans != NULL);
/* */ /* */
for (i = 0; i < RADIOID_MAX_COUNT; i++) { for (i = 0; i < RADIOID_MAX_COUNT; i++) {
if (sessiondata->wlans->wlans[i]) { if (session->wlans->devices[i].wlans) {
items = sessiondata->wlans->wlans[i]; items = session->wlans->devices[i].wlans;
/* Delete WLANS */ /* Delete WLANS */
while (items->first) { while (items->first) {
ac_wlans_delete_bssid(sessiondata, i + 1, ((struct ac_wlan*)items->first->item)->bssid); ac_wlans_delete_bssid(session, i + 1, ((struct ac_wlan*)items->first->item)->address);
} }
/* */ /* */
@ -114,51 +128,52 @@ void ac_wlans_destroy(struct ac_session_data_t* sessiondata) {
} }
/* */ /* */
ASSERT(sessiondata->wlans->stations->count == 0); ASSERT(session->wlans->stations->count == 0);
/* */ /* */
capwap_hash_free(sessiondata->wlans->stations); capwap_hash_free(session->wlans->stations);
capwap_free(sessiondata->wlans); capwap_free(session->wlans);
} }
/* */ /* */
int ac_wlans_assign_bssid(struct ac_session_data_t* sessiondata, struct ac_wlan* wlan) { int ac_wlans_assign_bssid(struct ac_session_t* session, struct ac_wlan* wlan) {
char buffer[CAPWAP_MACADDRESS_EUI48_BUFFER]; char buffer[CAPWAP_MACADDRESS_EUI48_BUFFER];
ASSERT(sessiondata != NULL); ASSERT(session != NULL);
ASSERT(sessiondata->wlans != NULL); ASSERT(session->wlans != NULL);
ASSERT(wlan != NULL); ASSERT(wlan != NULL);
ASSERT(IS_VALID_RADIOID(wlan->radioid)); ASSERT(wlan->device != NULL);
ASSERT(IS_VALID_RADIOID(wlan->device->radioid));
ASSERT(IS_VALID_WLANID(wlan->wlanid)); ASSERT(IS_VALID_WLANID(wlan->wlanid));
/* */ /* */
if (ac_wlans_get_bssid(sessiondata, wlan->radioid, wlan->bssid)) { if (ac_wlans_get_bssid(session, wlan->device->radioid, wlan->address)) {
return 0; return 0;
} }
/* */ /* */
wlan->session = sessiondata->session; wlan->session = session;
wlan->sessiondata = sessiondata; wlan->sessiondata = session->sessiondata;
/* Create WLAN list */ /* Create WLAN list */
if (!sessiondata->wlans->wlans[wlan->radioid - 1]) { if (!session->wlans->devices[wlan->device->radioid - 1].wlans) {
sessiondata->wlans->wlans[wlan->radioid - 1] = capwap_list_create(); session->wlans->devices[wlan->device->radioid - 1].wlans = capwap_list_create();
} }
/* Append WLAN to list */ /* Append WLAN to list */
capwap_itemlist_insert_after(sessiondata->wlans->wlans[wlan->radioid - 1], NULL, wlan->wlanitem); capwap_itemlist_insert_after(session->wlans->devices[wlan->device->radioid - 1].wlans, NULL, wlan->wlanitem);
/* */ /* */
capwap_logging_info("Added new wlan with radioid: %d, wlanid: %d, bssid: %s", (int)wlan->radioid, (int)wlan->wlanid, capwap_printf_macaddress(buffer, wlan->bssid, MACADDRESS_EUI48_LENGTH)); capwap_logging_info("Added new wlan with radioid: %d, wlanid: %d, bssid: %s", (int)wlan->device->radioid, (int)wlan->wlanid, capwap_printf_macaddress(buffer, wlan->address, MACADDRESS_EUI48_LENGTH));
return 1; return 1;
} }
/* */ /* */
struct ac_wlan* ac_wlans_create_bssid(uint8_t radioid, uint8_t wlanid, const uint8_t* bssid, struct capwap_80211_addwlan_element* addwlan) { struct ac_wlan* ac_wlans_create_bssid(struct ac_device* device, uint8_t wlanid, const uint8_t* bssid, struct capwap_80211_addwlan_element* addwlan) {
struct ac_wlan* wlan; struct ac_wlan* wlan;
struct capwap_list_item* wlanitem; struct capwap_list_item* wlanitem;
ASSERT(IS_VALID_RADIOID(radioid)); ASSERT(device != NULL);
ASSERT(IS_VALID_WLANID(wlanid)); ASSERT(IS_VALID_WLANID(wlanid));
ASSERT(bssid != NULL); ASSERT(bssid != NULL);
@ -169,8 +184,8 @@ struct ac_wlan* ac_wlans_create_bssid(uint8_t radioid, uint8_t wlanid, const uin
/* Init WLAN */ /* Init WLAN */
wlan->wlanitem = wlanitem; wlan->wlanitem = wlanitem;
memcpy(wlan->bssid, bssid, MACADDRESS_EUI48_LENGTH); memcpy(wlan->address, bssid, MACADDRESS_EUI48_LENGTH);
wlan->radioid = radioid; wlan->device = device;
wlan->wlanid = wlanid; wlan->wlanid = wlanid;
wlan->stations = capwap_list_create(); wlan->stations = capwap_list_create();
@ -192,34 +207,30 @@ struct ac_wlan* ac_wlans_create_bssid(uint8_t radioid, uint8_t wlanid, const uin
wlan->tunnelmode = addwlan->tunnelmode; wlan->tunnelmode = addwlan->tunnelmode;
wlan->suppressssid = addwlan->suppressssid; wlan->suppressssid = addwlan->suppressssid;
wlan->ssid = (uint8_t*)capwap_duplicate_string((const char*)addwlan->ssid); strcpy(wlan->ssid, (const char*)addwlan->ssid);
return wlan; return wlan;
} }
/* */ /* */
struct ac_wlan* ac_wlans_get_bssid(struct ac_session_data_t* sessiondata, uint8_t radioid, const uint8_t* bssid) { struct ac_wlan* ac_wlans_get_bssid(struct ac_session_t* session, uint8_t radioid, const uint8_t* bssid) {
struct capwap_list_item* search; struct capwap_list_item* search;
struct ac_wlan* wlan = NULL; struct ac_wlan* wlan = NULL;
ASSERT(sessiondata != NULL); ASSERT(session != NULL);
ASSERT(sessiondata->wlans != NULL); ASSERT(session->wlans != NULL);
ASSERT(IS_VALID_RADIOID(radioid)); ASSERT(IS_VALID_RADIOID(radioid));
ASSERT(bssid != NULL); ASSERT(bssid != NULL);
/* */ /* */
if (sessiondata->wlans->wlans[radioid - 1]) { if (session->wlans->devices[radioid - 1].wlans) {
search = sessiondata->wlans->wlans[radioid - 1]->first; for (search = session->wlans->devices[radioid - 1].wlans->first; search; search = search->next) {
while (search) {
struct ac_wlan* item = (struct ac_wlan*)search->item; struct ac_wlan* item = (struct ac_wlan*)search->item;
if (!memcmp(bssid, item->bssid, MACADDRESS_EUI48_LENGTH)) { if (!memcmp(bssid, item->address, MACADDRESS_EUI48_LENGTH)) {
wlan = item; wlan = item;
break; break;
} }
/* Next */
search = search->next;
} }
} }
@ -227,28 +238,24 @@ struct ac_wlan* ac_wlans_get_bssid(struct ac_session_data_t* sessiondata, uint8_
} }
/* */ /* */
struct ac_wlan* ac_wlans_get_bssid_with_wlanid(struct ac_session_data_t* sessiondata, uint8_t radioid, uint8_t wlanid) { struct ac_wlan* ac_wlans_get_bssid_with_wlanid(struct ac_session_t* session, uint8_t radioid, uint8_t wlanid) {
struct capwap_list_item* search; struct capwap_list_item* search;
struct ac_wlan* wlan = NULL; struct ac_wlan* wlan = NULL;
ASSERT(sessiondata != NULL); ASSERT(session != NULL);
ASSERT(sessiondata->wlans != NULL); ASSERT(session->wlans != NULL);
ASSERT(IS_VALID_RADIOID(radioid)); ASSERT(IS_VALID_RADIOID(radioid));
ASSERT(IS_VALID_WLANID(wlanid)); ASSERT(IS_VALID_WLANID(wlanid));
/* */ /* */
if (sessiondata->wlans->wlans[radioid - 1]) { if (session->wlans->devices[radioid - 1].wlans) {
search = sessiondata->wlans->wlans[radioid - 1]->first; for (search = session->wlans->devices[radioid - 1].wlans->first; search; search = search->next) {
while (search) {
struct ac_wlan* item = (struct ac_wlan*)search->item; struct ac_wlan* item = (struct ac_wlan*)search->item;
if (wlanid == item->wlanid) { if (wlanid == item->wlanid) {
wlan = item; wlan = item;
break; break;
} }
/* Next */
search = search->next;
} }
} }
@ -256,19 +263,19 @@ struct ac_wlan* ac_wlans_get_bssid_with_wlanid(struct ac_session_data_t* session
} }
/* */ /* */
static void ac_wlans_destroy_bssid(struct ac_session_data_t* sessiondata, struct ac_wlan* wlan) { static void ac_wlans_destroy_bssid(struct ac_session_t* session, struct ac_wlan* wlan) {
ASSERT(session != NULL);
ASSERT(session->wlans != NULL);
ASSERT(wlan != NULL);
/* Free capability */ /* Free capability */
if (wlan->key) { if (wlan->key) {
capwap_free(wlan->key); capwap_free(wlan->key);
} }
if (wlan->ssid) {
capwap_free(wlan->ssid);
}
/* Remove stations */ /* Remove stations */
while (wlan->stations->first) { while (wlan->stations->first) {
ac_stations_destroy_station(sessiondata, (struct ac_station*)wlan->stations->first->item); ac_stations_destroy_station(session, (struct ac_station*)wlan->stations->first->item);
} }
/* */ /* */
@ -276,43 +283,39 @@ static void ac_wlans_destroy_bssid(struct ac_session_data_t* sessiondata, struct
} }
/* */ /* */
void ac_wlans_delete_bssid(struct ac_session_data_t* sessiondata, uint8_t radioid, const uint8_t* bssid) { void ac_wlans_delete_bssid(struct ac_session_t* session, uint8_t radioid, const uint8_t* bssid) {
struct capwap_list_item* search; struct capwap_list_item* search;
ASSERT(sessiondata != NULL); ASSERT(session != NULL);
ASSERT(sessiondata->wlans != NULL); ASSERT(session->wlans != NULL);
ASSERT(IS_VALID_RADIOID(radioid)); ASSERT(IS_VALID_RADIOID(radioid));
ASSERT(bssid != NULL); ASSERT(bssid != NULL);
/* */ /* */
if (sessiondata->wlans->wlans[radioid - 1]) { if (session->wlans->devices[radioid - 1].wlans) {
search = sessiondata->wlans->wlans[radioid - 1]->first; for (search = session->wlans->devices[radioid - 1].wlans->first; search; search = search->next) {
while (search) {
struct ac_wlan* item = (struct ac_wlan*)search->item; struct ac_wlan* item = (struct ac_wlan*)search->item;
if (!memcmp(bssid, item->bssid, MACADDRESS_EUI48_LENGTH)) { if (!memcmp(bssid, item->address, MACADDRESS_EUI48_LENGTH)) {
ac_wlans_destroy_bssid(sessiondata, item); ac_wlans_destroy_bssid(session, item);
capwap_itemlist_free(capwap_itemlist_remove(sessiondata->wlans->wlans[radioid - 1], search)); capwap_itemlist_free(capwap_itemlist_remove(session->wlans->devices[radioid - 1].wlans, search));
break; break;
} }
/* Next */
search = search->next;
} }
} }
} }
/* */ /* */
struct ac_station* ac_stations_get_station(struct ac_session_data_t* sessiondata, uint8_t radioid, const uint8_t* bssid, const uint8_t* address) { struct ac_station* ac_stations_get_station(struct ac_session_t* session, uint8_t radioid, const uint8_t* bssid, const uint8_t* address) {
struct ac_station* station; struct ac_station* station;
ASSERT(sessiondata != NULL); ASSERT(session != NULL);
ASSERT(sessiondata->wlans != NULL); ASSERT(session->wlans != NULL);
ASSERT(address != NULL); ASSERT(address != NULL);
/* Get station */ /* Get station */
station = (struct ac_station*)capwap_hash_search(sessiondata->wlans->stations, address); station = (struct ac_station*)capwap_hash_search(session->wlans->stations, address);
if (station && (station->flags & AC_STATION_FLAGS_ENABLED) && ((radioid == RADIOID_ANY) || (radioid == station->wlan->radioid)) && (!bssid || !memcmp(bssid, station->wlan->bssid, MACADDRESS_EUI48_LENGTH))) { if (station && (station->flags & AC_STATION_FLAGS_ENABLED) && ((radioid == RADIOID_ANY) || (radioid == station->wlan->device->radioid)) && (!bssid || !memcmp(bssid, station->wlan->address, MACADDRESS_EUI48_LENGTH))) {
return station; return station;
} }
@ -320,16 +323,16 @@ struct ac_station* ac_stations_get_station(struct ac_session_data_t* sessiondata
} }
/* */ /* */
struct ac_station* ac_stations_create_station(struct ac_session_data_t* sessiondata, uint8_t radioid, const uint8_t* bssid, const uint8_t* address) { struct ac_station* ac_stations_create_station(struct ac_session_t* session, uint8_t radioid, const uint8_t* bssid, const uint8_t* address) {
char buffer1[CAPWAP_MACADDRESS_EUI48_BUFFER]; char buffer1[CAPWAP_MACADDRESS_EUI48_BUFFER];
char buffer2[CAPWAP_MACADDRESS_EUI48_BUFFER]; char buffer2[CAPWAP_MACADDRESS_EUI48_BUFFER];
struct ac_wlan* wlan; struct ac_wlan* wlan;
struct ac_session_data_t* ownersession; struct ac_session_t* ownersession;
struct ac_station* station;
struct capwap_list_item* stationitem; struct capwap_list_item* stationitem;
struct ac_station* station = NULL;
ASSERT(sessiondata != NULL); ASSERT(session != NULL);
ASSERT(sessiondata->wlans != NULL); ASSERT(session->wlans != NULL);
ASSERT(IS_VALID_RADIOID(radioid)); ASSERT(IS_VALID_RADIOID(radioid));
ASSERT(bssid != NULL); ASSERT(bssid != NULL);
ASSERT(address != NULL); ASSERT(address != NULL);
@ -339,74 +342,79 @@ struct ac_station* ac_stations_create_station(struct ac_session_data_t* sessiond
capwap_printf_macaddress(buffer2, address, MACADDRESS_EUI48_LENGTH); capwap_printf_macaddress(buffer2, address, MACADDRESS_EUI48_LENGTH);
capwap_logging_info("Create station to radioid: %d, bssid: %s, station address: %s", (int)radioid, buffer1, buffer2); capwap_logging_info("Create station to radioid: %d, bssid: %s, station address: %s", (int)radioid, buffer1, buffer2);
/* Get session that owns the station */ /* */
capwap_rwlock_rdlock(&g_ac.stationslock); wlan = ac_wlans_get_bssid(session, radioid, bssid);
ownersession = (struct ac_session_data_t*)capwap_hash_search(g_ac.stations, address); if (wlan) {
capwap_rwlock_exit(&g_ac.stationslock); /* Get session that owns the station */
capwap_rwlock_rdlock(&g_ac.stationslock);
ownersession = (struct ac_session_t*)capwap_hash_search(g_ac.stations, address);
capwap_rwlock_exit(&g_ac.stationslock);
/* If request change owner of station */ /* If request change owner of station */
if (ownersession != sessiondata) { if (ownersession != session) {
/* Release station from old owner */ /* Release station from old owner */
if (ownersession) { if (ownersession) {
ac_session_data_send_action(ownersession, AC_SESSION_DATA_ACTION_ROAMING_STATION, 0, (void*)address, MACADDRESS_EUI48_LENGTH); ac_session_data_send_action(ownersession->sessiondata, AC_SESSION_DATA_ACTION_ROAMING_STATION, 0, (void*)address, MACADDRESS_EUI48_LENGTH);
}
/* Set station into Global Cache Stations List */
capwap_rwlock_wrlock(&g_ac.stationslock);
capwap_hash_add(g_ac.stations, address, session);
capwap_rwlock_exit(&g_ac.stationslock);
} }
/* Set station into Global Cache Stations List */
capwap_rwlock_wrlock(&g_ac.stationslock);
capwap_hash_add(g_ac.stations, address, sessiondata);
capwap_rwlock_exit(&g_ac.stationslock);
}
/* */
wlan = ac_wlans_get_bssid(sessiondata, radioid, bssid);
station = (struct ac_station*)capwap_hash_search(sessiondata->wlans->stations, address);
if (!station) {
stationitem = capwap_itemlist_create(sizeof(struct ac_station));
station = (struct ac_station*)stationitem->item;
memset(station, 0, sizeof(struct ac_station));
/* */ /* */
station->idtimeout = CAPWAP_TIMEOUT_INDEX_NO_SET; station = (struct ac_station*)capwap_hash_search(session->wlans->stations, address);
memcpy(station->address, address, MACADDRESS_EUI48_LENGTH); if (!station) {
capwap_printf_macaddress(station->addrtext, address, MACADDRESS_EUI48_LENGTH); stationitem = capwap_itemlist_create(sizeof(struct ac_station));
station->wlanitem = stationitem; station = (struct ac_station*)stationitem->item;
memset(station, 0, sizeof(struct ac_station));
/* */ /* */
capwap_hash_add(sessiondata->wlans->stations, address, station); station->idtimeout = CAPWAP_TIMEOUT_INDEX_NO_SET;
memcpy(station->address, address, MACADDRESS_EUI48_LENGTH);
capwap_printf_macaddress(station->addrtext, address, MACADDRESS_EUI48_LENGTH);
station->wlanitem = stationitem;
/* */
capwap_hash_add(session->wlans->stations, address, station);
}
/* Set station to WLAN */
ac_stations_reset_station(session, station, wlan);
station->flags |= AC_STATION_FLAGS_ENABLED;
} else {
capwap_logging_warning("Unable to find radioid: %d, bssid: %s", (int)radioid, buffer1);
} }
/* Set station to WLAN */
ac_stations_reset_station(sessiondata, station, wlan);
station->flags |= AC_STATION_FLAGS_ENABLED;
return station; return station;
} }
/* */ /* */
void ac_stations_delete_station(struct ac_session_data_t* sessiondata, struct ac_station* station) { void ac_stations_delete_station(struct ac_session_t* session, struct ac_station* station) {
ASSERT(sessiondata != NULL); ASSERT(session != NULL);
ASSERT(sessiondata->wlans != NULL); ASSERT(session->wlans != NULL);
ASSERT(station != NULL); ASSERT(station != NULL);
/* Deauthorize station */ /* Deauthorize station */
ac_stations_deauthorize_station(sessiondata, station); ac_stations_deauthorize_station(session, station);
/* Destroy station reference */ /* Destroy station reference */
ac_stations_destroy_station(sessiondata, station); ac_stations_destroy_station(session, station);
} }
/* */ /* */
void ac_stations_authorize_station(struct ac_session_data_t* sessiondata, struct ac_station* station) { void ac_stations_authorize_station(struct ac_session_t* session, struct ac_station* station) {
struct ac_notify_station_configuration_ieee8011_add_station notify; struct ac_notify_station_configuration_ieee8011_add_station notify;
ASSERT(sessiondata != NULL); ASSERT(session != NULL);
ASSERT(sessiondata->wlans != NULL); ASSERT(session->wlans != NULL);
ASSERT(station != NULL); ASSERT(station != NULL);
/* Active Station only if Authenticated, Associated and not Authrizated */ /* Active Station only if Authenticated, Associated and not Authrizated */
if ((station->flags & AC_STATION_FLAGS_AUTHENTICATED) && (station->flags & AC_STATION_FLAGS_ASSOCIATE) && !(station->flags & AC_STATION_FLAGS_AUTHORIZED)) { if ((station->flags & AC_STATION_FLAGS_AUTHENTICATED) && (station->flags & AC_STATION_FLAGS_ASSOCIATE) && !(station->flags & AC_STATION_FLAGS_AUTHORIZED)) {
memset(&notify, 0, sizeof(struct ac_notify_station_configuration_ieee8011_add_station)); memset(&notify, 0, sizeof(struct ac_notify_station_configuration_ieee8011_add_station));
notify.radioid = station->wlan->radioid; notify.radioid = station->wlan->device->radioid;
memcpy(notify.address, station->address, MACADDRESS_EUI48_LENGTH); memcpy(notify.address, station->address, MACADDRESS_EUI48_LENGTH);
notify.wlanid = station->wlan->wlanid; notify.wlanid = station->wlan->wlanid;
notify.associationid = station->aid; notify.associationid = station->aid;
@ -414,34 +422,34 @@ void ac_stations_authorize_station(struct ac_session_data_t* sessiondata, struct
notify.supportedratescount = station->supportedratescount; notify.supportedratescount = station->supportedratescount;
memcpy(notify.supportedrates, station->supportedrates, station->supportedratescount); memcpy(notify.supportedrates, station->supportedrates, station->supportedratescount);
ac_session_send_action(sessiondata->session, AC_SESSION_ACTION_STATION_CONFIGURATION_IEEE80211_ADD_STATION, 0, &notify, sizeof(struct ac_notify_station_configuration_ieee8011_add_station)); ac_session_send_action(session, AC_SESSION_ACTION_STATION_CONFIGURATION_IEEE80211_ADD_STATION, 0, &notify, sizeof(struct ac_notify_station_configuration_ieee8011_add_station));
} }
} }
/* */ /* */
void ac_stations_deauthorize_station(struct ac_session_data_t* sessiondata, struct ac_station* station) { void ac_stations_deauthorize_station(struct ac_session_t* session, struct ac_station* station) {
int responselength; int responselength;
uint8_t buffer[IEEE80211_MTU]; uint8_t buffer[IEEE80211_MTU];
struct ieee80211_deauthentication_params ieee80211_params; struct ieee80211_deauthentication_params ieee80211_params;
struct ac_notify_station_configuration_ieee8011_delete_station notify; struct ac_notify_station_configuration_ieee8011_delete_station notify;
ASSERT(sessiondata != NULL); ASSERT(session != NULL);
ASSERT(sessiondata->wlans != NULL); ASSERT(session->wlans != NULL);
ASSERT(station != NULL); ASSERT(station != NULL);
if (station->flags & AC_STATION_FLAGS_AUTHORIZED) { if (station->flags & AC_STATION_FLAGS_AUTHORIZED) {
/* Deauthorize station */ /* Deauthorize station */
memset(&notify, 0, sizeof(struct ac_notify_station_configuration_ieee8011_delete_station)); memset(&notify, 0, sizeof(struct ac_notify_station_configuration_ieee8011_delete_station));
notify.radioid = station->wlan->radioid; notify.radioid = station->wlan->device->radioid;
memcpy(notify.address, station->address, MACADDRESS_EUI48_LENGTH); memcpy(notify.address, station->address, MACADDRESS_EUI48_LENGTH);
/* */ /* */
station->flags &= ~(AC_STATION_FLAGS_AUTHENTICATED | AC_STATION_FLAGS_ASSOCIATE | AC_STATION_FLAGS_AUTHORIZED); station->flags &= ~(AC_STATION_FLAGS_AUTHENTICATED | AC_STATION_FLAGS_ASSOCIATE | AC_STATION_FLAGS_AUTHORIZED);
ac_session_send_action(sessiondata->session, AC_SESSION_ACTION_STATION_CONFIGURATION_IEEE80211_DELETE_STATION, 0, &notify, sizeof(struct ac_notify_station_configuration_ieee8011_delete_station)); ac_session_send_action(session, AC_SESSION_ACTION_STATION_CONFIGURATION_IEEE80211_DELETE_STATION, 0, &notify, sizeof(struct ac_notify_station_configuration_ieee8011_delete_station));
} else if (station->flags & AC_STATION_FLAGS_AUTHENTICATED) { } else if (station->flags & AC_STATION_FLAGS_AUTHENTICATED) {
/* Create deauthentication packet */ /* Create deauthentication packet */
memset(&ieee80211_params, 0, sizeof(struct ieee80211_deauthentication_params)); memset(&ieee80211_params, 0, sizeof(struct ieee80211_deauthentication_params));
memcpy(ieee80211_params.bssid, station->wlan->bssid, MACADDRESS_EUI48_LENGTH); memcpy(ieee80211_params.bssid, station->wlan->address, MACADDRESS_EUI48_LENGTH);
memcpy(ieee80211_params.station, station->address, MACADDRESS_EUI48_LENGTH); memcpy(ieee80211_params.station, station->address, MACADDRESS_EUI48_LENGTH);
ieee80211_params.reasoncode = IEEE80211_REASON_PREV_AUTH_NOT_VALID; ieee80211_params.reasoncode = IEEE80211_REASON_PREV_AUTH_NOT_VALID;
@ -449,7 +457,7 @@ void ac_stations_deauthorize_station(struct ac_session_data_t* sessiondata, stru
responselength = ieee80211_create_deauthentication(buffer, IEEE80211_MTU, &ieee80211_params); responselength = ieee80211_create_deauthentication(buffer, IEEE80211_MTU, &ieee80211_params);
if (responselength > 0) { if (responselength > 0) {
station->flags &= ~(AC_STATION_FLAGS_AUTHENTICATED | AC_STATION_FLAGS_ASSOCIATE); station->flags &= ~(AC_STATION_FLAGS_AUTHENTICATED | AC_STATION_FLAGS_ASSOCIATE);
ac_session_data_send_data_packet(sessiondata, station->wlan->radioid, station->wlan->wlanid, buffer, responselength, 1); ac_session_data_send_data_packet(session->sessiondata, station->wlan->device->radioid, station->wlan->wlanid, buffer, responselength, 1);
} }
} }
} }
@ -464,7 +472,7 @@ void ac_stations_timeout(struct capwap_timeout* timeout, unsigned long index, vo
switch (station->timeoutaction) { switch (station->timeoutaction) {
case AC_STATION_TIMEOUT_ACTION_DEAUTHENTICATE: { case AC_STATION_TIMEOUT_ACTION_DEAUTHENTICATE: {
capwap_logging_warning("The %s station has not completed the association in time", station->addrtext); capwap_logging_warning("The %s station has not completed the association in time", station->addrtext);
ac_stations_delete_station((struct ac_session_data_t*)param, station); ac_stations_delete_station((struct ac_session_t*)param, station);
break; break;
} }
} }

58
src/ac/ac_wlans.h
View File

@ -13,15 +13,17 @@
/* AC WLAN */ /* AC WLAN */
struct ac_wlan { struct ac_wlan {
struct capwap_list_item* wlanitem; struct capwap_list_item* wlanitem;
struct ac_device* device;
uint8_t bssid[MACADDRESS_EUI48_LENGTH]; uint8_t address[MACADDRESS_EUI48_LENGTH];
uint8_t radioid;
uint8_t wlanid; uint8_t wlanid;
/* CAPWAP Session */ /* CAPWAP Session */
struct ac_session_t* session; struct ac_session_t* session;
struct ac_session_data_t* sessiondata; struct ac_session_data_t* sessiondata;
uint32_t aidbitfield[IEEE80211_AID_BITFIELD_SIZE];
/* Stations reference */ /* Stations reference */
struct capwap_list* stations; struct capwap_list* stations;
@ -37,7 +39,25 @@ struct ac_wlan {
uint8_t macmode; uint8_t macmode;
uint8_t tunnelmode; uint8_t tunnelmode;
uint8_t suppressssid; uint8_t suppressssid;
uint8_t* ssid; char ssid[IEEE80211_SSID_MAX_LENGTH + 1];
};
/* */
struct ac_device {
uint8_t radioid;
struct capwap_list* wlans;
/* Rates */
unsigned long supportedratescount;
uint8_t supportedrates[IEEE80211_SUPPORTEDRATE_MAX_COUNT];
};
/* */
struct ac_wlans {
struct ac_device devices[RADIOID_MAX_COUNT];
/* Stations */
struct capwap_hash* stations;
}; };
/* */ /* */
@ -81,31 +101,23 @@ struct ac_station {
uint16_t authalgorithm; uint16_t authalgorithm;
}; };
/* */
struct ac_wlans {
struct capwap_list* wlans[RADIOID_MAX_COUNT];
/* Stations */
struct capwap_hash* stations;
};
/* Management WLANS */ /* Management WLANS */
void ac_wlans_init(struct ac_session_data_t* sessiondata); void ac_wlans_init(struct ac_session_t* session);
void ac_wlans_destroy(struct ac_session_data_t* sessiondata); void ac_wlans_destroy(struct ac_session_t* session);
/* */ /* */
struct ac_wlan* ac_wlans_create_bssid(uint8_t radioid, uint8_t wlanid, const uint8_t* bssid, struct capwap_80211_addwlan_element* addwlan); struct ac_wlan* ac_wlans_create_bssid(struct ac_device* device, uint8_t wlanid, const uint8_t* bssid, struct capwap_80211_addwlan_element* addwlan);
int ac_wlans_assign_bssid(struct ac_session_data_t* sessiondata, struct ac_wlan* wlan); int ac_wlans_assign_bssid(struct ac_session_t* session, struct ac_wlan* wlan);
struct ac_wlan* ac_wlans_get_bssid(struct ac_session_data_t* sessiondata, uint8_t radioid, const uint8_t* bssid); struct ac_wlan* ac_wlans_get_bssid(struct ac_session_t* session, uint8_t radioid, const uint8_t* bssid);
struct ac_wlan* ac_wlans_get_bssid_with_wlanid(struct ac_session_data_t* sessiondata, uint8_t radioid, uint8_t wlanid); struct ac_wlan* ac_wlans_get_bssid_with_wlanid(struct ac_session_t* session, uint8_t radioid, uint8_t wlanid);
void ac_wlans_delete_bssid(struct ac_session_data_t* sessiondata, uint8_t radioid, const uint8_t* bssid); void ac_wlans_delete_bssid(struct ac_session_t* session, uint8_t radioid, const uint8_t* bssid);
/* Management Stations */ /* Management Stations */
struct ac_station* ac_stations_create_station(struct ac_session_data_t* sessiondata, uint8_t radioid, const uint8_t* bssid, const uint8_t* address); struct ac_station* ac_stations_create_station(struct ac_session_t* session, uint8_t radioid, const uint8_t* bssid, const uint8_t* address);
struct ac_station* ac_stations_get_station(struct ac_session_data_t* sessiondata, uint8_t radioid, const uint8_t* bssid, const uint8_t* address); struct ac_station* ac_stations_get_station(struct ac_session_t* session, uint8_t radioid, const uint8_t* bssid, const uint8_t* address);
void ac_stations_delete_station(struct ac_session_data_t* sessiondata, struct ac_station* station); void ac_stations_delete_station(struct ac_session_t* session, struct ac_station* station);
void ac_stations_authorize_station(struct ac_session_data_t* sessiondata, struct ac_station* station); void ac_stations_authorize_station(struct ac_session_t* session, struct ac_station* station);
void ac_stations_deauthorize_station(struct ac_session_data_t* sessiondata, struct ac_station* station); void ac_stations_deauthorize_station(struct ac_session_t* session, struct ac_station* station);
/* */ /* */
void ac_stations_timeout(struct capwap_timeout* timeout, unsigned long index, void* context, void* param); void ac_stations_timeout(struct capwap_timeout* timeout, unsigned long index, void* context, void* param);

2
src/common/binding/ieee80211/ieee80211.h
View File

@ -13,6 +13,8 @@
#define IEEE80211_MTU 7981 #define IEEE80211_MTU 7981
#define IEEE80211_SUPPORTEDRATE_MAX_COUNT 16 #define IEEE80211_SUPPORTEDRATE_MAX_COUNT 16
#define IEEE80211_MAX_STATIONS 2007 #define IEEE80211_MAX_STATIONS 2007
#define IEEE80211_SSID_MAX_LENGTH 32
/* Radio type with value same of IEEE802.11 Radio Information Message Element */ /* Radio type with value same of IEEE802.11 Radio Information Message Element */
#define IEEE80211_RADIO_TYPE_80211B 0x00000001 #define IEEE80211_RADIO_TYPE_80211B 0x00000001

156
src/wtp/binding/ieee80211/wifi_drivers.c
View File

@ -180,7 +180,7 @@ static void wifi_station_clean(struct wifi_station* station) {
wlan->device->instance->ops->station_deauthorize(wlan, station->address); wlan->device->instance->ops->station_deauthorize(wlan, station->address);
} }
if (station->aid) { if (station->aid && (wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_LOCAL)) {
ieee80211_aid_free(wlan->aidbitfield, station->aid); ieee80211_aid_free(wlan->aidbitfield, station->aid);
station->aid = 0; station->aid = 0;
} }
@ -429,35 +429,9 @@ static void wifi_wlan_receive_station_mgmt_probe_request(struct wifi_wlan* wlan,
} }
/* */ /* */
static int wifi_wlan_set_station_information(struct wifi_wlan* wlan, const struct ieee80211_header_mgmt* frame, struct ieee80211_ie_items* ieitems, struct wifi_station* station) { static void wifi_wlan_management_legacy_station(struct wifi_wlan* wlan, struct wifi_station* station) {
int updatebeacons = 0; int updatebeacons = 0;
/* Verify SSID */
if (ieee80211_is_valid_ssid(wlan->ssid, ieitems->ssid, NULL) != IEEE80211_VALID_SSID) {
return IEEE80211_STATUS_UNSPECIFIED_FAILURE;
}
/* */
station->capability = __le16_to_cpu(frame->associationrequest.capability);
station->listeninterval = __le16_to_cpu(frame->associationrequest.listeninterval);
if (ieee80211_aid_create(wlan->aidbitfield, &station->aid)) {
return IEEE80211_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA;
}
/* Get supported rates */
if (!ieitems->supported_rates) {
return IEEE80211_STATUS_UNSPECIFIED_FAILURE;
} else if ((ieitems->supported_rates->len + (ieitems->extended_supported_rates ? ieitems->extended_supported_rates->len : 0)) > sizeof(station->supportedrates)) {
return IEEE80211_STATUS_UNSPECIFIED_FAILURE;
}
station->supportedratescount = ieitems->supported_rates->len;
memcpy(station->supportedrates, ieitems->supported_rates->rates, ieitems->supported_rates->len);
if (ieitems->extended_supported_rates) {
station->supportedratescount += ieitems->extended_supported_rates->len;
memcpy(&station->supportedrates[ieitems->supported_rates->len], ieitems->extended_supported_rates->rates, ieitems->extended_supported_rates->len);
}
/* Check NON ERP */ /* Check NON ERP */
if (wlan->device->currentfrequency.mode & IEEE80211_RADIO_TYPE_80211G) { if (wlan->device->currentfrequency.mode & IEEE80211_RADIO_TYPE_80211G) {
int i; int i;
@ -501,8 +475,25 @@ static int wifi_wlan_set_station_information(struct wifi_wlan* wlan, const struc
if (updatebeacons) { if (updatebeacons) {
wlan->device->instance->ops->device_updatebeacons(wlan->device); wlan->device->instance->ops->device_updatebeacons(wlan->device);
} }
}
return IEEE80211_STATUS_SUCCESS; /* */
static int wifi_wlan_get_station_rates(struct wifi_station* station, struct ieee80211_ie_items* ieitems) {
if (!ieitems->supported_rates) {
return -1;
} else if ((ieitems->supported_rates->len + (ieitems->extended_supported_rates ? ieitems->extended_supported_rates->len : 0)) > sizeof(station->supportedrates)) {
return -1;
}
/* */
station->supportedratescount = ieitems->supported_rates->len;
memcpy(station->supportedrates, ieitems->supported_rates->rates, ieitems->supported_rates->len);
if (ieitems->extended_supported_rates) {
station->supportedratescount += ieitems->extended_supported_rates->len;
memcpy(&station->supportedrates[ieitems->supported_rates->len], ieitems->extended_supported_rates->rates, ieitems->extended_supported_rates->len);
}
return 0;
} }
/* */ /* */
@ -627,9 +618,6 @@ static void wifi_wlan_receive_station_mgmt_association_request(struct wifi_wlan*
return; return;
} }
/* */
;
/* Get station reference */ /* Get station reference */
station = wifi_station_get(wlan, frame->sa); station = wifi_station_get(wlan, frame->sa);
if (!station) { if (!station) {
@ -661,7 +649,24 @@ static void wifi_wlan_receive_station_mgmt_association_request(struct wifi_wlan*
/* */ /* */
if (wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_LOCAL) { if (wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_LOCAL) {
resultstatuscode = wifi_wlan_set_station_information(wlan, frame, &ieitems, station); /* Verify SSID */
if (ieee80211_is_valid_ssid(wlan->ssid, ieitems.ssid, NULL) == IEEE80211_VALID_SSID) {
station->capability = __le16_to_cpu(frame->associationrequest.capability);
station->listeninterval = __le16_to_cpu(frame->associationrequest.listeninterval);
if (!ieee80211_aid_create(wlan->aidbitfield, &station->aid)) {
/* Get supported rates */
if (!wifi_wlan_get_station_rates(station, &ieitems)) {
wifi_wlan_management_legacy_station(wlan, station);
resultstatuscode = IEEE80211_STATUS_SUCCESS;
} else {
resultstatuscode = IEEE80211_STATUS_UNSPECIFIED_FAILURE;
}
} else {
resultstatuscode = IEEE80211_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA;
}
} else {
resultstatuscode = IEEE80211_STATUS_UNSPECIFIED_FAILURE;
}
/* Create association response packet */ /* Create association response packet */
memset(&ieee80211_params, 0, sizeof(struct ieee80211_authentication_params)); memset(&ieee80211_params, 0, sizeof(struct ieee80211_authentication_params));
@ -693,6 +698,10 @@ static void wifi_wlan_receive_station_mgmt_association_request(struct wifi_wlan*
} }
} else if (wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_SPLIT) { } else if (wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_SPLIT) {
wlan->send_frame(wlan->send_frame_to_ac_cbparam, frame, length); wlan->send_frame(wlan->send_frame_to_ac_cbparam, frame, length);
/* Station information */
station->capability = __le16_to_cpu(frame->associationresponse.capability);
station->listeninterval = __le16_to_cpu(frame->associationrequest.listeninterval);
} }
} }
@ -700,8 +709,6 @@ static void wifi_wlan_receive_station_mgmt_association_request(struct wifi_wlan*
static void wifi_wlan_receive_station_mgmt_reassociation_request(struct wifi_wlan* wlan, const struct ieee80211_header_mgmt* frame, int length, uint8_t rssi, uint8_t snr, uint16_t rate) { static void wifi_wlan_receive_station_mgmt_reassociation_request(struct wifi_wlan* wlan, const struct ieee80211_header_mgmt* frame, int length, uint8_t rssi, uint8_t snr, uint16_t rate) {
int ielength; int ielength;
/* TODO */
/* Information Elements packet length */ /* Information Elements packet length */
ielength = length - (sizeof(struct ieee80211_header) + sizeof(frame->reassociationrequest)); ielength = length - (sizeof(struct ieee80211_header) + sizeof(frame->reassociationrequest));
if (ielength < 0) { if (ielength < 0) {
@ -715,8 +722,6 @@ static void wifi_wlan_receive_station_mgmt_reassociation_request(struct wifi_wla
static void wifi_wlan_receive_station_mgmt_disassociation(struct wifi_wlan* wlan, const struct ieee80211_header_mgmt* frame, int length, uint8_t rssi, uint8_t snr, uint16_t rate) { static void wifi_wlan_receive_station_mgmt_disassociation(struct wifi_wlan* wlan, const struct ieee80211_header_mgmt* frame, int length, uint8_t rssi, uint8_t snr, uint16_t rate) {
int ielength; int ielength;
/* TODO */
/* Information Elements packet length */ /* Information Elements packet length */
ielength = length - (sizeof(struct ieee80211_header) + sizeof(frame->disassociation)); ielength = length - (sizeof(struct ieee80211_header) + sizeof(frame->disassociation));
if (ielength < 0) { if (ielength < 0) {
@ -734,8 +739,6 @@ static void wifi_wlan_receive_station_mgmt_deauthentication(struct wifi_wlan* wl
int ielength; int ielength;
struct wifi_station* station; struct wifi_station* station;
/* TODO */
/* Information Elements packet length */ /* Information Elements packet length */
ielength = length - (sizeof(struct ieee80211_header) + sizeof(frame->deauthetication)); ielength = length - (sizeof(struct ieee80211_header) + sizeof(frame->deauthetication));
if (ielength < 0) { if (ielength < 0) {
@ -831,6 +834,7 @@ static void wifi_wlan_receive_station_mgmt_authentication_ack(struct wifi_wlan*
/* Check if authenticate */ /* Check if authenticate */
if ((algorithm == IEEE80211_AUTHENTICATION_ALGORITHM_OPEN) && (transactionseqnumber == 2)) { if ((algorithm == IEEE80211_AUTHENTICATION_ALGORITHM_OPEN) && (transactionseqnumber == 2)) {
capwap_logging_info("IEEE802.11 Authentication complete to %s station", station->addrtext);
station->flags |= WIFI_STATION_FLAGS_AUTHENTICATED; station->flags |= WIFI_STATION_FLAGS_AUTHENTICATED;
} else if ((algorithm == IEEE80211_AUTHENTICATION_ALGORITHM_SHARED_KEY) && (transactionseqnumber == 4)) { } else if ((algorithm == IEEE80211_AUTHENTICATION_ALGORITHM_SHARED_KEY) && (transactionseqnumber == 4)) {
/* TODO */ /* TODO */
@ -857,11 +861,15 @@ static void wifi_wlan_receive_station_mgmt_association_response_ack(struct wifi_
/* */ /* */
statuscode = __le16_to_cpu(frame->associationresponse.statuscode); statuscode = __le16_to_cpu(frame->associationresponse.statuscode);
if (statuscode == IEEE80211_STATUS_SUCCESS) { if (statuscode == IEEE80211_STATUS_SUCCESS) {
station->flags |= WIFI_STATION_FLAGS_ASSOCIATE; capwap_logging_info("IEEE802.11 Association complete to %s station", station->addrtext);
/* Apply authorization if Station already authorized */ /* */
station->flags |= WIFI_STATION_FLAGS_ASSOCIATE;
if (station->flags & WIFI_STATION_FLAGS_AUTHORIZED) { if (station->flags & WIFI_STATION_FLAGS_AUTHORIZED) {
wlan->device->instance->ops->station_authorize(wlan, station); /* Apply authorization if Station already authorized */
if (wlan->device->instance->ops->station_authorize(wlan, station)) {
wifi_wlan_deauthentication_station(wlan, station, IEEE80211_REASON_PREV_AUTH_NOT_VALID, 0);
}
} }
} }
} }
@ -893,7 +901,7 @@ static void wifi_wlan_receive_station_mgmt_ackframe(struct wifi_wlan* wlan, cons
} }
/* */ /* */
static int wifi_wlan_receive_ac_mgmt_authentication(struct wifi_wlan* wlan, const struct ieee80211_header_mgmt* frame, int length) { static int wifi_wlan_receive_ac_mgmt_authentication(struct wifi_wlan* wlan, struct ieee80211_header_mgmt* frame, int length) {
int ielength; int ielength;
struct wifi_station* station; struct wifi_station* station;
int forwardframe = 0; int forwardframe = 0;
@ -904,7 +912,22 @@ static int wifi_wlan_receive_ac_mgmt_authentication(struct wifi_wlan* wlan, cons
if (wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_SPLIT) { if (wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_SPLIT) {
station = wifi_station_get(wlan, frame->da); station = wifi_station_get(wlan, frame->da);
if (station) { if (station) {
/* TODO */ uint16_t statuscode = __le16_to_cpu(frame->authetication.statuscode);
if (statuscode == IEEE80211_STATUS_SUCCESS) {
uint16_t algorithm = __le16_to_cpu(frame->authetication.algorithm);
uint16_t transactionseqnumber = __le16_to_cpu(frame->authetication.transactionseqnumber);
/* Get authentication algorithm */
if ((algorithm == IEEE80211_AUTHENTICATION_ALGORITHM_OPEN) && (transactionseqnumber == 2)) {
station->authalgorithm = IEEE80211_AUTHENTICATION_ALGORITHM_OPEN;
} else if ((algorithm == IEEE80211_AUTHENTICATION_ALGORITHM_SHARED_KEY) && (transactionseqnumber == 4)) {
station->authalgorithm = IEEE80211_AUTHENTICATION_ALGORITHM_SHARED_KEY;
}
}
/* */
forwardframe = 1;
} }
} }
} }
@ -913,8 +936,9 @@ static int wifi_wlan_receive_ac_mgmt_authentication(struct wifi_wlan* wlan, cons
} }
/* */ /* */
static int wifi_wlan_receive_ac_mgmt_association_response(struct wifi_wlan* wlan, const struct ieee80211_header_mgmt* frame, int length) { static int wifi_wlan_receive_ac_mgmt_association_response(struct wifi_wlan* wlan, struct ieee80211_header_mgmt* frame, int length) {
int ielength; int ielength;
struct ieee80211_ie_items ieitems;
struct wifi_station* station; struct wifi_station* station;
int forwardframe = 0; int forwardframe = 0;
@ -929,7 +953,24 @@ static int wifi_wlan_receive_ac_mgmt_association_response(struct wifi_wlan* wlan
wifi_wlan_deauthentication_station(wlan, station, IEEE80211_REASON_PREV_AUTH_NOT_VALID, 0); wifi_wlan_deauthentication_station(wlan, station, IEEE80211_REASON_PREV_AUTH_NOT_VALID, 0);
} }
} else if (wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_SPLIT) { } else if (wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_SPLIT) {
/* TODO */ uint16_t statuscode = __le16_to_cpu(frame->associationresponse.statuscode);
if ((statuscode == IEEE80211_STATUS_SUCCESS) && !ieee80211_retrieve_information_elements_position(&ieitems, &frame->associationresponse.ie[0], ielength)) {
/* Station information */
station->aid = (__le16_to_cpu(frame->associationresponse.aid) & ~IEEE80211_AID_FIELD);
/* Get supported rates */
wifi_wlan_get_station_rates(station, &ieitems);
/* */
wifi_wlan_management_legacy_station(wlan, station);
/* Assign valid WLAN capability */
frame->associationresponse.capability = __cpu_to_le16(wifi_wlan_check_capability(wlan, wlan->capability));
}
/* */
forwardframe = 1;
} }
} }
} }
@ -938,7 +979,7 @@ static int wifi_wlan_receive_ac_mgmt_association_response(struct wifi_wlan* wlan
} }
/* */ /* */
static int wifi_wlan_receive_ac_mgmt_reassociation_response(struct wifi_wlan* wlan, const struct ieee80211_header_mgmt* frame, int length) { static int wifi_wlan_receive_ac_mgmt_reassociation_response(struct wifi_wlan* wlan, struct ieee80211_header_mgmt* frame, int length) {
int ielength; int ielength;
struct wifi_station* station; struct wifi_station* station;
int forwardframe = 0; int forwardframe = 0;
@ -958,7 +999,7 @@ static int wifi_wlan_receive_ac_mgmt_reassociation_response(struct wifi_wlan* wl
} }
/* */ /* */
static int wifi_wlan_receive_ac_mgmt_disassociation(struct wifi_wlan* wlan, const struct ieee80211_header_mgmt* frame, int length) { static int wifi_wlan_receive_ac_mgmt_disassociation(struct wifi_wlan* wlan, struct ieee80211_header_mgmt* frame, int length) {
int ielength; int ielength;
struct wifi_station* station; struct wifi_station* station;
@ -985,7 +1026,7 @@ static int wifi_wlan_receive_ac_mgmt_disassociation(struct wifi_wlan* wlan, cons
} }
/* */ /* */
static int wifi_wlan_receive_ac_mgmt_deauthentication(struct wifi_wlan* wlan, const struct ieee80211_header_mgmt* frame, int length) { static int wifi_wlan_receive_ac_mgmt_deauthentication(struct wifi_wlan* wlan, struct ieee80211_header_mgmt* frame, int length) {
int ielength; int ielength;
struct wifi_station* station; struct wifi_station* station;
@ -1005,7 +1046,7 @@ static int wifi_wlan_receive_ac_mgmt_deauthentication(struct wifi_wlan* wlan, co
} }
/* */ /* */
static int wifi_wlan_receive_ac_mgmt_frame(struct wifi_wlan* wlan, const struct ieee80211_header_mgmt* frame, int length, uint16_t framecontrol_subtype) { static int wifi_wlan_receive_ac_mgmt_frame(struct wifi_wlan* wlan, struct ieee80211_header_mgmt* frame, int length, uint16_t framecontrol_subtype) {
int forwardframe = 0; int forwardframe = 0;
switch (framecontrol_subtype) { switch (framecontrol_subtype) {
@ -1578,7 +1619,7 @@ void wifi_wlan_receive_station_ackframe(struct wifi_wlan* wlan, const struct iee
} }
/* */ /* */
void wifi_wlan_receive_ac_frame(struct wifi_wlan* wlan, const struct ieee80211_header* frame, int length) { void wifi_wlan_receive_ac_frame(struct wifi_wlan* wlan, struct ieee80211_header* frame, int length) {
int forwardframe = 1; int forwardframe = 1;
uint16_t framecontrol; uint16_t framecontrol;
uint16_t framecontrol_type; uint16_t framecontrol_type;
@ -1596,7 +1637,7 @@ void wifi_wlan_receive_ac_frame(struct wifi_wlan* wlan, const struct ieee80211_h
/* Parsing frame */ /* Parsing frame */
if (framecontrol_type == IEEE80211_FRAMECONTROL_TYPE_MGMT) { if (framecontrol_type == IEEE80211_FRAMECONTROL_TYPE_MGMT) {
forwardframe = wifi_wlan_receive_ac_mgmt_frame(wlan, (const struct ieee80211_header_mgmt*)frame, length, framecontrol_subtype); forwardframe = wifi_wlan_receive_ac_mgmt_frame(wlan, (struct ieee80211_header_mgmt*)frame, length, framecontrol_subtype);
} }
/* Forward frame */ /* Forward frame */
@ -1608,6 +1649,7 @@ void wifi_wlan_receive_ac_frame(struct wifi_wlan* wlan, const struct ieee80211_h
/* */ /* */
int wifi_station_authorize(struct wifi_wlan* wlan, struct station_add_params* params) { int wifi_station_authorize(struct wifi_wlan* wlan, struct station_add_params* params) {
int result;
struct wifi_station* station; struct wifi_station* station;
ASSERT(wlan != NULL); ASSERT(wlan != NULL);
@ -1622,9 +1664,6 @@ int wifi_station_authorize(struct wifi_wlan* wlan, struct station_add_params* pa
return 0; return 0;
} }
/* */
capwap_logging_info("Authorized station: %s", station->addrtext);
/* */ /* */
capwap_timeout_deletetimer(g_wifiglobal.timeout, station->idtimeout); capwap_timeout_deletetimer(g_wifiglobal.timeout, station->idtimeout);
station->idtimeout = CAPWAP_TIMEOUT_INDEX_NO_SET; station->idtimeout = CAPWAP_TIMEOUT_INDEX_NO_SET;
@ -1636,7 +1675,12 @@ int wifi_station_authorize(struct wifi_wlan* wlan, struct station_add_params* pa
} }
/* Station authorized */ /* Station authorized */
return wlan->device->instance->ops->station_authorize(wlan, station); result = wlan->device->instance->ops->station_authorize(wlan, station);
if (result) {
wifi_wlan_deauthentication_station(wlan, station, IEEE80211_REASON_PREV_AUTH_NOT_VALID, 0);
}
return result;
} }
/* */ /* */

5
src/wtp/binding/ieee80211/wifi_drivers.h
View File

@ -7,7 +7,6 @@
/* */ /* */
#define WIFI_DRIVER_NAME_SIZE 16 #define WIFI_DRIVER_NAME_SIZE 16
#define WIFI_SSID_MAX_LENGTH 32
/* */ /* */
#define WIFI_BAND_UNKNOWN 0 #define WIFI_BAND_UNKNOWN 0
@ -294,7 +293,7 @@ struct wifi_wlan {
void* send_frame_to_ac_cbparam; void* send_frame_to_ac_cbparam;
/* WLAN information */ /* WLAN information */
char ssid[WIFI_SSID_MAX_LENGTH + 1]; char ssid[IEEE80211_SSID_MAX_LENGTH + 1];
uint8_t ssid_hidden; uint8_t ssid_hidden;
uint16_t capability; uint16_t capability;
@ -415,7 +414,7 @@ void wifi_wlan_destroy(struct wifi_wlan* wlan);
/* WLAN packet management */ /* WLAN packet management */
void wifi_wlan_receive_station_frame(struct wifi_wlan* wlan, const struct ieee80211_header* frame, int length, uint32_t frequency, uint8_t rssi, uint8_t snr, uint16_t rate); void wifi_wlan_receive_station_frame(struct wifi_wlan* wlan, const struct ieee80211_header* frame, int length, uint32_t frequency, uint8_t rssi, uint8_t snr, uint16_t rate);
void wifi_wlan_receive_station_ackframe(struct wifi_wlan* wlan, const struct ieee80211_header* frame, int length, int ack); void wifi_wlan_receive_station_ackframe(struct wifi_wlan* wlan, const struct ieee80211_header* frame, int length, int ack);
void wifi_wlan_receive_ac_frame(struct wifi_wlan* wlan, const struct ieee80211_header* frame, int length); void wifi_wlan_receive_ac_frame(struct wifi_wlan* wlan, struct ieee80211_header* frame, int length);
/* Station management */ /* Station management */
int wifi_station_authorize(struct wifi_wlan* wlan, struct station_add_params* params); int wifi_station_authorize(struct wifi_wlan* wlan, struct station_add_params* params);

7
src/wtp/binding/ieee80211/wifi_nl80211.c
View File

@ -1003,10 +1003,15 @@ int nl80211_station_authorize(struct wifi_wlan* wlan, struct wifi_station* stati
if (result == -EEXIST) { if (result == -EEXIST) {
result = 0; result = 0;
} else { } else {
capwap_logging_error("Unable add station into wireless driver, error code: %d", result); capwap_logging_error("Unable to authorized station, error code: %d", result);
} }
} }
/* */
if (!result) {
capwap_logging_info("Authorized station: %s", station->addrtext);
}
/* */ /* */
nlmsg_free(msg); nlmsg_free(msg);
return result; return result;

2
src/wtp/wtp_radio.c
View File

@ -612,7 +612,7 @@ void wtp_radio_receive_data_packet(uint8_t radioid, unsigned short binding, cons
} }
if ((binding == CAPWAP_WIRELESS_BINDING_IEEE80211) && (length >= sizeof(struct ieee80211_header))) { if ((binding == CAPWAP_WIRELESS_BINDING_IEEE80211) && (length >= sizeof(struct ieee80211_header))) {
const struct ieee80211_header* header = (const struct ieee80211_header*)frame; struct ieee80211_header* header = (struct ieee80211_header*)frame;
const uint8_t* bssid = ieee80211_get_bssid_addr(header); const uint8_t* bssid = ieee80211_get_bssid_addr(header);
if (bssid) { if (bssid) {