external/DAWN
1
0
Fork 0
mirror of https://github.com/berlin-open-wireless-lab/DAWN.git synced 2025-03-09 15:40:12 +00:00
Code Issues Releases Wiki Activity

Reformat code

Browse source
This commit is contained in:
PolynomialDivision 2017-07-24 18:45:02 +02:00
parent fa52176cd8
commit 325cbc764c
6 changed files with 989 additions and 1048 deletions
Download patch file Download diff file Expand all files Collapse all files

114
src/main.c
View file

@ -9,76 +9,76 @@
#define BUFSIZE_DIR 255 #define BUFSIZE_DIR 255
int main(int argc, char **argv) { int main(int argc, char **argv) {
const char *ubus_socket = NULL; const char *ubus_socket = NULL;
int ch; int ch;
char opt_broadcast_ip[BUFSIZE]; char opt_broadcast_ip[BUFSIZE];
char opt_broadcast_port[BUFSIZE]; char opt_broadcast_port[BUFSIZE];
char opt_hostapd_dir[BUFSIZE_DIR]; char opt_hostapd_dir[BUFSIZE_DIR];
while ((ch = getopt(argc, argv, "cs:p:i:b:o:h:")) != -1) { while ((ch = getopt(argc, argv, "cs:p:i:b:o:h:")) != -1) {
switch (ch) { switch (ch) {
case 's': case 's':
ubus_socket = optarg; ubus_socket = optarg;
break; break;
case 'p': case 'p':
snprintf(opt_broadcast_port, BUFSIZE, "%s", optarg); snprintf(opt_broadcast_port, BUFSIZE, "%s", optarg);
printf("broadcast port: %s\n", opt_broadcast_port); printf("broadcast port: %s\n", opt_broadcast_port);
break; break;
case 'i': case 'i':
snprintf(opt_broadcast_ip, BUFSIZE, "%s", optarg); snprintf(opt_broadcast_ip, BUFSIZE, "%s", optarg);
printf("broadcast ip: %s\n", opt_broadcast_ip); printf("broadcast ip: %s\n", opt_broadcast_ip);
break; break;
case 'o': case 'o':
snprintf(sort_string, SORT_NUM, "%s", optarg); snprintf(sort_string, SORT_NUM, "%s", optarg);
printf("sort string: %s\n", sort_string); printf("sort string: %s\n", sort_string);
case 'h': case 'h':
snprintf(opt_hostapd_dir, BUFSIZE_DIR, "%s", optarg); snprintf(opt_hostapd_dir, BUFSIZE_DIR, "%s", optarg);
printf("hostapd dir: %s\n", opt_hostapd_dir); printf("hostapd dir: %s\n", opt_hostapd_dir);
hostapd_dir_glob = optarg; hostapd_dir_glob = optarg;
default: default:
break; break;
}
} }
}
argc -= optind; argc -= optind;
argv += optind; argv += optind;
if (pthread_mutex_init(&list_mutex, NULL) != 0) { if (pthread_mutex_init(&list_mutex, NULL) != 0) {
printf("\n mutex init failed\n"); printf("\n mutex init failed\n");
return 1; return 1;
} }
if (pthread_mutex_init(&probe_array_mutex, NULL) != 0) { if (pthread_mutex_init(&probe_array_mutex, NULL) != 0) {
printf("\n mutex init failed\n"); printf("\n mutex init failed\n");
return 1; return 1;
} }
if (pthread_mutex_init(&client_array_mutex, NULL) != 0) { if (pthread_mutex_init(&client_array_mutex, NULL) != 0) {
printf("\n mutex init failed\n"); printf("\n mutex init failed\n");
return 1; return 1;
} }
init_socket_runopts(opt_broadcast_ip, opt_broadcast_port, 1);
pthread_t tid_probe; init_socket_runopts(opt_broadcast_ip, opt_broadcast_port, 1);
pthread_create(&tid_probe, NULL, &remove_array_thread, NULL);
pthread_t tid_client; pthread_t tid_probe;
pthread_create(&tid_client, NULL, &remove_client_array_thread, NULL); pthread_create(&tid_probe, NULL, &remove_array_thread, NULL);
pthread_t tid_get_client; pthread_t tid_client;
pthread_create(&tid_get_client, NULL, &update_clients_thread, NULL); pthread_create(&tid_client, NULL, &remove_client_array_thread, NULL);
pthread_t tid_get_client;
pthread_create(&tid_get_client, NULL, &update_clients_thread, NULL);
//pthread_create(&tid, NULL, &remove_thread, NULL);
dawn_init_ubus(ubus_socket, opt_hostapd_dir); //pthread_create(&tid, NULL, &remove_thread, NULL);
// free ressources dawn_init_ubus(ubus_socket, opt_hostapd_dir);
pthread_mutex_destroy(&list_mutex);
free_list(probe_list_head);
return 0; // free ressources
pthread_mutex_destroy(&list_mutex);
free_list(probe_list_head);
return 0;
} }

50
src/network/broadcastsocket.c
View file

@ -9,33 +9,33 @@
#include "broadcastsocket.h" #include "broadcastsocket.h"
int setup_broadcast_socket(const char *_broadcast_ip, unsigned short _broadcast_port, struct sockaddr_in *addr) { int setup_broadcast_socket(const char *_broadcast_ip, unsigned short _broadcast_port, struct sockaddr_in *addr) {
int sock; int sock;
int broadcast_permission; int broadcast_permission;
/* Create socket */ /* Create socket */
if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
fprintf(stderr, "Failed to create socket.\n"); fprintf(stderr, "Failed to create socket.\n");
return -1; return -1;
} }
/* Allow broadcast */ /* Allow broadcast */
broadcast_permission = 1; broadcast_permission = 1;
if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (void *)&broadcast_permission, if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (void *) &broadcast_permission,
sizeof(broadcast_permission)) < 0) { sizeof(broadcast_permission)) < 0) {
fprintf(stderr, "Failed to create socket.\n"); fprintf(stderr, "Failed to create socket.\n");
return -1; return -1;
} }
/* Construct Address */ /* Construct Address */
memset(addr, 0, sizeof(*addr)); memset(addr, 0, sizeof(*addr));
addr->sin_family = AF_INET; addr->sin_family = AF_INET;
addr->sin_addr.s_addr = inet_addr(_broadcast_ip); addr->sin_addr.s_addr = inet_addr(_broadcast_ip);
addr->sin_port = htons(_broadcast_port); addr->sin_port = htons(_broadcast_port);
if (bind(sock, (struct sockaddr *)addr, sizeof(*addr)) < if (bind(sock, (struct sockaddr *) addr, sizeof(*addr)) <
0) { 0) {
fprintf(stderr, "Binding socket failed!\n"); fprintf(stderr, "Binding socket failed!\n");
return -1; return -1;
} }
return sock; return sock;
} }

