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

multiple update

This commit is contained in:
vemax78 2013-05-03 22:28:06 +02:00
parent f2dda6e115
commit 9082a7855c
10 changed files with 635 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

220
conf/wtp.conf
View File

@ -1,110 +1,110 @@
# WTP configuration file
version = "1.0";
application: {
name = "wtp 1";
location = "Ufficio";
binding = "802.11";
tunnelmode: {
nativeframe = false;
ethframe = false;
localbridging = false;
};
mactype = "localmac";
boardinfo: {
idvendor = 123456;
element = (
{ name = "model"; value = "1.0"; },
{ name = "serial"; value = "2.0"; },
{ name = "id"; value = "3.0"; },
{ name = "revision"; value = "4.0"; },
{ name = "macaddress"; type = "interface"; value = "eth1"; }
);
};
descriptor: {
radio = (
{ device = "wifi0"; type = "bg"; status = "enabled"; }
);
encryption = [
"802.11_AES",
"802.11_TKIP"
];
info = (
{ idvendor = 23456; type = "hardware"; value = "abcde"; },
{ idvendor = 33457; type = "software"; value = "fghil"; },
{ idvendor = 43458; type = "boot"; value = "mnopq"; },
{ idvendor = 53459; type = "other"; value = "qwert"; }
);
};
ecn = "limited";
timer: {
statistics = 120;
};
dtls: {
enable = true;
dtlspolicy: {
cleardatachannel = true;
dtlsdatachannel = true;
};
type = "x509";
presharedkey: {
# TODO
};
x509: {
calist = "/etc/capwap/ca.crt";
certificate = "/etc/capwap/wtp.crt";
privatekey = "/etc/capwap/wtp.key";
privatekeypassword = "";
};
};
network: {
#binding = "eth1";
mtu = 1500;
port = 10000;
transport = "udp";
ipv4 = true;
ipv6 = false;
ipdualstack = true;
};
acdiscovery: {
search = false;
host = [
"127.0.0.1"
];
};
acprefered: {
host = [
"127.0.0.1"
];
};
};
logging: {
enable = true;
level = "debug";
output = (
{ mode = "stdout"; }
);
};
# WTP configuration file
version = "1.0";
application: {
name = "wtp 1";
location = "Ufficio";
binding = "802.11";
tunnelmode: {
nativeframe = false;
ethframe = false;
localbridging = false;
};
mactype = "localmac";
boardinfo: {
idvendor = 123456;
element = (
{ name = "model"; value = "1.0"; },
{ name = "serial"; value = "2.0"; },
{ name = "id"; value = "3.0"; },
{ name = "revision"; value = "4.0"; },
{ name = "macaddress"; type = "interface"; value = "eth1"; }
);
};
descriptor: {
radio = (
{ device = "phy0"; driver = "nl80211"; type = "bg"; status = "enabled"; }
);
encryption = [
"802.11_AES",
"802.11_TKIP"
];
info = (
{ idvendor = 23456; type = "hardware"; value = "abcde"; },
{ idvendor = 33457; type = "software"; value = "fghil"; },
{ idvendor = 43458; type = "boot"; value = "mnopq"; },
{ idvendor = 53459; type = "other"; value = "qwert"; }
);
};
ecn = "limited";
timer: {
statistics = 120;
};
dtls: {
enable = true;
dtlspolicy: {
cleardatachannel = true;
dtlsdatachannel = true;
};
type = "x509";
presharedkey: {
# TODO
};
x509: {
calist = "/etc/capwap/ca.crt";
certificate = "/etc/capwap/wtp.crt";
privatekey = "/etc/capwap/wtp.key";
privatekeypassword = "";
};
};
network: {
#binding = "eth1";
mtu = 1500;
port = 10000;
transport = "udp";
ipv4 = true;
ipv6 = false;
ipdualstack = true;
};
acdiscovery: {
search = false;
host = [
"127.0.0.1"
];
};
acprefered: {
host = [
"127.0.0.1"
];
};
};
logging: {
enable = true;
level = "debug";
output = (
{ mode = "stdout"; }
);
};

