diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 9370def..0b777da 100755 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -13,6 +13,9 @@ SET(SOURCES storage/datastorage.c include/datastorage.h + storage/uface.c + include/uface.h + network/networksocket.c include/networksocket.h @@ -43,12 +46,27 @@ SET(SOURCES utils/ieee80211_utils.c include/ieee80211_utils.h) +SET(SOURCES_TEST_STORAGE + test/storage_test.c + + include/uface.h + + include/utils.h + utils/utils.c + + storage/datastorage.c + include/datastorage.h + + utils/ieee80211_utils.c + include/ieee80211_utils.h) + SET(LIBS ubox ubus json-c blobmsg_json uci gcrypt iwinfo) ADD_EXECUTABLE(dawn ${SOURCES}) +ADD_EXECUTABLE(test_storage ${SOURCES_TEST_STORAGE}) TARGET_LINK_LIBRARIES(dawn ${LIBS}) INSTALL(TARGETS dawn - RUNTIME DESTINATION /usr/sbin/) \ No newline at end of file + RUNTIME DESTINATION /usr/sbin/) diff --git a/src/include/datastorage.h b/src/include/datastorage.h index a1cc631..f6c4094 100644 --- a/src/include/datastorage.h +++ b/src/include/datastorage.h @@ -8,7 +8,6 @@ #include #include #include -#include #ifndef ETH_ALEN #define ETH_ALEN 6 @@ -101,6 +100,7 @@ struct time_config_s timeout_config; // ---------------- Global variables ---------------- struct probe_metric_s dawn_metric; +extern int probe_entry_last; /* Probe, Auth, Assoc */ @@ -155,6 +155,8 @@ auth_entry insert_to_denied_req_array(auth_entry entry, int inc_counter); // ---------------- Global variables ---------------- struct probe_entry_s probe_array[PROBE_ARRAY_LEN]; pthread_mutex_t probe_array_mutex; +extern int denied_req_last; +auth_entry denied_req_array_delete(auth_entry entry); // ---------------- Functions ---------------- probe_entry insert_to_array(probe_entry entry, int inc_counter, int save_80211k, int is_beacon); @@ -175,7 +177,6 @@ void uloop_add_data_cbs(); /* AP, Client */ -// blobmsg_alloc_string_buffer(&b, "signature", 1024); #define SIGNATURE_LEN 1024 // ---------------- Structs ---------------- @@ -229,6 +230,8 @@ struct client_s client_array[ARRAY_CLIENT_LEN]; pthread_mutex_t client_array_mutex; struct ap_s ap_array[ARRAY_AP_LEN]; pthread_mutex_t ap_array_mutex; +extern int ap_entry_last; +extern int client_entry_last; int mac_is_equal(uint8_t addr1[], uint8_t addr2[]); @@ -258,18 +261,12 @@ void print_ap_array(); ap ap_array_get_ap(uint8_t bssid_addr[]); -int build_hearing_map_sort_client(struct blob_buf *b); - -int build_network_overview(struct blob_buf *b); - int probe_array_set_all_probe_count(uint8_t client_addr[], uint32_t probe_count); int ap_get_collision_count(int col_domain); void send_beacon_reports(uint8_t bssid[], int id); -int ap_get_nr(struct blob_buf *b, uint8_t own_bssid_addr[]); - /* Utils */ // ---------------- Defines ------------------- @@ -281,4 +278,14 @@ char *sort_string; // ---------------- Functions ------------------- int better_ap_available(uint8_t bssid_addr[], uint8_t client_addr[], char* neighbor_report, int automatic_kick); -#endif \ No newline at end of file +int is_connected_somehwere(uint8_t client_addr[]); + +void remove_old_probe_entries(time_t current_time, long long int threshold); + +void remove_old_client_entries(time_t current_time, long long int threshold); + +void remove_old_ap_entries(time_t current_time, long long int threshold); + +int eval_probe_metric(struct probe_entry_s probe_entry); + +#endif diff --git a/src/include/ubus.h b/src/include/ubus.h index f1204d3..9c69fb8 100644 --- a/src/include/ubus.h +++ b/src/include/ubus.h @@ -4,6 +4,7 @@ #include #include + #include "datastorage.h" // 802.11 Status codes @@ -166,4 +167,10 @@ int uci_send_via_network(); void ubus_send_beacon_report(uint8_t client[], int id); +int build_hearing_map_sort_client(struct blob_buf *b); + +int build_network_overview(struct blob_buf *b); + +int ap_get_nr(struct blob_buf *b, uint8_t own_bssid_addr[]); + #endif diff --git a/src/include/uface.h b/src/include/uface.h new file mode 100644 index 0000000..81527f4 --- /dev/null +++ b/src/include/uface.h @@ -0,0 +1,8 @@ +void send_beacon_report(uint8_t client[], int id); +int send_probe_via_network(struct probe_entry_s probe_entry); + +int send_set_probe(uint8_t client_addr[]); +void wnm_disassoc_imminent(uint32_t id, const uint8_t *client_addr, char* dest_ap, uint32_t duration); +void add_client_update_timer(time_t time); +void del_client_interface(uint32_t id, const uint8_t *client_addr, uint32_t reason, uint8_t deauth, uint32_t ban_time); + diff --git a/src/storage/datastorage.c b/src/storage/datastorage.c index eb65bb4..fcd7ec9 100644 --- a/src/storage/datastorage.c +++ b/src/storage/datastorage.c @@ -1,13 +1,13 @@ -#include "datastorage.h" - #include -#include +#include -#include "ubus.h" #include "dawn_iwinfo.h" #include "utils.h" #include "ieee80211_utils.h" +#include "datastorage.h" +#include "uface.h" + #define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5] int go_next_help(char sort_order[], int i, probe_entry entry, @@ -16,32 +16,22 @@ int go_next_help(char sort_order[], int i, probe_entry entry, int go_next(char sort_order[], int i, probe_entry entry, probe_entry next_entry); -void remove_old_probe_entries(time_t current_time, long long int threshold); - int client_array_go_next(char sort_order[], int i, client entry, client next_entry); int client_array_go_next_help(char sort_order[], int i, client entry, client next_entry); -void remove_old_client_entries(time_t current_time, long long int threshold); - -int eval_probe_metric(struct probe_entry_s probe_entry); - int kick_client(struct client_s client_entry, char* neighbor_report); void ap_array_insert(ap entry); ap ap_array_delete(ap entry); -void remove_old_ap_entries(time_t current_time, long long int threshold); - void print_ap_entry(ap entry); int is_connected(uint8_t bssid_addr[], uint8_t client_addr[]); -int is_connected_somehwere(uint8_t client_addr[]); - int compare_station_count(uint8_t *bssid_addr_own, uint8_t *bssid_addr_to_compare, uint8_t *client_addr, int automatic_kick); @@ -49,8 +39,6 @@ int compare_ssid(uint8_t *bssid_addr_own, uint8_t *bssid_addr_to_compare); void denied_req_array_insert(auth_entry entry); -auth_entry denied_req_array_delete(auth_entry entry); - int denied_req_array_go_next(char sort_order[], int i, auth_entry entry, auth_entry next_entry); @@ -63,30 +51,6 @@ int ap_entry_last = -1; int mac_list_entry_last = -1; int denied_req_last = -1; -void remove_probe_array_cb(struct uloop_timeout *t); - -struct uloop_timeout probe_timeout = { - .cb = remove_probe_array_cb -}; - -void remove_client_array_cb(struct uloop_timeout *t); - -struct uloop_timeout client_timeout = { - .cb = remove_client_array_cb -}; - -void remove_ap_array_cb(struct uloop_timeout *t); - -struct uloop_timeout ap_timeout = { - .cb = remove_ap_array_cb -}; - -void denied_req_array_cb(struct uloop_timeout *t); - -struct uloop_timeout denied_req_timeout = { - .cb = denied_req_array_cb -}; - void send_beacon_reports(uint8_t bssid[], int id) { pthread_mutex_lock(&client_array_mutex); @@ -104,171 +68,10 @@ void send_beacon_reports(uint8_t bssid[], int id) { if (!mac_is_equal(client_array[j].bssid_addr, bssid)) { break; } - ubus_send_beacon_report(client_array[j].client_addr, id); + send_beacon_report(client_array[j].client_addr, id); } pthread_mutex_unlock(&client_array_mutex); } - -int build_hearing_map_sort_client(struct blob_buf *b) { - print_probe_array(); - pthread_mutex_lock(&probe_array_mutex); - - void *client_list, *ap_list, *ssid_list; - char ap_mac_buf[20]; - char client_mac_buf[20]; - - blob_buf_init(b, 0); - int m; - for (m = 0; m <= ap_entry_last; m++) { - if (m > 0) { - if (strcmp((char *) ap_array[m].ssid, (char *) ap_array[m - 1].ssid) == 0) { - continue; - } - } - ssid_list = blobmsg_open_table(b, (char *) ap_array[m].ssid); - - int i; - for (i = 0; i <= probe_entry_last; i++) { - /*if(!mac_is_equal(ap_array[m].bssid_addr, probe_array[i].bssid_addr)) - { - continue; - }*/ - - ap ap_entry_i = ap_array_get_ap(probe_array[i].bssid_addr); - - if (!mac_is_equal(ap_entry_i.bssid_addr, probe_array[i].bssid_addr)) { - continue; - } - - if (strcmp((char *) ap_entry_i.ssid, (char *) ap_array[m].ssid) != 0) { - continue; - } - - int k; - sprintf(client_mac_buf, MACSTR, MAC2STR(probe_array[i].client_addr)); - client_list = blobmsg_open_table(b, client_mac_buf); - for (k = i; k <= probe_entry_last; k++) { - ap ap_entry = ap_array_get_ap(probe_array[k].bssid_addr); - - if (!mac_is_equal(ap_entry.bssid_addr, probe_array[k].bssid_addr)) { - continue; - } - - if (strcmp((char *) ap_entry.ssid, (char *) ap_array[m].ssid) != 0) { - continue; - } - - if (!mac_is_equal(probe_array[k].client_addr, probe_array[i].client_addr)) { - i = k - 1; - break; - } else if (k == probe_entry_last) { - i = k; - } - - sprintf(ap_mac_buf, MACSTR, MAC2STR(probe_array[k].bssid_addr)); - ap_list = blobmsg_open_table(b, ap_mac_buf); - blobmsg_add_u32(b, "signal", probe_array[k].signal); - blobmsg_add_u32(b, "rcpi", probe_array[k].rcpi); - blobmsg_add_u32(b, "rsni", probe_array[k].rsni); - blobmsg_add_u32(b, "freq", probe_array[k].freq); - blobmsg_add_u8(b, "ht_capabilities", probe_array[k].ht_capabilities); - blobmsg_add_u8(b, "vht_capabilities", probe_array[k].vht_capabilities); - - - // check if ap entry is available - blobmsg_add_u32(b, "channel_utilization", ap_entry.channel_utilization); - blobmsg_add_u32(b, "num_sta", ap_entry.station_count); - blobmsg_add_u8(b, "ht_support", ap_entry.ht_support); - blobmsg_add_u8(b, "vht_support", ap_entry.vht_support); - - blobmsg_add_u32(b, "score", eval_probe_metric(probe_array[k])); - blobmsg_close_table(b, ap_list); - } - blobmsg_close_table(b, client_list); - } - blobmsg_close_table(b, ssid_list); - } - pthread_mutex_unlock(&probe_array_mutex); - return 0; -} - -int build_network_overview(struct blob_buf *b) { - void *client_list, *ap_list, *ssid_list; - char ap_mac_buf[20]; - char client_mac_buf[20]; - - blob_buf_init(b, 0); - int m; - for (m = 0; m <= ap_entry_last; m++) { - if (m > 0) { - if (strcmp((char *) ap_array[m].ssid, (char *) ap_array[m - 1].ssid) == 0) { - continue; - } - } - - ssid_list = blobmsg_open_table(b, (char *) ap_array[m].ssid); - - int i; - for (i = 0; i <= client_entry_last; i++) { - ap ap_entry_i = ap_array_get_ap(client_array[i].bssid_addr); - - if (strcmp((char *) ap_entry_i.ssid, (char *) ap_array[m].ssid) != 0) { - continue; - } - int k; - sprintf(ap_mac_buf, MACSTR, MAC2STR(client_array[i].bssid_addr)); - ap_list = blobmsg_open_table(b, ap_mac_buf); - - blobmsg_add_u32(b, "freq", ap_entry_i.freq); - blobmsg_add_u32(b, "channel_utilization", ap_entry_i.channel_utilization); - blobmsg_add_u32(b, "num_sta", ap_entry_i.station_count); - blobmsg_add_u8(b, "ht_support", ap_entry_i.ht_support); - blobmsg_add_u8(b, "vht_support", ap_entry_i.vht_support); - - char *nr; - nr = blobmsg_alloc_string_buffer(b, "neighbor_report", NEIGHBOR_REPORT_LEN); - sprintf(nr, "%s", ap_entry_i.neighbor_report); - blobmsg_add_string_buffer(b); - - for (k = i; k <= client_entry_last; k++) { - if (!mac_is_equal(client_array[k].bssid_addr, client_array[i].bssid_addr)) { - i = k - 1; - break; - } else if (k == client_entry_last) { - i = k; - } - - sprintf(client_mac_buf, MACSTR, MAC2STR(client_array[k].client_addr)); - client_list = blobmsg_open_table(b, client_mac_buf); - if(strlen(client_array[k].signature) != 0) - { - char *s; - s = blobmsg_alloc_string_buffer(b, "signature", 1024); - sprintf(s, "%s", client_array[k].signature); - blobmsg_add_string_buffer(b); - } - blobmsg_add_u8(b, "ht", client_array[k].ht); - blobmsg_add_u8(b, "vht", client_array[k].vht); - blobmsg_add_u32(b, "collision_count", ap_get_collision_count(ap_array[m].collision_domain)); - - int n; - for(n = 0; n <= probe_entry_last; n++) - { - if (mac_is_equal(client_array[k].client_addr, probe_array[n].client_addr) && - mac_is_equal(client_array[k].bssid_addr, probe_array[n].bssid_addr)) { - blobmsg_add_u32(b, "signal", probe_array[n].signal); - break; - } - } - blobmsg_close_table(b, client_list); - } - blobmsg_close_table(b, ap_list); - } - blobmsg_close_table(b, ssid_list); - } - return 0; -} - int eval_probe_metric(struct probe_entry_s probe_entry) { int score = 0; @@ -780,7 +583,7 @@ int probe_array_update_rssi(uint8_t bssid_addr[], uint8_t client_addr[], uint32_ updated = 1; if(send_network) { - ubus_send_probe_via_network(probe_array[i]); + send_probe_via_network(probe_array[i]); } break; //TODO: break?! @@ -809,7 +612,7 @@ int probe_array_update_rcpi_rsni(uint8_t bssid_addr[], uint8_t client_addr[], ui updated = 1; if(send_network) { - ubus_send_probe_via_network(probe_array[i]); + send_probe_via_network(probe_array[i]); } break; //TODO: break?! @@ -895,36 +698,6 @@ ap insert_to_ap_array(ap entry) { } -int ap_get_nr(struct blob_buf *b_local, uint8_t own_bssid_addr[]) { - - pthread_mutex_lock(&ap_array_mutex); - int i; - - void* nbs = blobmsg_open_array(b_local, "list"); - - for (i = 0; i <= ap_entry_last; i++) { - if (mac_is_equal(own_bssid_addr, ap_array[i].bssid_addr)) { - continue; //TODO: Skip own entry?! - } - - void* nr_entry = blobmsg_open_array(b_local, NULL); - - char mac_buf[20]; - sprintf(mac_buf, MACSTRLOWER, MAC2STR(ap_array[i].bssid_addr)); - blobmsg_add_string(b_local, NULL, mac_buf); - - blobmsg_add_string(b_local, NULL, (char *) ap_array[i].ssid); - blobmsg_add_string(b_local, NULL, ap_array[i].neighbor_report); - blobmsg_close_array(b_local, nr_entry); - - } - blobmsg_close_array(b_local, nbs); - - pthread_mutex_unlock(&ap_array_mutex); - - return 0; -} - int ap_get_collision_count(int col_domain) { int ret_sta_count = 0; @@ -1046,71 +819,6 @@ void remove_old_ap_entries(time_t current_time, long long int threshold) { } } -void uloop_add_data_cbs() { - uloop_timeout_add(&probe_timeout); - uloop_timeout_add(&client_timeout); - uloop_timeout_add(&ap_timeout); - - if (dawn_metric.use_driver_recog) { - uloop_timeout_add(&denied_req_timeout); - } -} - -void remove_probe_array_cb(struct uloop_timeout *t) { - pthread_mutex_lock(&probe_array_mutex); - printf("[Thread] : Removing old probe entries!\n"); - remove_old_probe_entries(time(0), timeout_config.remove_probe); - printf("[Thread] : Removing old entries finished!\n"); - pthread_mutex_unlock(&probe_array_mutex); - uloop_timeout_set(&probe_timeout, timeout_config.remove_probe * 1000); -} - -void remove_client_array_cb(struct uloop_timeout *t) { - pthread_mutex_lock(&client_array_mutex); - printf("[Thread] : Removing old client entries!\n"); - remove_old_client_entries(time(0), timeout_config.update_client); - pthread_mutex_unlock(&client_array_mutex); - uloop_timeout_set(&client_timeout, timeout_config.update_client * 1000); -} - -void remove_ap_array_cb(struct uloop_timeout *t) { - pthread_mutex_lock(&ap_array_mutex); - printf("[ULOOP] : Removing old ap entries!\n"); - remove_old_ap_entries(time(0), timeout_config.remove_ap); - pthread_mutex_unlock(&ap_array_mutex); - uloop_timeout_set(&ap_timeout, timeout_config.remove_ap * 1000); -} - -void denied_req_array_cb(struct uloop_timeout *t) { - pthread_mutex_lock(&denied_array_mutex); - printf("[ULOOP] : Processing denied authentication!\n"); - - time_t current_time = time(0); - - for (int i = 0; i <= denied_req_last; i++) { - // check counter - - //check timer - if (denied_req_array[i].time < current_time - timeout_config.denied_req_threshold) { - - // client is not connected for a given time threshold! - if (!is_connected_somehwere(denied_req_array[i].client_addr)) { - printf("Client has probably a bad driver!\n"); - - // problem that somehow station will land into this list - // maybe delete again? - if (insert_to_maclist(denied_req_array[i].client_addr) == 0) { - send_add_mac(denied_req_array[i].client_addr); - write_mac_to_file("/tmp/dawn_mac_list", denied_req_array[i].client_addr); - } - } - denied_req_array_delete(denied_req_array[i]); - } - } - pthread_mutex_unlock(&denied_array_mutex); - uloop_timeout_set(&denied_req_timeout, timeout_config.denied_req_threshold * 1000); -} - void insert_client_to_array(client entry) { pthread_mutex_lock(&client_array_mutex); entry.time = time(0); diff --git a/src/storage/uface.c b/src/storage/uface.c new file mode 100644 index 0000000..0c82b89 --- /dev/null +++ b/src/storage/uface.c @@ -0,0 +1,124 @@ +#include +#include "datastorage.h" +#include "utils.h" +#include "ubus.h" +#include "uface.h" + +void send_beacon_report(uint8_t client[], int id) +{ + ubus_send_beacon_report(client, id); +} + +int send_set_probe(uint8_t client_addr[]) +{ + return send_set_probe(client_addr); +} + +void wnm_disassoc_imminent(uint32_t id, const uint8_t *client_addr, char* dest_ap, uint32_t duration) +{ + wnm_disassoc_imminent(id, client_addr, dest_ap, duration); +} + +void add_client_update_timer(time_t time) +{ + add_client_update_timer(time); +} + +void del_client_interface(uint32_t id, const uint8_t *client_addr, uint32_t reason, uint8_t deauth, uint32_t ban_time) +{ + del_client_interface(id, client_addr, reason, deauth, ban_time); +} + +int send_probe_via_network(struct probe_entry_s probe_entry) +{ + return ubus_send_probe_via_network(probe_entry); +} + +void remove_probe_array_cb(struct uloop_timeout *t); + +struct uloop_timeout probe_timeout = { + .cb = remove_probe_array_cb +}; + +void remove_client_array_cb(struct uloop_timeout *t); + +struct uloop_timeout client_timeout = { + .cb = remove_client_array_cb +}; + +void remove_ap_array_cb(struct uloop_timeout *t); + +struct uloop_timeout ap_timeout = { + .cb = remove_ap_array_cb +}; + +void denied_req_array_cb(struct uloop_timeout *t); + +struct uloop_timeout denied_req_timeout = { + .cb = denied_req_array_cb +}; + +void uloop_add_data_cbs() { + uloop_timeout_add(&probe_timeout); + uloop_timeout_add(&client_timeout); + uloop_timeout_add(&ap_timeout); + + if (dawn_metric.use_driver_recog) { + uloop_timeout_add(&denied_req_timeout); + } +} + +void remove_probe_array_cb(struct uloop_timeout *t) { + pthread_mutex_lock(&probe_array_mutex); + printf("[Thread] : Removing old probe entries!\n"); + remove_old_probe_entries(time(0), timeout_config.remove_probe); + printf("[Thread] : Removing old entries finished!\n"); + pthread_mutex_unlock(&probe_array_mutex); + uloop_timeout_set(&probe_timeout, timeout_config.remove_probe * 1000); +} + +void remove_client_array_cb(struct uloop_timeout *t) { + pthread_mutex_lock(&client_array_mutex); + printf("[Thread] : Removing old client entries!\n"); + remove_old_client_entries(time(0), timeout_config.update_client); + pthread_mutex_unlock(&client_array_mutex); + uloop_timeout_set(&client_timeout, timeout_config.update_client * 1000); +} + +void remove_ap_array_cb(struct uloop_timeout *t) { + pthread_mutex_lock(&ap_array_mutex); + printf("[ULOOP] : Removing old ap entries!\n"); + remove_old_ap_entries(time(0), timeout_config.remove_ap); + pthread_mutex_unlock(&ap_array_mutex); + uloop_timeout_set(&ap_timeout, timeout_config.remove_ap * 1000); +} + +void denied_req_array_cb(struct uloop_timeout *t) { + pthread_mutex_lock(&denied_array_mutex); + printf("[ULOOP] : Processing denied authentication!\n"); + + time_t current_time = time(0); + + for (int i = 0; i <= denied_req_last; i++) { + // check counter + + //check timer + if (denied_req_array[i].time < current_time - timeout_config.denied_req_threshold) { + + // client is not connected for a given time threshold! + if (!is_connected_somehwere(denied_req_array[i].client_addr)) { + printf("Client has probably a bad driver!\n"); + + // problem that somehow station will land into this list + // maybe delete again? + if (insert_to_maclist(denied_req_array[i].client_addr) == 0) { + send_add_mac(denied_req_array[i].client_addr); + write_mac_to_file("/tmp/dawn_mac_list", denied_req_array[i].client_addr); + } + } + denied_req_array_delete(denied_req_array[i]); + } + } + pthread_mutex_unlock(&denied_array_mutex); + uloop_timeout_set(&denied_req_timeout, timeout_config.denied_req_threshold * 1000); +} diff --git a/src/test/storage_test.c b/src/test/storage_test.c new file mode 100644 index 0000000..e2acae7 --- /dev/null +++ b/src/test/storage_test.c @@ -0,0 +1,93 @@ +#include +#include + +#include "dawn_iwinfo.h" +#include "utils.h" +#include "ieee80211_utils.h" + +#include "datastorage.h" +#include "uface.h" + +void ap_array_insert(ap entry); + +ap ap_array_delete(ap entry); + +int main() +{ +ap ap0; +union __attribute__((__packed__)){ +struct { +uint8_t the_mac[6]; +uint8_t packing[2]; +}mac; +uint64_t u64; +} mac_mangler; + + + print_ap_array(); + for (int m = 0; m < 1000; m++) + { + mac_mangler.u64 = m; + memcpy(ap0.bssid_addr, mac_mangler.mac.the_mac, sizeof(ap0.bssid_addr)); + ap_array_insert(ap0); + } + print_ap_array(); + for (int m = 0; m < 1000; m++) + { + mac_mangler.u64 = m; + memcpy(ap0.bssid_addr, mac_mangler.mac.the_mac, sizeof(ap0.bssid_addr)); + ap_array_delete(ap0); + } + print_ap_array(); +} + +void send_beacon_report(uint8_t client[], int id) +{ + printf("send_beacon_report() was called...\n"); +} + +int send_set_probe(uint8_t client_addr[]) +{ + printf("send_set_probe() was called...\n"); + return 0; +} + +void wnm_disassoc_imminent(uint32_t id, const uint8_t *client_addr, char* dest_ap, uint32_t duration) +{ + printf("wnm_disassoc_imminent() was called...\n"); +} + +void add_client_update_timer(time_t time) +{ + printf("add_client_update_timer() was called...\n"); +} + +void del_client_interface(uint32_t id, const uint8_t *client_addr, uint32_t reason, uint8_t deauth, uint32_t ban_time) +{ + printf("del_client_interface() was called...\n"); +} + +int send_probe_via_network(struct probe_entry_s probe_entry) +{ + printf("send_probe_via_network() was called...\n"); + return 0; +} + +int get_rssi_iwinfo(uint8_t *client_addr) +{ + printf("get_rssi_iwinfo() was called...\n"); + return 0; +} + +int get_expected_throughput_iwinfo(uint8_t *client_addr) +{ + printf("get_expected_throughput_iwinfo() was called...\n"); + return 0; +} + +int get_bandwidth_iwinfo(uint8_t *client_addr, float *rx_rate, float *tx_rate) +{ + printf("get_bandwidth_iwinfo() was called...\n"); + return 0; +} + diff --git a/src/utils/ubus.c b/src/utils/ubus.c index b65b671..eebf938 100644 --- a/src/utils/ubus.c +++ b/src/utils/ubus.c @@ -1,3 +1,6 @@ +#include + + #include #include #include @@ -22,6 +25,7 @@ #include "dawn_iwinfo.h" #include "datastorage.h" #include "tcpsocket.h" +#include "ieee80211_utils.h" static struct ubus_context *ctx = NULL; @@ -1990,3 +1994,193 @@ int handle_uci_config(struct blob_attr *msg) { return 0; } + +int build_hearing_map_sort_client(struct blob_buf *b) { + print_probe_array(); + pthread_mutex_lock(&probe_array_mutex); + + void *client_list, *ap_list, *ssid_list; + char ap_mac_buf[20]; + char client_mac_buf[20]; + + blob_buf_init(b, 0); + int m; + for (m = 0; m <= ap_entry_last; m++) { + if (m > 0) { + if (strcmp((char *) ap_array[m].ssid, (char *) ap_array[m - 1].ssid) == 0) { + continue; + } + } + ssid_list = blobmsg_open_table(b, (char *) ap_array[m].ssid); + + int i; + for (i = 0; i <= probe_entry_last; i++) { + /*if(!mac_is_equal(ap_array[m].bssid_addr, probe_array[i].bssid_addr)) + { + continue; + }*/ + + ap ap_entry_i = ap_array_get_ap(probe_array[i].bssid_addr); + + if (!mac_is_equal(ap_entry_i.bssid_addr, probe_array[i].bssid_addr)) { + continue; + } + + if (strcmp((char *) ap_entry_i.ssid, (char *) ap_array[m].ssid) != 0) { + continue; + } + + int k; + sprintf(client_mac_buf, MACSTR, MAC2STR(probe_array[i].client_addr)); + client_list = blobmsg_open_table(b, client_mac_buf); + for (k = i; k <= probe_entry_last; k++) { + ap ap_entry = ap_array_get_ap(probe_array[k].bssid_addr); + + if (!mac_is_equal(ap_entry.bssid_addr, probe_array[k].bssid_addr)) { + continue; + } + + if (strcmp((char *) ap_entry.ssid, (char *) ap_array[m].ssid) != 0) { + continue; + } + + if (!mac_is_equal(probe_array[k].client_addr, probe_array[i].client_addr)) { + i = k - 1; + break; + } else if (k == probe_entry_last) { + i = k; + } + + sprintf(ap_mac_buf, MACSTR, MAC2STR(probe_array[k].bssid_addr)); + ap_list = blobmsg_open_table(b, ap_mac_buf); + blobmsg_add_u32(b, "signal", probe_array[k].signal); + blobmsg_add_u32(b, "rcpi", probe_array[k].rcpi); + blobmsg_add_u32(b, "rsni", probe_array[k].rsni); + blobmsg_add_u32(b, "freq", probe_array[k].freq); + blobmsg_add_u8(b, "ht_capabilities", probe_array[k].ht_capabilities); + blobmsg_add_u8(b, "vht_capabilities", probe_array[k].vht_capabilities); + + + // check if ap entry is available + blobmsg_add_u32(b, "channel_utilization", ap_entry.channel_utilization); + blobmsg_add_u32(b, "num_sta", ap_entry.station_count); + blobmsg_add_u8(b, "ht_support", ap_entry.ht_support); + blobmsg_add_u8(b, "vht_support", ap_entry.vht_support); + + blobmsg_add_u32(b, "score", eval_probe_metric(probe_array[k])); + blobmsg_close_table(b, ap_list); + } + blobmsg_close_table(b, client_list); + } + blobmsg_close_table(b, ssid_list); + } + pthread_mutex_unlock(&probe_array_mutex); + return 0; +} + +int build_network_overview(struct blob_buf *b) { + void *client_list, *ap_list, *ssid_list; + char ap_mac_buf[20]; + char client_mac_buf[20]; + + blob_buf_init(b, 0); + int m; + for (m = 0; m <= ap_entry_last; m++) { + if (m > 0) { + if (strcmp((char *) ap_array[m].ssid, (char *) ap_array[m - 1].ssid) == 0) { + continue; + } + } + + ssid_list = blobmsg_open_table(b, (char *) ap_array[m].ssid); + + int i; + for (i = 0; i <= client_entry_last; i++) { + ap ap_entry_i = ap_array_get_ap(client_array[i].bssid_addr); + + if (strcmp((char *) ap_entry_i.ssid, (char *) ap_array[m].ssid) != 0) { + continue; + } + int k; + sprintf(ap_mac_buf, MACSTR, MAC2STR(client_array[i].bssid_addr)); + ap_list = blobmsg_open_table(b, ap_mac_buf); + + blobmsg_add_u32(b, "freq", ap_entry_i.freq); + blobmsg_add_u32(b, "channel_utilization", ap_entry_i.channel_utilization); + blobmsg_add_u32(b, "num_sta", ap_entry_i.station_count); + blobmsg_add_u8(b, "ht_support", ap_entry_i.ht_support); + blobmsg_add_u8(b, "vht_support", ap_entry_i.vht_support); + + char *nr; + nr = blobmsg_alloc_string_buffer(b, "neighbor_report", NEIGHBOR_REPORT_LEN); + sprintf(nr, "%s", ap_entry_i.neighbor_report); + blobmsg_add_string_buffer(b); + + for (k = i; k <= client_entry_last; k++) { + if (!mac_is_equal(client_array[k].bssid_addr, client_array[i].bssid_addr)) { + i = k - 1; + break; + } else if (k == client_entry_last) { + i = k; + } + + sprintf(client_mac_buf, MACSTR, MAC2STR(client_array[k].client_addr)); + client_list = blobmsg_open_table(b, client_mac_buf); + if(strlen(client_array[k].signature) != 0) + { + char *s; + s = blobmsg_alloc_string_buffer(b, "signature", 1024); + sprintf(s, "%s", client_array[k].signature); + blobmsg_add_string_buffer(b); + } + blobmsg_add_u8(b, "ht", client_array[k].ht); + blobmsg_add_u8(b, "vht", client_array[k].vht); + blobmsg_add_u32(b, "collision_count", ap_get_collision_count(ap_array[m].collision_domain)); + + int n; + for(n = 0; n <= probe_entry_last; n++) + { + if (mac_is_equal(client_array[k].client_addr, probe_array[n].client_addr) && + mac_is_equal(client_array[k].bssid_addr, probe_array[n].bssid_addr)) { + blobmsg_add_u32(b, "signal", probe_array[n].signal); + break; + } + } + blobmsg_close_table(b, client_list); + } + blobmsg_close_table(b, ap_list); + } + blobmsg_close_table(b, ssid_list); + } + return 0; +} + +int ap_get_nr(struct blob_buf *b_local, uint8_t own_bssid_addr[]) { + + pthread_mutex_lock(&ap_array_mutex); + int i; + + void* nbs = blobmsg_open_array(b_local, "list"); + + for (i = 0; i <= ap_entry_last; i++) { + if (mac_is_equal(own_bssid_addr, ap_array[i].bssid_addr)) { + continue; //TODO: Skip own entry?! + } + + void* nr_entry = blobmsg_open_array(b_local, NULL); + + char mac_buf[20]; + sprintf(mac_buf, MACSTRLOWER, MAC2STR(ap_array[i].bssid_addr)); + blobmsg_add_string(b_local, NULL, mac_buf); + + blobmsg_add_string(b_local, NULL, (char *) ap_array[i].ssid); + blobmsg_add_string(b_local, NULL, ap_array[i].neighbor_report); + blobmsg_close_array(b_local, nr_entry); + + } + blobmsg_close_array(b_local, nbs); + + pthread_mutex_unlock(&ap_array_mutex); + + return 0; +} diff --git a/src/utils/utils.c b/src/utils/utils.c index 147207b..02616dd 100644 --- a/src/utils/utils.c +++ b/src/utils/utils.c @@ -1,5 +1,8 @@ +#include +#include +#include +#include "datastorage.h" #include "utils.h" -#include "ubus.h" int string_is_greater(uint8_t *str, uint8_t *str_2) { @@ -82,4 +85,4 @@ void write_mac_to_file(char *path, uint8_t addr[]) { int rcpi_to_rssi(int rcpi) { return rcpi / 2 - 110; -} \ No newline at end of file +}