87
src/network/multicastsocket.c
View file

@ -13,59 +13,58 @@
static struct ip_mreq command; /* static ?! */ static struct ip_mreq command; /* static ?! */
int setup_multicast_socket(const char *_multicast_ip, unsigned short _multicast_port, struct sockaddr_in *addr) int setup_multicast_socket(const char *_multicast_ip, unsigned short _multicast_port, struct sockaddr_in *addr) {
{ int loop = 1;
int loop = 1; int sock;
int sock;
memset (addr, 0, sizeof (*addr)); memset(addr, 0, sizeof(*addr));
addr->sin_family = AF_INET; addr->sin_family = AF_INET;
addr->sin_addr.s_addr = htonl (INADDR_ANY); addr->sin_addr.s_addr = htonl (INADDR_ANY);
addr->sin_port = htons (_multicast_port); addr->sin_port = htons (_multicast_port);
if ( ( sock = socket(PF_INET, SOCK_DGRAM, 0)) == -1) { if ((sock = socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
perror ("socket()"); perror("socket()");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
/* Mehr Prozessen erlauben, denselben Port zu nutzen */ /* Mehr Prozessen erlauben, denselben Port zu nutzen */
loop = 1; loop = 1;
if (setsockopt ( sock, if (setsockopt(sock,
SOL_SOCKET, SOL_SOCKET,
SO_REUSEADDR, SO_REUSEADDR,
&loop, sizeof (loop)) < 0) { &loop, sizeof(loop)) < 0) {
perror ("setsockopt:SO_REUSEADDR"); perror("setsockopt:SO_REUSEADDR");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
if(bind( sock, if (bind(sock,
(struct sockaddr *)addr, (struct sockaddr *) addr,
sizeof(*addr)) < 0) { sizeof(*addr)) < 0) {
perror ("bind"); perror("bind");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
/* Broadcast auf dieser Maschine zulassen */ /* Broadcast auf dieser Maschine zulassen */
loop = 1; loop = 1;
if (setsockopt ( sock, if (setsockopt(sock,
IPPROTO_IP, IPPROTO_IP,
IP_MULTICAST_LOOP, IP_MULTICAST_LOOP,
&loop, sizeof (loop)) < 0) { &loop, sizeof(loop)) < 0) {
perror ("setsockopt:IP_MULTICAST_LOOP"); perror("setsockopt:IP_MULTICAST_LOOP");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
/* Join the broadcast group: */ /* Join the broadcast group: */
command.imr_multiaddr.s_addr = inet_addr (_multicast_ip); command.imr_multiaddr.s_addr = inet_addr(_multicast_ip);
command.imr_interface.s_addr = htonl (INADDR_ANY); command.imr_interface.s_addr = htonl (INADDR_ANY);
if (command.imr_multiaddr.s_addr == -1) { if (command.imr_multiaddr.s_addr == -1) {
perror ("224.0.0.1 ist keine Multicast-Adresse\n"); perror("224.0.0.1 ist keine Multicast-Adresse\n");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
if (setsockopt ( sock, if (setsockopt(sock,
IPPROTO_IP, IPPROTO_IP,
IP_ADD_MEMBERSHIP, IP_ADD_MEMBERSHIP,
&command, sizeof (command)) < 0) { &command, sizeof(command)) < 0) {
perror ("setsockopt:IP_ADD_MEMBERSHIP"); perror("setsockopt:IP_ADD_MEMBERSHIP");
} }
return sock; return sock;
} }

203
src/network/networksocket.c
View file

@ -26,127 +26,120 @@ const char *ip;
unsigned short port; unsigned short port;
char recv_string[MAX_RECV_STRING + 1]; char recv_string[MAX_RECV_STRING + 1];
int recv_string_len; int recv_string_len;
void *receive_msg(void *args); void *receive_msg(void *args);
int init_socket_runopts(char *_ip, char *_port, int broadcast_socket) { int init_socket_runopts(char *_ip, char *_port, int broadcast_socket) {
port = atoi(_port);
ip = _ip;
if(broadcast_socket) port = atoi(_port);
{ ip = _ip;
sock = setup_broadcast_socket(ip, port, &addr);
} else
{
printf("Settingup multicastsocket!\n");
sock = setup_multicast_socket(ip, port, &addr);
}
pthread_t sniffer_thread; if (broadcast_socket) {
if (pthread_create(&sniffer_thread, NULL, receive_msg, NULL)) { sock = setup_broadcast_socket(ip, port, &addr);
fprintf(stderr, "Could not create receiving thread!"); } else {
return -1; printf("Settingup multicastsocket!\n");
} sock = setup_multicast_socket(ip, port, &addr);
}
fprintf(stdout, "Connected to %s:%d\n", ip, port); pthread_t sniffer_thread;
if (pthread_create(&sniffer_thread, NULL, receive_msg, NULL)) {
fprintf(stderr, "Could not create receiving thread!");
return -1;
}
return 0; fprintf(stdout, "Connected to %s:%d\n", ip, port);
return 0;
} }
void *receive_msg(void *args) { void *receive_msg(void *args) {
while (1) { while (1) {
if ((recv_string_len = if ((recv_string_len =
recvfrom(sock, recv_string, MAX_RECV_STRING, 0, NULL, 0)) < 0) { recvfrom(sock, recv_string, MAX_RECV_STRING, 0, NULL, 0)) < 0) {
fprintf(stderr, "Could not receive message!"); fprintf(stderr, "Could not receive message!");
continue; continue;
}
if (recv_string == NULL) {
return 0;
}
if (strlen(recv_string) <= 0) {
return 0;
}
recv_string[recv_string_len] = '\0';
printf("[WC] Network-Received: %s\n", recv_string);
probe_entry prob_req;
struct blob_buf b;
blob_buf_init(&b, 0);
blobmsg_add_json_from_string(&b, recv_string);
char *str;
str = blobmsg_format_json(b.head, true);
/*
TODO: REFACTOR THIS!!! (just workaround)
OTHERWISE NULLPOINTER?!
*/
if (str == NULL) {
return 0;
}
if (strlen(str) <= 0) {
return 0;
}
/*
HERE IS NULLPOINTER PROBABLY
*/
if (strstr(str, "clients") != NULL) {
parse_to_clients(b.head);
} else if (strstr(str, "target") != NULL) {
if (parse_to_probe_req(b.head, &prob_req) == 0) {
insert_to_array(prob_req, 0);
}
}
//if(parse_to_probe_req(b.head, &prob_req) == 0)
//{
// insert_to_array(prob_req, 0);
//}
// insert to list
//insert_to_list(prob_req, 0);
} }
if(recv_string == NULL)
{
return 0;
}
if(strlen(recv_string) <= 0)
{
return 0;
}
recv_string[recv_string_len] = '\0';
printf("[WC] Network-Received: %s\n", recv_string);
probe_entry prob_req;
struct blob_buf b;
blob_buf_init(&b, 0);
blobmsg_add_json_from_string(&b, recv_string);
char *str;
str = blobmsg_format_json(b.head, true);
/*
TODO: REFACTOR THIS!!! (just workaround)
OTHERWISE NULLPOINTER?!
*/
if(str == NULL)
{
return 0;
}
if( strlen(str) <= 0)
{
return 0;
}
/*
HERE IS NULLPOINTER PROBABLY
*/
if(strstr(str, "clients") != NULL) {
parse_to_clients(b.head);
} else if(strstr(str, "target")!= NULL)
{
if(parse_to_probe_req(b.head, &prob_req) == 0)
{
insert_to_array(prob_req, 0);
}
}
//if(parse_to_probe_req(b.head, &prob_req) == 0)
//{
// insert_to_array(prob_req, 0);
//}
// insert to list
//insert_to_list(prob_req, 0);
}
} }
int send_string(char *msg) { int send_string(char *msg) {
pthread_mutex_lock(&send_mutex); pthread_mutex_lock(&send_mutex);
int msglen = strlen(msg); int msglen = strlen(msg);
printf("Sending string! %s\n", msg); printf("Sending string! %s\n", msg);
if (sendto( sock, if (sendto(sock,
msg, msg,
msglen, msglen,
0, 0,
(struct sockaddr *) &addr, (struct sockaddr *) &addr,
sizeof (addr)) < 0) { sizeof(addr)) < 0) {
perror ("sendto()"); perror("sendto()");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
pthread_mutex_unlock(&send_mutex); pthread_mutex_unlock(&send_mutex);
/*if (sendto(sock, msg, msglen, 0, (struct sockaddr *)&addr, /*if (sendto(sock, msg, msglen, 0, (struct sockaddr *)&addr,
sizeof(addr)) != msglen) { sizeof(addr)) != msglen) {
fprintf(stderr, "Failed to send message.\n"); fprintf(stderr, "Failed to send message.\n");
return -1; return -1;
}*/ }*/
return 0; return 0;
} }
void close_socket() { close(sock); } void close_socket() { close(sock); }

1009
src/storage/datastorage.c
View file

File diff suppressed because it is too large Load diff

574
src/utils/ubus.c
View file

@ -18,81 +18,86 @@ static struct ubus_subscriber hostapd_event;
static struct blob_buf b; static struct blob_buf b;
enum { enum {
PROB_BSSID_ADDR, PROB_BSSID_ADDR,
PROB_CLIENT_ADDR, PROB_CLIENT_ADDR,
PROB_TARGET_ADDR, PROB_TARGET_ADDR,
PROB_SIGNAL, PROB_SIGNAL,
PROB_FREQ, PROB_FREQ,
PROB_HT_SUPPORT, PROB_HT_SUPPORT,
PROB_VHT_SUPPORT, PROB_VHT_SUPPORT,
__PROB_MAX, __PROB_MAX,
}; };
static const struct blobmsg_policy prob_policy[__PROB_MAX] = { static const struct blobmsg_policy prob_policy[__PROB_MAX] = {
[PROB_BSSID_ADDR] = {.name = "bssid", .type = BLOBMSG_TYPE_STRING}, [PROB_BSSID_ADDR] = {.name = "bssid", .type = BLOBMSG_TYPE_STRING},
[PROB_CLIENT_ADDR] = {.name = "address", .type = BLOBMSG_TYPE_STRING}, [PROB_CLIENT_ADDR] = {.name = "address", .type = BLOBMSG_TYPE_STRING},
[PROB_TARGET_ADDR] = {.name = "target", .type = BLOBMSG_TYPE_STRING}, [PROB_TARGET_ADDR] = {.name = "target", .type = BLOBMSG_TYPE_STRING},
[PROB_SIGNAL] = {.name = "signal", .type = BLOBMSG_TYPE_INT32}, [PROB_SIGNAL] = {.name = "signal", .type = BLOBMSG_TYPE_INT32},
[PROB_FREQ] = {.name = "freq", .type = BLOBMSG_TYPE_INT32}, [PROB_FREQ] = {.name = "freq", .type = BLOBMSG_TYPE_INT32},
[PROB_HT_SUPPORT] = {.name = "ht_support", .type = BLOBMSG_TYPE_INT8}, [PROB_HT_SUPPORT] = {.name = "ht_support", .type = BLOBMSG_TYPE_INT8},
[PROB_VHT_SUPPORT] = {.name = "vht_support", .type = BLOBMSG_TYPE_INT8}, [PROB_VHT_SUPPORT] = {.name = "vht_support", .type = BLOBMSG_TYPE_INT8},
}; };
enum { enum {
CLIENT_TABLE, CLIENT_TABLE,
CLIENT_TABLE_BSSID, CLIENT_TABLE_BSSID,
CLIENT_TABLE_FREQ, CLIENT_TABLE_FREQ,
CLIENT_TABLE_HT, CLIENT_TABLE_HT,
CLIENT_TABLE_VHT, CLIENT_TABLE_VHT,
__CLIENT_TABLE_MAX, __CLIENT_TABLE_MAX,
}; };
static const struct blobmsg_policy client_table_policy[__CLIENT_TABLE_MAX] = { static const struct blobmsg_policy client_table_policy[__CLIENT_TABLE_MAX] = {
[CLIENT_TABLE] = {.name = "clients", .type = BLOBMSG_TYPE_TABLE}, [CLIENT_TABLE] = {.name = "clients", .type = BLOBMSG_TYPE_TABLE},
[CLIENT_TABLE_BSSID] = {.name = "bssid", .type = BLOBMSG_TYPE_STRING}, [CLIENT_TABLE_BSSID] = {.name = "bssid", .type = BLOBMSG_TYPE_STRING},
[CLIENT_TABLE_FREQ] = {.name = "freq", .type = BLOBMSG_TYPE_INT32}, [CLIENT_TABLE_FREQ] = {.name = "freq", .type = BLOBMSG_TYPE_INT32},
[CLIENT_TABLE_HT] = {.name = "ht_supported", .type = BLOBMSG_TYPE_INT8}, [CLIENT_TABLE_HT] = {.name = "ht_supported", .type = BLOBMSG_TYPE_INT8},
[CLIENT_TABLE_VHT] = {.name = "vht_supported", .type = BLOBMSG_TYPE_INT8}, [CLIENT_TABLE_VHT] = {.name = "vht_supported", .type = BLOBMSG_TYPE_INT8},
}; };
enum { enum {
CLIENT_AUTH, CLIENT_AUTH,
CLIENT_ASSOC, CLIENT_ASSOC,
CLIENT_AUTHORIZED, CLIENT_AUTHORIZED,
CLIENT_PREAUTH, CLIENT_PREAUTH,
CLIENT_WDS, CLIENT_WDS,
CLIENT_WMM, CLIENT_WMM,
CLIENT_HT, CLIENT_HT,
CLIENT_VHT, CLIENT_VHT,
CLIENT_WPS, CLIENT_WPS,
CLIENT_MFP, CLIENT_MFP,
CLIENT_AID, CLIENT_AID,
__CLIENT_MAX, __CLIENT_MAX,
}; };
static const struct blobmsg_policy client_policy[__CLIENT_MAX] = { static const struct blobmsg_policy client_policy[__CLIENT_MAX] = {
[CLIENT_AUTH] = {.name = "auth", .type = BLOBMSG_TYPE_INT8}, [CLIENT_AUTH] = {.name = "auth", .type = BLOBMSG_TYPE_INT8},
[CLIENT_ASSOC] = {.name = "assoc", .type = BLOBMSG_TYPE_INT8}, [CLIENT_ASSOC] = {.name = "assoc", .type = BLOBMSG_TYPE_INT8},
[CLIENT_AUTHORIZED] = {.name = "authorized", .type = BLOBMSG_TYPE_INT8}, [CLIENT_AUTHORIZED] = {.name = "authorized", .type = BLOBMSG_TYPE_INT8},
[CLIENT_PREAUTH] = {.name = "preauth", .type = BLOBMSG_TYPE_INT8}, [CLIENT_PREAUTH] = {.name = "preauth", .type = BLOBMSG_TYPE_INT8},
[CLIENT_WDS] = {.name = "wds", .type = BLOBMSG_TYPE_INT8}, [CLIENT_WDS] = {.name = "wds", .type = BLOBMSG_TYPE_INT8},
[CLIENT_WMM] = {.name = "wmm", .type = BLOBMSG_TYPE_INT8}, [CLIENT_WMM] = {.name = "wmm", .type = BLOBMSG_TYPE_INT8},
[CLIENT_HT] = {.name = "ht", .type = BLOBMSG_TYPE_INT8}, [CLIENT_HT] = {.name = "ht", .type = BLOBMSG_TYPE_INT8},
[CLIENT_VHT] = {.name = "vht", .type = BLOBMSG_TYPE_INT8}, [CLIENT_VHT] = {.name = "vht", .type = BLOBMSG_TYPE_INT8},
[CLIENT_WPS] = {.name = "wps", .type = BLOBMSG_TYPE_INT8}, [CLIENT_WPS] = {.name = "wps", .type = BLOBMSG_TYPE_INT8},
[CLIENT_MFP] = {.name = "mfp", .type = BLOBMSG_TYPE_INT8}, [CLIENT_MFP] = {.name = "mfp", .type = BLOBMSG_TYPE_INT8},
[CLIENT_AID] = {.name = "aid", .type = BLOBMSG_TYPE_INT32}, [CLIENT_AID] = {.name = "aid", .type = BLOBMSG_TYPE_INT32},
}; };
/* Function Definitions */ /* Function Definitions */
static void hostapd_handle_remove(struct ubus_context *ctx, static void hostapd_handle_remove(struct ubus_context *ctx,
struct ubus_subscriber *s, uint32_t id); struct ubus_subscriber *s, uint32_t id);
static int hostapd_notify(struct ubus_context *ctx, struct ubus_object *obj, static int hostapd_notify(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method, struct ubus_request_data *req, const char *method,
struct blob_attr *msg); struct blob_attr *msg);
static int add_subscriber(char *name); static int add_subscriber(char *name);
static int subscribe_to_hostapd_interfaces(char *hostapd_dir); static int subscribe_to_hostapd_interfaces(char *hostapd_dir);
static int ubus_get_clients(); static int ubus_get_clients();
/* /*
static int decide_function(probe_entry *prob_req) { static int decide_function(probe_entry *prob_req) {
// TODO: Refactor... // TODO: Refactor...
@ -112,338 +117,325 @@ static int decide_function(probe_entry *prob_req) {
*/ */
static void hostapd_handle_remove(struct ubus_context *ctx, static void hostapd_handle_remove(struct ubus_context *ctx,
struct ubus_subscriber *s, uint32_t id) { struct ubus_subscriber *s, uint32_t id) {
fprintf(stderr, "Object %08x went away\n", id); fprintf(stderr, "Object %08x went away\n", id);
} }
int parse_to_probe_req(struct blob_attr *msg, probe_entry *prob_req) { int parse_to_probe_req(struct blob_attr *msg, probe_entry *prob_req) {
struct blob_attr *tb[__PROB_MAX]; struct blob_attr *tb[__PROB_MAX];
blobmsg_parse(prob_policy, __PROB_MAX, tb, blob_data(msg), blob_len(msg));
if (hwaddr_aton(blobmsg_data(tb[PROB_BSSID_ADDR]), prob_req->bssid_addr)) blobmsg_parse(prob_policy, __PROB_MAX, tb, blob_data(msg), blob_len(msg));
return UBUS_STATUS_INVALID_ARGUMENT;
if (hwaddr_aton(blobmsg_data(tb[PROB_CLIENT_ADDR]), prob_req->client_addr)) if (hwaddr_aton(blobmsg_data(tb[PROB_BSSID_ADDR]), prob_req->bssid_addr))
return UBUS_STATUS_INVALID_ARGUMENT; return UBUS_STATUS_INVALID_ARGUMENT;
if (hwaddr_aton(blobmsg_data(tb[PROB_TARGET_ADDR]), prob_req->target_addr)) if (hwaddr_aton(blobmsg_data(tb[PROB_CLIENT_ADDR]), prob_req->client_addr))
return UBUS_STATUS_INVALID_ARGUMENT; return UBUS_STATUS_INVALID_ARGUMENT;
if (tb[PROB_SIGNAL]) { if (hwaddr_aton(blobmsg_data(tb[PROB_TARGET_ADDR]), prob_req->target_addr))
prob_req->signal = blobmsg_get_u32(tb[PROB_SIGNAL]); return UBUS_STATUS_INVALID_ARGUMENT;
}
if (tb[PROB_FREQ]) { if (tb[PROB_SIGNAL]) {
prob_req->freq = blobmsg_get_u32(tb[PROB_FREQ]); prob_req->signal = blobmsg_get_u32(tb[PROB_SIGNAL]);
} }
if (tb[PROB_HT_SUPPORT]) { if (tb[PROB_FREQ]) {
prob_req->ht_support = blobmsg_get_u8(tb[PROB_HT_SUPPORT]); prob_req->freq = blobmsg_get_u32(tb[PROB_FREQ]);
} }
if (tb[PROB_VHT_SUPPORT]) { if (tb[PROB_HT_SUPPORT]) {
prob_req->vht_support = blobmsg_get_u8(tb[PROB_VHT_SUPPORT]); prob_req->ht_support = blobmsg_get_u8(tb[PROB_HT_SUPPORT]);
} }
return 0; if (tb[PROB_VHT_SUPPORT]) {
prob_req->vht_support = blobmsg_get_u8(tb[PROB_VHT_SUPPORT]);
}
return 0;
} }
static int hostapd_notify(struct ubus_context *ctx, struct ubus_object *obj, static int hostapd_notify(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method, struct ubus_request_data *req, const char *method,
struct blob_attr *msg) { struct blob_attr *msg) {
probe_entry prob_req; probe_entry prob_req;
parse_to_probe_req(msg, &prob_req); parse_to_probe_req(msg, &prob_req);
//insert_to_list(prob_req, 1); //insert_to_list(prob_req, 1);
insert_to_array(prob_req, 1); insert_to_array(prob_req, 1);
// send probe via network // send probe via network
char *str; char *str;
str = blobmsg_format_json(msg, true); str = blobmsg_format_json(msg, true);
send_string(str); send_string(str);
printf("[WC] Hostapd-Probe: %s : %s\n", method, str); printf("[WC] Hostapd-Probe: %s : %s\n", method, str);
print_array(); print_array();
// sleep(2); // sleep for 2s // sleep(2); // sleep for 2s
// deny access // deny access
//if (!decide_function(&prob_req)) { //if (!decide_function(&prob_req)) {
// return UBUS_STATUS_UNKNOWN_ERROR; // return UBUS_STATUS_UNKNOWN_ERROR;
//} //}
// allow access // allow access
return 0; return 0;
} }
static int add_subscriber(char *name) { static int add_subscriber(char *name) {
uint32_t id = 0; uint32_t id = 0;
if (ubus_lookup_id(ctx, name, &id)) { if (ubus_lookup_id(ctx, name, &id)) {
fprintf(stderr, "Failed to look up test object for %s\n", name); fprintf(stderr, "Failed to look up test object for %s\n", name);
return -1; return -1;
} }
// add callbacks // add callbacks
hostapd_event.remove_cb = hostapd_handle_remove; hostapd_event.remove_cb = hostapd_handle_remove;
hostapd_event.cb = hostapd_notify; hostapd_event.cb = hostapd_notify;
int ret = ubus_subscribe(ctx, &hostapd_event, id); int ret = ubus_subscribe(ctx, &hostapd_event, id);
fprintf(stderr, "Watching object %08x: %s\n", id, ubus_strerror(ret)); fprintf(stderr, "Watching object %08x: %s\n", id, ubus_strerror(ret));
return 0; return 0;
} }
static int subscribe_to_hostapd_interfaces(char *hostapd_dir) { static int subscribe_to_hostapd_interfaces(char *hostapd_dir) {
DIR *dirp; DIR *dirp;
struct dirent *entry; struct dirent *entry;
int ret = ubus_register_subscriber(ctx, &hostapd_event); int ret = ubus_register_subscriber(ctx, &hostapd_event);
if (ret) { if (ret) {
fprintf(stderr, "Failed to add watch handler: %s\n", ubus_strerror(ret)); fprintf(stderr, "Failed to add watch handler: %s\n", ubus_strerror(ret));
return -1; return -1;
}
dirp = opendir(hostapd_dir); // error handling?
while ((entry = readdir(dirp)) != NULL) {
if (entry->d_type == DT_SOCK) {
char subscribe_name[256];
sprintf(subscribe_name, "hostapd.%s", entry->d_name);
printf("Subscribing to %s\n", subscribe_name);
add_subscriber(subscribe_name);
} }
}
// free(hostapd_dir); // free string dirp = opendir(hostapd_dir); // error handling?
return 0; while ((entry = readdir(dirp)) != NULL) {
if (entry->d_type == DT_SOCK) {
char subscribe_name[256];
sprintf(subscribe_name, "hostapd.%s", entry->d_name);
printf("Subscribing to %s\n", subscribe_name);
add_subscriber(subscribe_name);
}
}
// free(hostapd_dir); // free string
return 0;
} }
int dawn_init_ubus(const char *ubus_socket, char *hostapd_dir) { int dawn_init_ubus(const char *ubus_socket, char *hostapd_dir) {
uloop_init(); uloop_init();
signal(SIGPIPE, SIG_IGN); signal(SIGPIPE, SIG_IGN);
ctx = ubus_connect(ubus_socket); ctx = ubus_connect(ubus_socket);
if (!ctx) { if (!ctx) {
fprintf(stderr, "Failed to connect to ubus\n"); fprintf(stderr, "Failed to connect to ubus\n");
return -1; return -1;
} else { } else {
printf("Connected to ubus\n"); printf("Connected to ubus\n");
} }
ubus_add_uloop(ctx); ubus_add_uloop(ctx);
subscribe_to_hostapd_interfaces(hostapd_dir); subscribe_to_hostapd_interfaces(hostapd_dir);
ubus_get_clients(); ubus_get_clients();
/*
printf("Deleting Client\n");
//"78:02:f8:bc:ac:0b"
int tmp_int_mac[ETH_ALEN]; uloop_run();
uint8_t tmp_mac[ETH_ALEN];
sscanf("78:02:f8:bc:ac:0b", "%x:%x:%x:%x:%x:%x", STR2MAC(tmp_int_mac));
for(int i = 0; i < ETH_ALEN; ++i )
tmp_mac[i] = (uint8_t) tmp_int_mac[i];
del_client(tmp_mac, 5, 1, 60000);
*/
uloop_run();
close_socket(); close_socket();
ubus_free(ctx); ubus_free(ctx);
uloop_done(); uloop_done();
return 0; return 0;
} }
static void static void
dump_client(struct blob_attr **tb, uint8_t client_addr[], const char* bssid_addr, uint32_t freq, uint8_t ht_supported, uint8_t vht_supported) dump_client(struct blob_attr **tb, uint8_t client_addr[], const char *bssid_addr, uint32_t freq, uint8_t ht_supported,
{ uint8_t vht_supported) {
client client_entry; client client_entry;
hwaddr_aton(bssid_addr, client_entry.bssid_addr); hwaddr_aton(bssid_addr, client_entry.bssid_addr);
memcpy(client_entry.client_addr, client_addr, ETH_ALEN * sizeof(uint8_t)); memcpy(client_entry.client_addr, client_addr, ETH_ALEN * sizeof(uint8_t));
//char mac_buf_client[20]; //char mac_buf_client[20];
//char mac_buf_ap[20]; //char mac_buf_ap[20];
//sprintf(mac_buf_ap, "%x:%x:%x:%x:%x:%x", MAC2STR(client_entry.bssid_addr)); //sprintf(mac_buf_ap, "%x:%x:%x:%x:%x:%x", MAC2STR(client_entry.bssid_addr));
//sprintf(mac_buf_client, "%x:%x:%x:%x:%x:%x", MAC2STR(client_entry.client_addr)); //sprintf(mac_buf_client, "%x:%x:%x:%x:%x:%x", MAC2STR(client_entry.client_addr));
//printf("Frequency is: %d\n",freq); //printf("Frequency is: %d\n",freq);
client_entry.freq = freq; client_entry.freq = freq;
client_entry.ht_supported = ht_supported; client_entry.ht_supported = ht_supported;
client_entry.vht_supported = vht_supported; client_entry.vht_supported = vht_supported;
if (tb[CLIENT_AUTH]) { if (tb[CLIENT_AUTH]) {
client_entry.auth = blobmsg_get_u8(tb[CLIENT_AUTH]); client_entry.auth = blobmsg_get_u8(tb[CLIENT_AUTH]);
} }
if (tb[CLIENT_ASSOC]) { if (tb[CLIENT_ASSOC]) {
client_entry.assoc = blobmsg_get_u8(tb[CLIENT_ASSOC]); client_entry.assoc = blobmsg_get_u8(tb[CLIENT_ASSOC]);
} }
if(tb[CLIENT_AUTHORIZED]) if (tb[CLIENT_AUTHORIZED]) {
{ client_entry.authorized = blobmsg_get_u8(tb[CLIENT_AUTHORIZED]);
client_entry.authorized = blobmsg_get_u8(tb[CLIENT_AUTHORIZED]); }
} if (tb[CLIENT_PREAUTH]) {
if(tb[CLIENT_PREAUTH]){ client_entry.preauth = blobmsg_get_u8(tb[CLIENT_PREAUTH]);
client_entry.preauth = blobmsg_get_u8(tb[CLIENT_PREAUTH]); }
} if (tb[CLIENT_WDS]) {
if(tb[CLIENT_WDS]){ client_entry.wds = blobmsg_get_u8(tb[CLIENT_WDS]);
client_entry.wds = blobmsg_get_u8(tb[CLIENT_WDS]); }
} if (tb[CLIENT_WMM]) {
if(tb[CLIENT_WMM]){ client_entry.wmm = blobmsg_get_u8(tb[CLIENT_WMM]);
client_entry.wmm = blobmsg_get_u8(tb[CLIENT_WMM]); }
} if (tb[CLIENT_HT]) {
if(tb[CLIENT_HT]){ client_entry.ht = blobmsg_get_u8(tb[CLIENT_HT]);
client_entry.ht = blobmsg_get_u8(tb[CLIENT_HT]); }
} if (tb[CLIENT_VHT]) {
if(tb[CLIENT_VHT]){ client_entry.vht = blobmsg_get_u8(tb[CLIENT_VHT]);
client_entry.vht = blobmsg_get_u8(tb[CLIENT_VHT]); }
} if (tb[CLIENT_WPS]) {
if(tb[CLIENT_WPS]){ client_entry.wps = blobmsg_get_u8(tb[CLIENT_WPS]);
client_entry.wps = blobmsg_get_u8(tb[CLIENT_WPS]); }
} if (tb[CLIENT_MFP]) {
if(tb[CLIENT_MFP]){ client_entry.mfp = blobmsg_get_u8(tb[CLIENT_MFP]);
client_entry.mfp = blobmsg_get_u8(tb[CLIENT_MFP]); }
} if (tb[CLIENT_AID]) {
if(tb[CLIENT_AID]){ client_entry.aid = blobmsg_get_u32(tb[CLIENT_AID]);
client_entry.aid = blobmsg_get_u32(tb[CLIENT_AID]); }
}
insert_client_to_array(client_entry); insert_client_to_array(client_entry);
} }
static void static void
dump_client_table(struct blob_attr *head, int len, const char* bssid_addr, uint32_t freq, uint8_t ht_supported, uint8_t vht_supported) dump_client_table(struct blob_attr *head, int len, const char *bssid_addr, uint32_t freq, uint8_t ht_supported,
{ uint8_t vht_supported) {
struct blob_attr *attr; struct blob_attr *attr;
struct blobmsg_hdr *hdr; struct blobmsg_hdr *hdr;
__blob_for_each_attr(attr, head, len) { __blob_for_each_attr(attr, head, len)
hdr = blob_data(attr); {
hdr = blob_data(attr);
struct blob_attr *tb[__CLIENT_MAX]; struct blob_attr *tb[__CLIENT_MAX];
blobmsg_parse(client_policy, __CLIENT_MAX, tb, blobmsg_data(attr), blobmsg_len(attr)); blobmsg_parse(client_policy, __CLIENT_MAX, tb, blobmsg_data(attr), blobmsg_len(attr));
//char* str = blobmsg_format_json_indent(attr, true, -1); //char* str = blobmsg_format_json_indent(attr, true, -1);
int tmp_int_mac[ETH_ALEN]; int tmp_int_mac[ETH_ALEN];
uint8_t tmp_mac[ETH_ALEN]; uint8_t tmp_mac[ETH_ALEN];
sscanf((char*)hdr->name, "%x:%x:%x:%x:%x:%x", STR2MAC(tmp_int_mac)); sscanf((char *) hdr->name, "%x:%x:%x:%x:%x:%x", STR2MAC(tmp_int_mac));
for(int i = 0; i < ETH_ALEN; ++i ) for (int i = 0; i < ETH_ALEN; ++i)
tmp_mac[i] = (uint8_t) tmp_int_mac[i]; tmp_mac[i] = (uint8_t) tmp_int_mac[i];
dump_client(tb, tmp_mac, bssid_addr, freq, ht_supported, vht_supported); dump_client(tb, tmp_mac, bssid_addr, freq, ht_supported, vht_supported);
} }
} }
int parse_to_clients(struct blob_attr *msg) { int parse_to_clients(struct blob_attr *msg) {
struct blob_attr *tb[__CLIENT_TABLE_MAX]; struct blob_attr *tb[__CLIENT_TABLE_MAX];
blobmsg_parse(client_table_policy, __CLIENT_TABLE_MAX, tb, blob_data(msg), blob_len(msg)); blobmsg_parse(client_table_policy, __CLIENT_TABLE_MAX, tb, blob_data(msg), blob_len(msg));
if (tb[CLIENT_TABLE] && tb[CLIENT_TABLE_BSSID] && tb[CLIENT_TABLE_FREQ] && tb[CLIENT_TABLE_HT] && tb[CLIENT_TABLE_VHT]) { if (tb[CLIENT_TABLE] && tb[CLIENT_TABLE_BSSID] && tb[CLIENT_TABLE_FREQ] && tb[CLIENT_TABLE_HT] &&
dump_client_table(blobmsg_data(tb[CLIENT_TABLE]), blobmsg_data_len(tb[CLIENT_TABLE]), blobmsg_data(tb[CLIENT_TABLE_BSSID]), blobmsg_get_u32(tb[CLIENT_TABLE_FREQ]), blobmsg_get_u8(tb[CLIENT_TABLE_HT]), blobmsg_get_u8(tb[CLIENT_TABLE_VHT])); tb[CLIENT_TABLE_VHT]) {
dump_client_table(blobmsg_data(tb[CLIENT_TABLE]), blobmsg_data_len(tb[CLIENT_TABLE]),
/* BSSID */ blobmsg_data(tb[CLIENT_TABLE_BSSID]), blobmsg_get_u32(tb[CLIENT_TABLE_FREQ]),
/* blobmsg_get_u8(tb[CLIENT_TABLE_HT]), blobmsg_get_u8(tb[CLIENT_TABLE_VHT]));
* here i know my bssid to kick the clients
* seems a good idea ?!
*/
uint8_t bssid[ETH_ALEN];
hwaddr_aton(blobmsg_data(tb[CLIENT_TABLE_BSSID]), bssid);
kick_clients(bssid);
}
return 0; /* BSSID */
/*
* here i know my bssid to kick the clients
* seems a good idea ?!
*/
uint8_t bssid[ETH_ALEN];
hwaddr_aton(blobmsg_data(tb[CLIENT_TABLE_BSSID]), bssid);
kick_clients(bssid);
}
return 0;
} }
static void ubus_get_clients_cb(struct ubus_request *req, int type, struct blob_attr *msg) static void ubus_get_clients_cb(struct ubus_request *req, int type, struct blob_attr *msg) {
{ if (!msg)
if (!msg) return;
return;
parse_to_clients(msg); parse_to_clients(msg);
char *str = blobmsg_format_json(msg, true); char *str = blobmsg_format_json(msg, true);
send_string(str); send_string(str);
print_client_array(); print_client_array();
} }
static int ubus_get_clients() { static int ubus_get_clients() {
DIR *dirp; DIR *dirp;
struct dirent *entry; struct dirent *entry;
dirp = opendir(hostapd_dir_glob); // error handling? dirp = opendir(hostapd_dir_glob); // error handling?
while ((entry = readdir(dirp)) != NULL) { while ((entry = readdir(dirp)) != NULL) {
if (entry->d_type == DT_SOCK) { if (entry->d_type == DT_SOCK) {
char hostapd_iface[256]; char hostapd_iface[256];
uint32_t id; uint32_t id;
sprintf(hostapd_iface, "hostapd.%s", entry->d_name); sprintf(hostapd_iface, "hostapd.%s", entry->d_name);
int ret = ubus_lookup_id(ctx, hostapd_iface, &id); int ret = ubus_lookup_id(ctx, hostapd_iface, &id);
if(!ret) if (!ret) {
{ int timeout = 1;
int timeout = 1; ubus_invoke(ctx, id, "get_clients", NULL, ubus_get_clients_cb, NULL, timeout * 1000);
ubus_invoke(ctx, id, "get_clients", NULL, ubus_get_clients_cb, NULL, timeout * 1000); }
} }
} }
} return 0;
return 0;
} }
void *update_clients_thread(void *arg) void *update_clients_thread(void *arg) {
{ while (1) {
while (1){ sleep(TIME_THRESHOLD_CLIENT_UPDATE);
sleep(TIME_THRESHOLD_CLIENT_UPDATE); printf("[Thread] : Updating clients!\n");
printf("[Thread] : Updating clients!\n"); ubus_get_clients();
ubus_get_clients(); }
} return 0;
return 0;
} }
/* hostapd function */ /* hostapd function */
#define MACSTR "%02x:%02x:%02x:%02x:%02x:%02x" #define MACSTR "%02x:%02x:%02x:%02x:%02x:%02x"
static void static void
blobmsg_add_macaddr(struct blob_buf *buf, const char *name, const uint8_t *addr) bblobmsg_add_macaddr(struct blob_buf *buf, const char *name, const uint8_t *addr) {
{ char *s;
char *s;
s = blobmsg_alloc_string_buffer(buf, name, 20); s = blobmsg_alloc_string_buffer(buf, name, 20);
sprintf(s, MACSTR, MAC2STR(addr)); sprintf(s, MACSTR, MAC2STR(addr));
blobmsg_add_string_buffer(buf); blobmsg_add_string_buffer(buf);
} }
void del_client(const uint8_t* client_addr, uint32_t reason, uint8_t deauth, uint32_t ban_time) void del_client(const uint8_t *client_addr, uint32_t reason, uint8_t deauth, uint32_t ban_time) {
{ /* Problem:
/* Problem: On which interface is the client?
On which interface is the client? First send to all ifaces to ban client... xD
First send to all ifaces to ban client... xD Maybe Hashmap?
Maybe Hashmap?
* get_clients method and look if client is there * get_clients method and look if client is there
* save on which hostapd the client is... * save on which hostapd the client is...
*/ */
blob_buf_init(&b, 0); blob_buf_init(&b, 0);
blobmsg_add_macaddr(&b, "addr", client_addr); blobmsg_add_macaddr(&b, "addr", client_addr);
blobmsg_add_u32(&b, "reason", reason); blobmsg_add_u32(&b, "reason", reason);
blobmsg_add_u8(&b, "deauth", deauth); blobmsg_add_u8(&b, "deauth", deauth);
blobmsg_add_u32(&b, "ban_time", ban_time); blobmsg_add_u32(&b, "ban_time", ban_time);
DIR *dirp; DIR *dirp;
struct dirent *entry; struct dirent *entry;
dirp = opendir(hostapd_dir_glob); // error handling? dirp = opendir(hostapd_dir_glob); // error handling?
while ((entry = readdir(dirp)) != NULL) { while ((entry = readdir(dirp)) != NULL) {
if (entry->d_type == DT_SOCK) { if (entry->d_type == DT_SOCK) {
char hostapd_iface[256]; char hostapd_iface[256];
uint32_t id; uint32_t id;
sprintf(hostapd_iface, "hostapd.%s", entry->d_name); sprintf(hostapd_iface, "hostapd.%s", entry->d_name);
int ret = ubus_lookup_id(ctx, hostapd_iface, &id); int ret = ubus_lookup_id(ctx, hostapd_iface, &id);
if(!ret) if (!ret) {
{ int timeout = 1;
int timeout = 1; ubus_invoke(ctx, id, "del_client", b.head, NULL, NULL, timeout * 1000);
ubus_invoke(ctx, id, "del_client", b.head, NULL, NULL, timeout * 1000); }
} }
} }
}
} }