4
configure.ac
View File

@ -96,7 +96,7 @@ AC_ARG_WITH(
# WTP drivers wifi binding
AC_ARG_ENABLE(
[wifi-drivers-nl80211],
[AS_HELP_STRING([--wifi-drivers-nl80211], [disable WTP support for nl80211 wifi binding @<:@default=yes@:>@])],
[AS_HELP_STRING([--disable-wifi-drivers-nl80211], [disable WTP support for nl80211 wifi binding @<:@default=yes@:>@])],
,
[enable_wifi_drivers_nl80211="yes"]
)
@ -115,6 +115,7 @@ if test "${enable_debug}" = "yes"; then
CFLAGS="${CFLAGS} -DDEBUG -Wall -Werror -g -O0"
else
CFLAGS="${CFLAGS} -O2"
AC_DEFINE([DISABLE_LOGGING_DEBUG], [1], [Disable logging debug])
fi
#
@ -231,7 +232,6 @@ PKG_CHECK_MODULES(
)]
)]
)
test "$has_libnl_ver" -gt 1 &&
if test "${enable_wifi_drivers_nl80211}" = "yes"; then
AC_CHECK_HEADERS([netlink/genl/genl.h netlink/genl/family.h netlink/genl/ctrl.h], [], [AC_MSG_ERROR(You need the netlink header)])

83
src/binding/wifi/drivers/wifi_drivers.c
View File

@ -1,11 +1,5 @@
#include "wifi_drivers.h"
/* */
struct wifi_driver_instance {
struct wifi_driver_ops* ops; /* Driver functions */
wifi_global_handle handle; /* Global instance handle */
};
#include "capwap_array.h"
/* Declare enable wifi driver */
#ifdef ENABLE_WIFI_DRIVERS_NL80211
@ -19,30 +13,93 @@ static struct wifi_driver_instance wifi_driver[] = {
{ NULL }
};
/* Radio instance */
static struct capwap_array* wifi_device = NULL;
/* */
int wifi_init_driver(void) {
int i;
for (i = 0; wifi_driver[i].ops != NULL; i++) {
if (!wifi_driver[i].ops->global_init) {
return -1;
}
/* Initialize driver */
ASSERT(wifi_driver[i].ops->global_init != NULL);
wifi_driver[i].handle = wifi_driver[i].ops->global_init();
}
/* Device handler */
wifi_device = capwap_array_create(sizeof(struct wifi_device), 0);
wifi_device->zeroed = 1;
return 0;
}
/* */
void wifi_free_driver(void) {
int i;
unsigned long i;
/* Free device */
if (wifi_device) {
for (i = 0; i < wifi_device->count; i++) {
struct wifi_device* device = (struct wifi_device*)capwap_array_get_item_pointer(wifi_device, i);
if (device->instance->ops->device_deinit) {
device->instance->ops->device_deinit(device->handle);
}
}
capwap_array_free(wifi_device);
}
/* Free driver */
for (i = 0; wifi_driver[i].ops != NULL; i++) {
/* Free driver */
if (wifi_driver[i].ops->global_deinit) {
wifi_driver[i].ops->global_deinit(wifi_driver[i].handle);
}
}
}
/* */
int wifi_create_device(int radioid, char* ifname, char* driver) {
int i;
int length;
int result = -1;
ASSERT(radioid > 0);
ASSERT(ifname != NULL);
ASSERT(driver != NULL);
/* Check */
length = strlen(ifname);
if ((length <= 0) || (length >= IFNAMSIZ)) {
capwap_logging_warning("Wifi device name error: %s", ifname);
return -1;
} else if (wifi_device->count >= radioid) {
capwap_logging_warning("Wifi device RadioID already used: %d", radioid);
return -1;
}
/* Search driver */
for (i = 0; wifi_driver[i].ops != NULL; i++) {
if (!strcmp(driver, wifi_driver[i].ops->name)) {
wifi_device_handle devicehandle;
struct device_init_params params = {
.ifname = ifname
};
/* Device init */
ASSERT(wifi_driver[i].ops->device_init);
devicehandle = wifi_driver[i].ops->device_init(wifi_driver[i].handle, &params);
if (devicehandle) {
/* Register new device */
struct wifi_device* device = (struct wifi_device*)capwap_array_get_item_pointer(wifi_device, radioid);
device->handle = devicehandle;
device->instance = &wifi_driver[i];
result = 0;
}
break;
}
}
return result;
}

19
src/binding/wifi/drivers/wifi_drivers.h
View File

@ -8,10 +8,14 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <net/if.h>
#include "capwap_debug.h"
#include "capwap_logging.h"
/* */
#define WIFI_DRIVER_NAME_SIZE 16
/* */
typedef void* wifi_global_handle;
typedef void* wifi_device_handle;
@ -35,8 +39,23 @@ struct wifi_driver_ops {
void (*device_deinit)(wifi_device_handle handle);
};
/* */
struct wifi_driver_instance {
struct wifi_driver_ops* ops; /* Driver functions */
wifi_global_handle handle; /* Global instance handle */
};
/* */
struct wifi_device {
wifi_device_handle handle; /* Device handle */
struct wifi_driver_instance* instance; /* Driver instance */
};
/* Initialize wifi driver engine */
int wifi_init_driver(void);
void wifi_free_driver(void);
/* */
int wifi_create_device(int radioid, char* ifname, char* driver);
#endif /* __WIFI_DRIVERS_HEADER__ */

269
src/binding/wifi/drivers/wifi_nl80211.c
View File

@ -1,14 +1,17 @@
#include "wifi_drivers.h"
#include <sys/types.h>
#include <unistd.h>
#include <net/if.h>
#include <netlink/genl/genl.h>
#include <netlink/genl/family.h>
#include <netlink/genl/ctrl.h>
#include <linux/nl80211.h>
#include "capwap_list.h"
#include "wifi_nl80211.h"
/* Compatibility functions */
#if !defined(HAVE_LIBNL20) && !defined(HAVE_LIBNL30)
#define nl_sock nl_handle
static uint32_t port_bitmap[32] = { 0 };
static struct nl_sock* nl_socket_alloc_cb(void* cb) {
@ -42,21 +45,275 @@ static void nl_socket_free(struct nl_sock* handle) {
#endif
/* */
wifi_device_handle nl80211_device_init(wifi_global_handle handle, struct device_init_params* params) {
return NULL;
static struct nl_sock* nl_create_handle(struct nl_cb* cb) {
struct nl_sock* handle;
handle = nl_socket_alloc_cb(cb);
if (!handle) {
return NULL;
}
if (genl_connect(handle)) {
nl_socket_free(handle);
return NULL;
}
return handle;
}
/* */
void nl80211_device_deinit(wifi_device_handle handle) {
static int nl80211_no_seq_check(struct nl_msg* msg, void* arg) {
return NL_OK;
}
/* */
static int nl80211_error_handler(struct sockaddr_nl* nla, struct nlmsgerr* err, void* arg) {
*((int*)arg) = err->error;
return NL_STOP;
}
/* */
static int nl80211_finish_handler(struct nl_msg* msg, void* arg) {
*((int*)arg) = 0;
return NL_SKIP;
}
/* */
static int nl80211_ack_handler(struct nl_msg* msg, void* arg) {
*((int*)arg) = 0;
return NL_STOP;
}
/* */
static int nl80211_send_and_recv(struct nl_sock* nl, struct nl_cb* nl_cb, struct nl_msg* msg, nl_valid_cb valid_cb, void* data) {
int result;
struct nl_cb* cb;
/* Clone netlink callback */
cb = nl_cb_clone(nl_cb);
if (!cb) {
return -1;
}
/* Complete send message */
result = nl_send_auto_complete(nl, msg);
if (result < 0) {
nl_cb_put(cb);
return -1;
}
/* Customize message callback */
nl_cb_err(cb, NL_CB_CUSTOM, nl80211_error_handler, &result);
nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, nl80211_finish_handler, &result);
nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, nl80211_ack_handler, &result);
if (valid_cb) {
nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, valid_cb, data);
}
result = 1;
while (result > 0) {
nl_recvmsgs(nl, cb);
}
nl_cb_put(cb);
return result;
}
/* */
static int nl80211_send_and_recv_msg(struct nl80211_global_handle* globalhandle, struct nl_msg* msg, nl_valid_cb valid_cb, void* data) {
return nl80211_send_and_recv(globalhandle->nl, globalhandle->nl_cb, msg, valid_cb, data);
}
/* */
static int cb_get_phydevice_list(struct nl_msg* msg, void* data) {
struct nlattr* tb_msg[NL80211_ATTR_MAX + 1];
struct genlmsghdr* gnlh = nlmsg_data(nlmsg_hdr(msg));
struct capwap_list* list = (struct capwap_list*)data;
nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), NULL);
if (tb_msg[NL80211_ATTR_WIPHY_NAME] && tb_msg[NL80211_ATTR_WIPHY]) {
struct capwap_list_item* item = capwap_itemlist_create(sizeof(struct nl80211_phydevice_item));
struct nl80211_phydevice_item* phyitem = (struct nl80211_phydevice_item*)item->item;
/* Add physical device info */
phyitem->index = nla_get_u32(tb_msg[NL80211_ATTR_WIPHY]);
strcpy(phyitem->name, nla_get_string(tb_msg[NL80211_ATTR_WIPHY_NAME]));
capwap_itemlist_insert_after(list, NULL, item);
}
return NL_SKIP;
}
/* */
static int nl80211_get_phydevice_list(struct nl80211_global_handle* globalhandle, struct capwap_list* list) {
int result;
struct nl_msg* msg;
ASSERT(globalhandle != NULL);
ASSERT(list != NULL);
/* */
msg = nlmsg_alloc();
if (!msg) {
return -1;
}
/* Retrieve list of physical device */
genlmsg_put(msg, 0, 0, globalhandle->nl80211_id, 0, NLM_F_DUMP, NL80211_CMD_GET_WIPHY, 0);
/* Retrieve all physical interface */
result = nl80211_send_and_recv_msg(globalhandle, msg, cb_get_phydevice_list, list);
/* */
nlmsg_free(msg);
return result;
}
/* */
static wifi_device_handle nl80211_device_init(wifi_global_handle handle, struct device_init_params* params) {
int result;
struct capwap_list* list;
struct capwap_list_item* item;
struct nl80211_device_handle* devicehandle = NULL;
struct nl80211_global_handle* globalhandle = (struct nl80211_global_handle*)handle;
ASSERT(params != NULL);
if (!handle) {
return NULL;
}
/* Retrieve physical device info */
list = capwap_list_create();
result = nl80211_get_phydevice_list(globalhandle, list);
if (!result) {
item = list->first;
while (item) {
struct nl80211_phydevice_item* phyitem = (struct nl80211_phydevice_item*)item->item;
if (!strcmp(phyitem->name, params->ifname)) {
/* Create device */
devicehandle = (struct nl80211_device_handle*)capwap_alloc(sizeof(struct nl80211_device_handle));
memset(devicehandle, 0, sizeof(struct nl80211_device_handle));
/* */
strcpy(devicehandle->phyname, phyitem->name);
devicehandle->phyindex = phyitem->index;
break;
}
/* Next */
item = item->next;
}
} else {
/* Error get physical devices */
capwap_logging_error("Unable retrieve physical device info, error code: %d", result);
}
/* */
capwap_list_free(list);
if (!devicehandle) {
return NULL;
}
/* */
devicehandle->globalhandle = globalhandle;
/* Save device handle into global handle */
item = capwap_itemlist_create_with_item(devicehandle, sizeof(struct nl80211_device_handle));
capwap_itemlist_insert_after(globalhandle->devicelist, NULL, item);
return devicehandle;
}
/* */
static void nl80211_device_deinit(wifi_device_handle handle) {
struct nl80211_device_handle* devicehandle = (struct nl80211_device_handle*)handle;
if (devicehandle) {
struct capwap_list_item* search;
/* Remove device handle from global handle*/
search = devicehandle->globalhandle->devicelist->first;
while (search) {
/* Remove item from list without destroy */
if ((struct nl80211_device_handle*)search->item == devicehandle) {
capwap_itemlist_remove(devicehandle->globalhandle->devicelist, search);
break;
}
search = search->next;
}
/* */
capwap_free(devicehandle);
}
}
/* */
static wifi_global_handle nl80211_global_init(void) {
return NULL;
struct nl80211_global_handle* globalhandle;
/* */
globalhandle = (struct nl80211_global_handle*)capwap_alloc(sizeof(struct nl80211_global_handle));
memset(globalhandle, 0, sizeof(struct nl80211_global_handle));
/* Configure global netlink callback */
globalhandle->nl_cb = nl_cb_alloc(NL_CB_DEFAULT);
if (!globalhandle->nl_cb) {
capwap_free(globalhandle);
return NULL;
}
/* Create netlink socket */
globalhandle->nl = nl_create_handle(globalhandle->nl_cb);
if (!globalhandle->nl) {
nl_cb_put(globalhandle->nl_cb);
capwap_free(globalhandle);
return NULL;
}
/* Get nl80211 netlink family */
globalhandle->nl80211_id = genl_ctrl_resolve(globalhandle->nl, "nl80211");
if (globalhandle->nl80211_id < 0) {
capwap_logging_warning("Unable to found mac80211 kernel module");
nl_socket_free(globalhandle->nl);
nl_cb_put(globalhandle->nl_cb);
capwap_free(globalhandle);
return NULL;
}
/* Configure global callback function */
nl_cb_set(globalhandle->nl_cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, nl80211_no_seq_check, NULL);
/* TODO */
/* Device list */
globalhandle->devicelist = capwap_list_create();
return (wifi_global_handle)globalhandle;
}
/* */
void nl80211_global_deinit(wifi_global_handle handle) {
static void nl80211_global_deinit(wifi_global_handle handle) {
struct nl80211_global_handle* globalhandle = (struct nl80211_global_handle*)handle;
if (globalhandle) {
ASSERT(globalhandle->devicelist->count == 0);
if (globalhandle->nl) {
nl_socket_free(globalhandle->nl);
}
if (globalhandle->nl_cb) {
nl_cb_put(globalhandle->nl_cb);
}
capwap_list_free(globalhandle->devicelist);
capwap_free(globalhandle);
}
}
/* Driver function */

35
src/binding/wifi/drivers/wifi_nl80211.h Normal file
View File

@ -0,0 +1,35 @@
#ifndef __WIFI_NL80211_HEADER__
#define __WIFI_NL80211_HEADER__
/* Compatibility functions */
#if !defined(HAVE_LIBNL20) && !defined(HAVE_LIBNL30)
#define nl_sock nl_handle
#endif
/* */
typedef int (*nl_valid_cb)(struct nl_msg* msg, void* data);
/* Global handle */
struct nl80211_global_handle {
struct nl_sock* nl;
struct nl_cb* nl_cb;
int nl80211_id;
struct capwap_list* devicelist;
};
/* Device handle */
struct nl80211_device_handle {
struct nl80211_global_handle* globalhandle;
uint32_t phyindex;
char phyname[IFNAMSIZ];
};
/* Physical device info */
struct nl80211_phydevice_item {
uint32_t index;
char name[IFNAMSIZ];
};
#endif /* __WIFI_NL80211_HEADER__ */

16
src/common/capwap_array.c
View File

@ -70,22 +70,28 @@ void capwap_array_resize(struct capwap_array* array, unsigned long count) {
if (array->count == count) {
return;
}
if (count > 0) {
newbuffer = capwap_alloc(array->itemsize * count);
if (!newbuffer) {
capwap_outofmemory();
}
}
if (array->buffer) {
if (newbuffer != NULL) {
memcpy(newbuffer, array->buffer, array->itemsize * min(array->count, count));
int newcount = min(array->count, count);
memcpy(newbuffer, array->buffer, array->itemsize * newcount);
/* Zeroed new items */
if (array->zeroed && (count > newcount)) {
memset(newbuffer + array->itemsize * newcount, 0, array->itemsize * (count - newcount));
}
}
capwap_free(array->buffer);
}
array->buffer = newbuffer;
array->count = count;
}

6
src/common/capwap_array.h
View File

@ -5,6 +5,7 @@ struct capwap_array {
void* buffer;
unsigned short itemsize;
unsigned long count;
int zeroed;
};
struct capwap_array* capwap_array_create(unsigned short itemsize, unsigned long initcount);
@ -13,9 +14,4 @@ void capwap_array_free(struct capwap_array* array);
void* capwap_array_get_item_pointer(struct capwap_array* array, unsigned long pos);
void capwap_array_resize(struct capwap_array* array, unsigned long count);
/* Helper */
#define capwap_array_getitem(x, y, z) *((z*)capwap_array_get_item_pointer((x), (y)))
#define capwap_array_setnewitem(x, y, z) *((z*)capwap_array_get_item_pointer((x), (x)->count)) = (y)
#endif /* __CAPWAP_ARRAY_HEADER__ */

5
src/common/capwap_logging.h
View File

@ -32,6 +32,11 @@ void capwap_logging_printf(int level, const char *format, ...);
#define capwap_logging_error(f, args...) capwap_logging_printf(CAPWAP_LOGGING_ERROR, f, ##args)
#define capwap_logging_warning(f, args...) capwap_logging_printf(CAPWAP_LOGGING_WARNING, f, ##args)
#define capwap_logging_info(f, args...) capwap_logging_printf(CAPWAP_LOGGING_INFO, f, ##args)
#ifdef DISABLE_LOGGING_DEBUG
#define capwap_logging_debug(f, args...)
#else
#define capwap_logging_debug(f, args...) capwap_logging_printf(CAPWAP_LOGGING_DEBUG, f, ##args)
#endif
#endif /* __CAPWAP_LOGGING_HEADER__ */

211
src/wtp/wtp.c
View File

@ -158,6 +158,7 @@ static void wtp_print_usage(void) {
/* Parsing configuration */
static int wtp_parsing_configuration_1_0(config_t* config) {
int i;
int result;
int configInt;
int configIPv4;
int configIPv6;
@ -246,6 +247,29 @@ static int wtp_parsing_configuration_1_0(config_t* config) {
}
}
/* Initialize binding */
switch (g_wtp.binding) {
case CAPWAP_WIRELESS_BINDING_NONE: {
break;
}
case CAPWAP_WIRELESS_BINDING_IEEE80211: {
/* Initialize wifi binding driver */
capwap_logging_info("Initializing wifi binding engine");
if (wifi_init_driver()) {
capwap_logging_fatal("Unable initialize wifi binding engine");
return 0;
}
break;
}
default: {
capwap_logging_fatal("Unable initialize unknown binding engine: %hu", g_wtp.binding);
return 0;
}
}
/* Set tunnelmode of WTP */
if (config_lookup(config, "application.tunnelmode") != NULL) {
g_wtp.mactunnel.mode = 0;
@ -364,6 +388,7 @@ static int wtp_parsing_configuration_1_0(config_t* config) {
for (i = 0; i < count; i++) {
struct wtp_radio* radio;
char radioname[IFNAMSIZ];
char drivername[WIFI_DRIVER_NAME_SIZE];
unsigned char radiotype = 0;
int radiostatus = WTP_RADIO_ENABLED;
@ -372,66 +397,89 @@ static int wtp_parsing_configuration_1_0(config_t* config) {
if (config_setting_lookup_string(configElement, "device", &configString) == CONFIG_TRUE) {
if (*configString && (strlen(configString) < IFNAMSIZ)) {
strcpy(radioname, configString);
if (config_setting_lookup_string(configElement, "type", &configString) == CONFIG_TRUE) {
int length = strlen(configString);
for (i = 0; i < length; i++) {
switch (configString[i]) {
case 'a': {
radiotype |= CAPWAP_RADIO_TYPE_80211A;
break;
}
if (config_setting_lookup_string(configElement, "driver", &configString) == CONFIG_TRUE) {
if (*configString && (strlen(configString) < WIFI_DRIVER_NAME_SIZE)) {
strcpy(drivername, configString);
if (config_setting_lookup_string(configElement, "type", &configString) == CONFIG_TRUE) {
int length = strlen(configString);
case 'b': {
radiotype |= CAPWAP_RADIO_TYPE_80211B;
break;
}
case 'g': {
radiotype |= CAPWAP_RADIO_TYPE_80211G;
break;
}
case 'n': {
radiotype |= CAPWAP_RADIO_TYPE_80211N;
break;
for (i = 0; i < length; i++) {
switch (configString[i]) {
case 'a': {
radiotype |= CAPWAP_RADIO_TYPE_80211A;
break;
}
case 'b': {
radiotype |= CAPWAP_RADIO_TYPE_80211B;
break;
}
case 'g': {
radiotype |= CAPWAP_RADIO_TYPE_80211G;
break;
}
case 'n': {
radiotype |= CAPWAP_RADIO_TYPE_80211N;
break;
}
default: {
capwap_logging_error("Invalid configuration file, unknown application.descriptor.radio.type value");
return 0;
}
}
}
default: {
capwap_logging_error("Invalid configuration file, unknown application.descriptor.radio.type value");
return 0;
}
}
}
if (radiotype != 0) {
int radioid;
if (radiotype != 0) {
if (config_setting_lookup_string(configElement, "status", &configString) == CONFIG_TRUE) {
if (!strcmp(configString, "enabled")) {
radiostatus = WTP_RADIO_ENABLED;
} else if (!strcmp(configString, "disabled")) {
radiostatus = WTP_RADIO_DISABLED;
} else if (!strcmp(configString, "hwfailure")) {
radiostatus = WTP_RADIO_HWFAILURE;
} else if (!strcmp(configString, "swfailure")) {
radiostatus = WTP_RADIO_SWFAILURE;
if (config_setting_lookup_string(configElement, "status", &configString) == CONFIG_TRUE) {
if (!strcmp(configString, "enabled")) {
radiostatus = WTP_RADIO_ENABLED;
} else if (!strcmp(configString, "disabled")) {
radiostatus = WTP_RADIO_DISABLED;
} else if (!strcmp(configString, "hwfailure")) {
radiostatus = WTP_RADIO_HWFAILURE;
} else if (!strcmp(configString, "swfailure")) {
radiostatus = WTP_RADIO_SWFAILURE;
} else {
capwap_logging_error("Invalid configuration file, unknown application.descriptor.radio.type value");
return 0;
}
}
/* Initialize radio device */
radioid = g_wtp.radios->count + 1;
if (radiostatus == WTP_RADIO_ENABLED) {
result = wifi_create_device(radioid, radioname, drivername);
if (result) {
radiostatus = WTP_RADIO_HWFAILURE;
capwap_logging_warning("Unable to register radio device: %s - %s", radioname, drivername);
}
}
/* Create new radio device */
radio = (struct wtp_radio*)capwap_array_get_item_pointer(g_wtp.radios, g_wtp.radios->count);
strcpy(radio->device, radioname);
radio->radioinformation.radioid = radioid;
radio->radioinformation.radiotype = radiotype;
radio->status = radiostatus;
} else {
capwap_logging_error("Invalid configuration file, unknown application.descriptor.radio.type value");
return 0;
}
} else {
capwap_logging_error("Invalid configuration file, element application.descriptor.radio.type not found");
return 0;
}
/* Create new radio device */
radio = (struct wtp_radio*)capwap_array_get_item_pointer(g_wtp.radios, g_wtp.radios->count);
strcpy(radio->device, radioname);
radio->radioinformation.radioid = g_wtp.radios->count;
radio->radioinformation.radiotype = radiotype;
radio->status = radiostatus;
} else {
capwap_logging_error("Invalid configuration file, unknown application.descriptor.radio.type value");
capwap_logging_error("Invalid configuration file, application.descriptor.radio.driver string length exceeded");
return 0;
}
} else {
capwap_logging_error("Invalid configuration file, element application.descriptor.radio.type not found");
capwap_logging_error("Invalid configuration file, element application.descriptor.radio.driver not found");
return 0;
}
} else {
@ -921,54 +969,33 @@ int main(int argc, char** argv) {
result = WTP_ERROR_LOAD_CONFIGURATION;
capwap_logging_fatal("Error to load configuration");
} else if (value > 0) {
/* Initialize binding */
switch (g_wtp.binding) {
case CAPWAP_WIRELESS_BINDING_NONE: {
value = 0;
break;
}
capwap_logging_info("Startup WTP");
case CAPWAP_WIRELESS_BINDING_IEEE80211: {
/* Initialize wifi binding driver */
capwap_logging_info("Initializing wifi binding engine");
value = wifi_init_driver();
break;
}
/* Start WTP */
wtp_dfa_change_state(CAPWAP_START_TO_IDLE_STATE);
/* Complete configuration WTP */
result = wtp_configure();
if (result == CAPWAP_SUCCESSFUL) {
/* Init complete */
wtp_dfa_change_state(CAPWAP_IDLE_STATE);
/* Running WTP */
result = wtp_dfa_execute();
/* Close socket */
capwap_close_sockets(&g_wtp.net);
}
/* */
if (value) {
result = WTP_ERROR_INIT_BINDING;
capwap_logging_fatal("Unable initialize binding engine");
} else {
capwap_logging_info("Startup WTP");
capwap_logging_info("Terminate WTP");
/* Start WTP */
wtp_dfa_change_state(CAPWAP_START_TO_IDLE_STATE);
/* Complete configuration WTP */
result = wtp_configure();
if (result == CAPWAP_SUCCESSFUL) {
/* Init complete */
wtp_dfa_change_state(CAPWAP_IDLE_STATE);
/* Running WTP */
result = wtp_dfa_execute();
/* Close socket */
capwap_close_sockets(&g_wtp.net);
}
capwap_logging_info("Terminate WTP");
/* Free binding */
switch (g_wtp.binding) {
case CAPWAP_WIRELESS_BINDING_IEEE80211: {
/* Free wifi binding driver */
wifi_free_driver();
capwap_logging_info("Free wifi binding engine");
break;
}
/* Free binding */
switch (g_wtp.binding) {
case CAPWAP_WIRELESS_BINDING_IEEE80211: {
/* Free wifi binding driver */
wifi_free_driver();
capwap_logging_info("Free wifi binding engine");
break;
}
}
}