Wrong option for ./configure in README.md

(this has been backported from master)
Instead of haing a pool of unsused BSS Id's and a list of active
BSS's (wlans), use a single array and only mark the BSS Id as used
or unused.

When leaving RUN state, release (stop) all used BSS.

Conflicts:
	src/wtp/wtp.c
	src/wtp/wtp_radio.c

README.md

@@ -6,8 +6,6 @@ This fork is currently focusing on the WTP side only.
 
 ## STATUS
 
-NOTE: The WTP has been ported to libev, the AC has not been adjusted and is therefor broken for the moment.
-
 ### WTP tested and working features:
 
 * 802.11b
@@ -15,7 +13,6 @@ NOTE: The WTP has been ported to libev, the AC has not been adjusted and is ther
 * WMM/WME (mostly)
 * Local MAC
 * single radio, single WLAN mode
-* 802.11n ([draft-ietf-opsawg-capwap-extension-06](https://tools.ietf.org/html/draft-ietf-opsawg-capwap-extension-06))
 
 Only cards with cfg80211 netlink API are supported and only
 ath9k cards (in particular Qualcomm Atheros AR5418) have
@@ -23,6 +20,7 @@ been tested.
 
 ### Planned WTP features:
 
+* 802.11n ([draft-ietf-opsawg-capwap-extension-06](https://tools.ietf.org/html/draft-ietf-opsawg-capwap-extension-06))
 * encryption (WPA2)
 * Hybrid-MAC ([RFC-7494](https://tools.ietf.org/html/rfc7494))
 
@@ -39,21 +37,19 @@ NOTE: To run WTP you must have a wireless card that has Linux driver based on th
 * libconfig-dev
 * libjson0-dev
 * libnl-dev
-* libev-dev
 * libtool
 * libxml2-dev
 * wolfssl 3.8 or newer
 
-
 ### Build
 
 WolfSSL:
 
     ./configure --enable-dtls --enable-ipv6 --enable-aesgcm \
                 --enable-aesccm --enable-aesni --enable-poly1305 \
-                --enable-ecc --enable-ecc25519 --enable-chacha \
+	            --enable-ecc --enable-ecc25519 --enable-chacha \
-                --enable-supportedcurves --enable-dh --enable-psk \
+				--enable-supportedcurves --enable-dh --enable-psk \
-                --disable-des3 --disable-arc4 --prefix=/usr/
+				--disable-des3 --disable-arc4 --prefix=/usr/
     make
     make install
 

build/Makefile_common.am

@@ -100,9 +100,7 @@ capwap_SOURCES = $(top_srcdir)/src/common/capwap.c \
 	$(top_srcdir)/src/common/capwap_element_80211_wtpqos.c \
 	$(top_srcdir)/src/common/capwap_element_80211_wtpradioconf.c \
 	$(top_srcdir)/src/common/capwap_element_80211_wtpradiofailalarm.c \
-	$(top_srcdir)/src/common/capwap_element_80211_wtpradioinformation.c \
+	$(top_srcdir)/src/common/capwap_element_80211_wtpradioinformation.c
-	$(top_srcdir)/src/common/capwap_element_80211n_radioconf.c \
-	$(top_srcdir)/src/common/capwap_element_80211n_station_information.c
 
 if DEBUG_BUILD
 capwap_SOURCES += $(top_srcdir)/src/common/capwap_debug.c

build/wtp/Makefile.am

@@ -23,7 +23,6 @@ bin_PROGRAMS = wtp
 
 AM_CFLAGS = -D_REENTRANT \
 	-D_GNU_SOURCE \
-	-fno-strict-aliasing \
 	${LIBNL_CFLAGS}
 
 if DTLS_ENABLED

conf/wtp.conf

@@ -149,17 +149,6 @@ application: {
 					dscp = 0;		# not used yet
 				};
 			};
-			ieee80211n = {
-				a-msdu = true;
-				a-mpdu = true;
-				require-ht = false;
-				short-gi = true;
-				ht40 = false;
-				max-sup-mcs = 15;
-				max-mand-mcs = 7;
-				tx-antenna = 0;
-				rx-antenna = 0;
-			};
 		}
 	);
 

configure.ac

@@ -19,7 +19,7 @@
 
 AC_PREREQ(2.63)
 
-AC_INIT([SmartCAPWAP], [1.2], [https://github.com/travelping/smartcapwap], [smartcapwap])
+AC_INIT([SmartCAPWAP], [1.1.0], [https://github.com/travelping/smartcapwap], [smartcapwap])
 AC_CONFIG_AUX_DIR([build])
 AC_CONFIG_MACRO_DIR([m4])
 AM_INIT_AUTOMAKE([1.11 -Wall])
@@ -60,8 +60,12 @@ AC_ARG_ENABLE(
 	[enable_logging="yes"]
 )
 
-AC_ARG_ENABLE([ac],
+AC_ARG_ENABLE(
-	[AS_HELP_STRING([--enable-ac], [enable ac support])])
+	[ac],
+	[AS_HELP_STRING([--disable-ac], [disable ac support])],
+	,
+	[enable_ac="yes"]
+)
 
 AC_ARG_ENABLE(
 	[wtp],
@@ -174,7 +178,6 @@ AC_DEFINE_UNQUOTED([LIBCONFIG_LOOKUP_INT_ARG], [$LIBCONFIG_LOOKUP_INT_ARG], [con
 # Check PTHREAD library
 AC_CHECK_HEADER([pthread.h], [], [AC_MSG_ERROR(You need the pthread headers)])
 AC_CHECK_LIB([pthread], [pthread_create], [PTHREAD_LIBS="-lpthread"], [AC_MSG_ERROR(You need the pthread library)])
-AC_CHECK_LIB([ev], [ev_run],, [AC_MSG_ERROR(Required library ev missing)])
 
 # Check SSL library
 PKG_CHECK_MODULES([WOLFSSL], [wolfssl >= 3.8.0], [have_wolfssl_ssl="yes"], [have_wolfssl_ssl="no"])
@@ -184,10 +187,15 @@ if test "${enable_ac}" = "yes"; then
 	test "x${have_wolfssl_ssl}" != "xyes" && AC_MSG_ERROR(You need the wolfssl library)
 
 	PKG_CHECK_MODULES(
-		[LIBJSON],
+		[LIBJSON], 
-		[json-c >= 0.11],
+		[json-c >= 0.11], 
-		[],
+		[], 
-		[AC_MSG_ERROR(You need the libjson)]
+		[PKG_CHECK_MODULES(
+			[LIBJSON],
+			[json >= 0.9],
+			[],
+			[AC_MSG_ERROR(You need the libjson)]
+		)]
 	)
 
 	# Check XML2 library

src/ac/ac.c

@@ -214,22 +214,22 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 	/* Logging configuration */
 	if (config_lookup_bool(config, "logging.enable", &configBool) == CONFIG_TRUE) {
 		if (!configBool) {
-			capwap_logging_verboselevel(LOG_NONE);
+			capwap_logging_verboselevel(CAPWAP_LOGGING_NONE);
 			capwap_logging_disable_allinterface();
 		} else {
 			if (config_lookup_string(config, "logging.level", &configString) == CONFIG_TRUE) {
 				if (!strcmp(configString, "fatal")) {
-					capwap_logging_verboselevel(LOG_EMERG);
+					capwap_logging_verboselevel(CAPWAP_LOGGING_FATAL);
 				} else if (!strcmp(configString, "error")) {
-					capwap_logging_verboselevel(LOG_ERR);
+					capwap_logging_verboselevel(CAPWAP_LOGGING_ERROR);
 				} else if (!strcmp(configString, "warning")) {
-					capwap_logging_verboselevel(LOG_WARNING);
+					capwap_logging_verboselevel(CAPWAP_LOGGING_WARNING);
 				} else if (!strcmp(configString, "info")) {
-					capwap_logging_verboselevel(LOG_INFO);
+					capwap_logging_verboselevel(CAPWAP_LOGGING_INFO);
 				} else if (!strcmp(configString, "debug")) {
-					capwap_logging_verboselevel(LOG_DEBUG);
+					capwap_logging_verboselevel(CAPWAP_LOGGING_DEBUG);
 				} else {
-					log_printf(LOG_ERR, "Invalid configuration file, unknown logging.level value");
+					capwap_logging_error("Invalid configuration file, unknown logging.level value");
 					return 0;
 				}
 			}
@@ -251,7 +251,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 						} else if (!strcmp(configString, "stderr")) {
 							capwap_logging_enable_console(1);
 						} else {
-							log_printf(LOG_ERR, "Invalid configuration file, unknown logging.output value");
+							capwap_logging_error("Invalid configuration file, unknown logging.output value");
 							return 0;
 						}
 					}
@@ -268,7 +268,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 	/* Set name of AC */
 	if (config_lookup_string(config, "application.name", &configString) == CONFIG_TRUE) {
 		if (strlen(configString) > CAPWAP_ACNAME_MAXLENGTH) {
-			log_printf(LOG_ERR, "Invalid configuration file, application.name string length exceeded");
+			capwap_logging_error("Invalid configuration file, application.name string length exceeded");
 			return 0;
 		}
 
@@ -291,7 +291,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 				} else if (!strcmp(bindingName, "EPCGlobal")) {
 					*binding = CAPWAP_WIRELESS_BINDING_EPCGLOBAL;
 				} else {
-					log_printf(LOG_ERR, "Invalid configuration file, unknown application.binding value");
+					capwap_logging_error("Invalid configuration file, unknown application.binding value");
 					return 0;
 				}
 			}
@@ -303,7 +303,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 		if ((configInt > 0) && (configInt < 65536)) {
 			g_ac.descriptor.stationlimit = (unsigned short)configInt;
 		} else {
-			log_printf(LOG_ERR, "Invalid configuration file, unknown application.descriptor.maxstations value");
+			capwap_logging_error("Invalid configuration file, unknown application.descriptor.maxstations value");
 			return 0;
 		}
 	}
@@ -313,7 +313,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 		if ((configInt > 0) && (configInt < 65536)) {
 			g_ac.descriptor.maxwtp = (unsigned short)configInt;
 		} else {
-			log_printf(LOG_ERR, "Invalid configuration file, unknown application.descriptor.maxwtp value");
+			capwap_logging_error("Invalid configuration file, unknown application.descriptor.maxwtp value");
 			return 0;
 		}
 	}
@@ -379,7 +379,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 								} else if (!strcmp(configType, "software")) {
 									type = CAPWAP_ACDESC_SUBELEMENT_SOFTWAREVERSION;
 								} else {
-									log_printf(LOG_ERR, "Invalid configuration file, unknown application.descriptor.info.type value");
+									capwap_logging_error("Invalid configuration file, unknown application.descriptor.info.type value");
 									return 0;
 								}
 
@@ -392,19 +392,19 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 								strcpy((char*)desc->data, configValue);
 								desc->data[desc->length] = 0;
 							} else {
-								log_printf(LOG_ERR, "Invalid configuration file, application.descriptor.info.value string length exceeded");
+								capwap_logging_error("Invalid configuration file, application.descriptor.info.value string length exceeded");
 								return 0;
 							}
 						} else {
-							log_printf(LOG_ERR, "Invalid configuration file, element application.descriptor.info.value not found");
+							capwap_logging_error("Invalid configuration file, element application.descriptor.info.value not found");
 							return 0;
 						}
 					} else {
-						log_printf(LOG_ERR, "Invalid configuration file, element application.descriptor.info.type not found");
+						capwap_logging_error("Invalid configuration file, element application.descriptor.info.type not found");
 						return 0;
 					}
 				} else {
-					log_printf(LOG_ERR, "Invalid configuration file, element application.descriptor.info.idvendor not found");
+					capwap_logging_error("Invalid configuration file, element application.descriptor.info.idvendor not found");
 					return 0;
 				}
 			}
@@ -418,7 +418,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 		} else if (!strcmp(configString, "limited")) {
 			g_ac.dfa.ecn.flag = CAPWAP_LIMITED_ECN_SUPPORT;
 		} else {
-			log_printf(LOG_ERR, "Invalid configuration file, unknown application.ecn value");
+			capwap_logging_error("Invalid configuration file, unknown application.ecn value");
 			return 0;
 		}
 	}
@@ -429,7 +429,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 		if ((configInt >= AC_MIN_DISCOVERY_INTERVAL) && (configInt <= AC_MAX_DISCOVERY_INTERVAL)) {
 			g_ac.dfa.timers.discovery = (unsigned char)(configInt / 1000);
 		} else {
-			log_printf(LOG_ERR, "Invalid configuration file, invalid application.timer.discovery value");
+			capwap_logging_error("Invalid configuration file, invalid application.timer.discovery value");
 			return 0;
 		}
 	}
@@ -439,7 +439,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 		if ((configInt >= AC_MIN_ECHO_INTERVAL) && (configInt <= AC_MAX_ECHO_INTERVAL)) {
 			g_ac.dfa.timers.echorequest = (unsigned char)(configInt / 1000);
 		} else {
-			log_printf(LOG_ERR, "Invalid configuration file, invalid application.timer.echorequest value");
+			capwap_logging_error("Invalid configuration file, invalid application.timer.echorequest value");
 			return 0;
 		}
 	}
@@ -448,7 +448,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 		if ((configInt > 0) && (configInt < 65536)) {
 			g_ac.dfa.decrypterrorreport_interval = (unsigned short)configInt;
 		} else {
-			log_printf(LOG_ERR, "Invalid configuration file, invalid application.timer.decrypterrorreport value");
+			capwap_logging_error("Invalid configuration file, invalid application.timer.decrypterrorreport value");
 			return 0;
 		}
 	}
@@ -457,7 +457,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 		if (configInt > 0) {
 			g_ac.dfa.idletimeout.timeout = (unsigned long)configInt;
 		} else {
-			log_printf(LOG_ERR, "Invalid configuration file, invalid application.timer.idletimeout value");
+			capwap_logging_error("Invalid configuration file, invalid application.timer.idletimeout value");
 			return 0;
 		}
 	}
@@ -483,7 +483,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 				} else if (!strcmp(configString, "presharedkey")) {
 					dtlsparam.mode = CAPWAP_DTLS_MODE_PRESHAREDKEY;
 				} else {
-					log_printf(LOG_ERR, "Invalid configuration file, unknown application.dtls.type value");
+					capwap_logging_error("Invalid configuration file, unknown application.dtls.type value");
 					return 0;
 				}
 			}
@@ -576,7 +576,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 	/* Set interface binding of AC */
 	if (config_lookup_string(config, "application.network.binding", &configString) == CONFIG_TRUE) {
 		if (strlen(configString) > (IFNAMSIZ - 1)) {
-			log_printf(LOG_ERR, "Invalid configuration file, application.network.binding string length exceeded");
+			capwap_logging_error("Invalid configuration file, application.network.binding string length exceeded");
 			return 0;
 		}			
 			
@@ -588,7 +588,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 		if ((configInt > 0) && (configInt < 65536)) {
 			g_ac.mtu = (unsigned short)configInt;
 		} else {
-			log_printf(LOG_ERR, "Invalid configuration file, invalid application.network.mtu value");
+			capwap_logging_error("Invalid configuration file, invalid application.network.mtu value");
 			return 0;
 		}
 	}
@@ -600,7 +600,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 		} else if (!strcmp(configString, "udplite")) {
 			g_ac.dfa.transport.type = CAPWAP_UDPLITE_TRANSPORT;
 		} else {
-			log_printf(LOG_ERR, "Invalid configuration file, unknown application.network.transport value");
+			capwap_logging_error("Invalid configuration file, unknown application.network.transport value");
 			return 0;
 		}
 	}
@@ -633,7 +633,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 					/* */
 					server = ac_soapclient_create_server(configString);
 					if (!server) {
-						log_printf(LOG_ERR, "Invalid configuration file, invalid backend.server value");
+						capwap_logging_error("Invalid configuration file, invalid backend.server value");
 						return 0;
 					}
 
@@ -647,7 +647,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 						/* */
 						configSSL = config_setting_get_member(configServer, "x509");
 						if (!configSSL) {
-							log_printf(LOG_ERR, "Invalid configuration file, invalid backend.server.x509 value");
+							capwap_logging_error("Invalid configuration file, invalid backend.server.x509 value");
 							return 0;
 						}
 
@@ -673,11 +673,11 @@ static int ac_parsing_configuration_1_0(config_t* config) {
 						if (calist && certificate && privatekey) {
 							server->sslcontext = capwap_socket_crypto_createcontext(calist, certificate, privatekey);
 							if (!server->sslcontext) {
-								log_printf(LOG_ERR, "Invalid configuration file, unable to initialize crypto library");
+								capwap_logging_error("Invalid configuration file, unable to initialize crypto library");
 								return 0;
 							}
 						} else {
-							log_printf(LOG_ERR, "Invalid configuration file, invalid backend.server.x509 value");
+							capwap_logging_error("Invalid configuration file, invalid backend.server.x509 value");
 							return 0;
 						}
 
@@ -707,9 +707,9 @@ static int ac_parsing_configuration(config_t* config) {
 			return ac_parsing_configuration_1_0(config);
 		}
 		
-		log_printf(LOG_ERR, "Invalid configuration file, '%s' is not supported", configString);
+		capwap_logging_error("Invalid configuration file, '%s' is not supported", configString);
 	} else {
-		log_printf(LOG_ERR, "Invalid configuration file, unable to found version tag");
+		capwap_logging_error("Invalid configuration file, unable to found version tag");
 	}
 
 	return 0;
@@ -738,7 +738,7 @@ static int ac_load_configuration(int argc, char** argv) {
 				if (strlen(optarg) < sizeof(g_configurationfile)) {
 					strcpy(g_configurationfile, optarg);
 				} else {
-					log_printf(LOG_ERR, "Invalid -%c argument", optopt);
+					capwap_logging_error("Invalid -%c argument", optopt);
 					return -1;
 				}
 				
@@ -747,9 +747,9 @@ static int ac_load_configuration(int argc, char** argv) {
 				
 			case '?': {
 				if (optopt == 'c') {
-					log_printf(LOG_ERR, "Option -%c requires an argument", optopt);
+					capwap_logging_error("Option -%c requires an argument", optopt);
 				} else {
-					log_printf(LOG_ERR, "Unknown option character `\\x%x'", optopt);
+					capwap_logging_error("Unknown option character `\\x%x'", optopt);
 				}
 				
 				ac_print_usage();
@@ -766,7 +766,7 @@ static int ac_load_configuration(int argc, char** argv) {
 		result = ac_parsing_configuration(&config);
 	} else {
 		result = -1;
-		log_printf(LOG_ERR, "Unable load the configuration file '%s': %s (%d)", g_configurationfile, config_error_text(&config), config_error_line(&config));
+		capwap_logging_error("Unable load the configuration file '%s': %s (%d)", g_configurationfile, config_error_text(&config), config_error_line(&config));
 	}
 
 	/* Free libconfig */
@@ -778,7 +778,7 @@ static int ac_load_configuration(int argc, char** argv) {
 static int ac_configure(void) {
 	/* Bind control channel to any address */
 	if (capwap_bind_sockets(&g_ac.net)) {
-		log_printf(LOG_EMERG, "Cannot bind address");
+		capwap_logging_fatal("Cannot bind address");
 		return AC_ERROR_NETWORK;
 	}
 
@@ -821,7 +821,7 @@ int main(int argc, char** argv) {
 
 	/* Init capwap */
 	if (geteuid() != 0) {
-		log_printf(LOG_EMERG, "Request root privileges");
+		capwap_logging_fatal("Request root privileges");
 		return CAPWAP_REQUEST_ROOT;
 	}
 	
@@ -830,7 +830,7 @@ int main(int argc, char** argv) {
 
 	/* Init crypt */
 	if (capwap_crypt_init()) {
-		log_printf(LOG_EMERG, "Error to init crypt engine");
+		capwap_logging_fatal("Error to init crypt engine");
 		return CAPWAP_CRYPT_ERROR;
 	}
 
@@ -852,7 +852,7 @@ int main(int argc, char** argv) {
 
 			/* Console logging is disabled in daemon mode */
 			capwap_logging_disable_console();
-			log_printf(LOG_INFO, "Running AC in daemon mode");
+			capwap_logging_info("Running AC in daemon mode");
 		}
 
 		/* Complete configuration AC */
@@ -862,18 +862,18 @@ int main(int argc, char** argv) {
 			if (!ac_kmod_init()) {
 				/* Bind data channel */
 				if (!ac_kmod_createdatachannel(g_ac.net.localaddr.ss.ss_family, CAPWAP_GET_NETWORK_PORT(&g_ac.net.localaddr) + 1)) {
-					log_printf(LOG_INFO, "SmartCAPWAP kernel module connected");
+					capwap_logging_info("SmartCAPWAP kernel module connected");
 
 					/* Running AC */
 					result = ac_execute();
 				} else {
-					log_printf(LOG_EMERG, "Unable to create kernel data channel");
+					capwap_logging_fatal("Unable to create kernel data channel");
 				}
 
 				/* Disconnect kernel module */
 				ac_kmod_free();
 			} else {
-				log_printf(LOG_EMERG, "Unable to connect to kernel module");
+				capwap_logging_fatal("Unable to connect to kernel module");
 			}
 
 			/* Close connection */

src/ac/ac.h

@@ -14,7 +14,7 @@
 
 #include <pthread.h>
 #include <linux/if_ether.h>
-#include <json-c/json.h>
+#include <json/json.h>
 
 #include <ac_kmod.h>
 

src/ac/ac_80211_json.c

@@ -31,29 +31,26 @@ static struct ac_json_ieee80211_ops* ac_json_80211_message_elements[] = {
 };
 
 /* */
-static struct ac_json_ieee80211_ops *
+static struct ac_json_ieee80211_ops* ac_json_80211_getops_by_capwaptype(uint16_t type) {
-ac_json_80211_getops_by_capwaptype(const struct capwap_message_element_id type)
-{
 	int i;
 
 	for (i = 0; i < CAPWAP_80211_MESSAGE_ELEMENTS_COUNT; i++) {
-		if (ac_json_80211_message_elements[i] &&
+		if (ac_json_80211_message_elements[i] && (ac_json_80211_message_elements[i]->type == type)) {
-		    memcmp(&ac_json_80211_message_elements[i]->type, &type, sizeof(type)) == 0)
 			return ac_json_80211_message_elements[i];
+		}
 	}
 
 	return NULL;
 }
 
 /* */
-static struct ac_json_ieee80211_ops* ac_json_80211_getops_by_jsontype(char* type)
+static struct ac_json_ieee80211_ops* ac_json_80211_getops_by_jsontype(char* type) {
-{
 	int i;
 
 	for (i = 0; i < CAPWAP_80211_MESSAGE_ELEMENTS_COUNT; i++) {
-		if (ac_json_80211_message_elements[i] &&
+		if (ac_json_80211_message_elements[i] && !strcmp(ac_json_80211_message_elements[i]->json_type, type)) {
-		    strcmp(ac_json_80211_message_elements[i]->json_type, type) == 0)
 			return ac_json_80211_message_elements[i];
+		}
 	}
 
 	return NULL;
@@ -77,113 +74,111 @@ void ac_json_ieee80211_free(struct ac_json_ieee80211_wtpradio* wtpradio) {
 
 		if (item->valid) {
 			if (item->addwlan) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_ADD_WLAN)->free(item->addwlan);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_ADD_WLAN)->free_message_element(item->addwlan);
 			}
 
 			if (item->antenna) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_ANTENNA)->free(item->antenna);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_ANTENNA)->free_message_element(item->antenna);
 			}
 
 			if (item->assignbssid) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_ASSIGN_BSSID)->free(item->assignbssid);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_ASSIGN_BSSID)->free_message_element(item->assignbssid);
 			}
 
 			if (item->deletewlan) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_DELETE_WLAN)->free(item->deletewlan);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_DELETE_WLAN)->free_message_element(item->deletewlan);
 			}
 
 			if (item->directsequencecontrol) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL)->free(item->directsequencecontrol);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL)->free_message_element(item->directsequencecontrol);
 			}
 
 			if (item->iearray) {
-				const struct capwap_message_elements_ops* ieops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_IE);
+				struct capwap_message_elements_ops* ieops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_IE);
 
 				for (j = 0; j < item->iearray->count; j++) {
-					ieops->free(*(struct capwap_80211_ie_element**)capwap_array_get_item_pointer(item->iearray, j));
+					ieops->free_message_element(*(struct capwap_80211_ie_element**)capwap_array_get_item_pointer(item->iearray, j));
 				}
 
 				capwap_array_free(item->iearray);
 			}
 
 			if (item->macoperation) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_MACOPERATION)->free(item->macoperation);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_MACOPERATION)->free_message_element(item->macoperation);
 			}
 
 			if (item->miccountermeasures) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES)->free(item->miccountermeasures);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES)->free_message_element(item->miccountermeasures);
 			}
 
 			if (item->multidomaincapability) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY)->free(item->multidomaincapability);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY)->free_message_element(item->multidomaincapability);
 			}
 
 			if (item->ofdmcontrol) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_OFDMCONTROL)->free(item->ofdmcontrol);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_OFDMCONTROL)->free_message_element(item->ofdmcontrol);
 			}
 
 			if (item->rateset) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_RATESET)->free(item->rateset);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_RATESET)->free_message_element(item->rateset);
 			}
 
 			if (item->rsnaerrorreport) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT)->free(item->rsnaerrorreport);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT)->free_message_element(item->rsnaerrorreport);
 			}
 
 			if (item->statistics) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_STATISTICS)->free(item->statistics);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_STATISTICS)->free_message_element(item->statistics);
 			}
 
 			if (item->supportedrates) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_SUPPORTEDRATES)->free(item->supportedrates);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_SUPPORTEDRATES)->free_message_element(item->supportedrates);
 			}
 
 			if (item->txpower) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_TXPOWER)->free(item->txpower);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_TXPOWER)->free_message_element(item->txpower);
 			}
 
 			if (item->txpowerlevel) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_TXPOWERLEVEL)->free(item->txpowerlevel);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_TXPOWERLEVEL)->free_message_element(item->txpowerlevel);
 			}
 
 			if (item->updatewlan) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_UPDATE_WLAN)->free(item->updatewlan);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_UPDATE_WLAN)->free_message_element(item->updatewlan);
 			}
 
 			if (item->wtpqos) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTP_QOS)->free(item->wtpqos);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTP_QOS)->free_message_element(item->wtpqos);
 			}
 
 			if (item->wtpradioconf) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTP_RADIO_CONF)->free(item->wtpradioconf);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTP_RADIO_CONF)->free_message_element(item->wtpradioconf);
 			}
 
 			if (item->wtpradiofailalarm) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM)->free(item->wtpradiofailalarm);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM)->free_message_element(item->wtpradiofailalarm);
 			}
 
 			if (item->wtpradioinformation) {
-				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION)->free(item->wtpradioinformation);
+				capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION)->free_message_element(item->wtpradioinformation);
 			}
 		}
 	}
 }
 
 /* */
-int ac_json_ieee80211_addmessageelement(struct ac_json_ieee80211_wtpradio *wtpradio,
+int ac_json_ieee80211_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, uint16_t type, void* data, int overwrite) {
-					const struct capwap_message_element_id id,
-					void *data, int overwrite)
-{
 	struct ac_json_ieee80211_ops* ops;
 
 	ASSERT(wtpradio != NULL);
-	ASSERT(IS_80211_MESSAGE_ELEMENTS(id));
+	ASSERT(IS_80211_MESSAGE_ELEMENTS(type));
 	ASSERT(data != NULL);
 
 	/* */
- 	ops = ac_json_80211_getops_by_capwaptype(id);
+ 	ops = ac_json_80211_getops_by_capwaptype(type);
- 	if (!ops)
+ 	if (!ops) {
  		return 0;
+ 	}
 
 	return ops->add_message_element(wtpradio, data, overwrite);
 }
@@ -194,27 +189,21 @@ int ac_json_ieee80211_parsingmessageelement(struct ac_json_ieee80211_wtpradio* w
 
 	ASSERT(wtpradio != NULL);
 	ASSERT(messageelement != NULL);
-	ASSERT(IS_80211_MESSAGE_ELEMENTS(messageelement->id));
+	ASSERT(IS_80211_MESSAGE_ELEMENTS(messageelement->type));
 
-	switch (messageelement->category) {
+	if (messageelement->category == CAPWAP_MESSAGE_ELEMENT_SINGLE) {
-	case CAPWAP_MESSAGE_ELEMENT_SINGLE:
+		if (!ac_json_ieee80211_addmessageelement(wtpradio, messageelement->type, messageelement->data, 0)) {
-		if (!ac_json_ieee80211_addmessageelement(wtpradio, messageelement->id,
-							 messageelement->data, 0))
 			return 0;
-		break;
+		}
+	} else if (messageelement->category == CAPWAP_MESSAGE_ELEMENT_ARRAY) {
+		struct capwap_array* items = (struct capwap_array*)messageelement->data;
 
-	case CAPWAP_MESSAGE_ELEMENT_ARRAY: {
+		for (i = 0; i < items->count; i++) {
-		struct capwap_array* items =
+			if (!ac_json_ieee80211_addmessageelement(wtpradio, messageelement->type, *(void**)capwap_array_get_item_pointer(items, i), 0)) {
-			(struct capwap_array*)messageelement->data;
-
-		for (i = 0; i < items->count; i++)
-			if (!ac_json_ieee80211_addmessageelement(wtpradio, messageelement->id,
-								 *(void**)capwap_array_get_item_pointer(items, i), 0))
 				return 0;
-		break;
+			}
-	}
+		}
-
+	} else {
-	default:
 		return 0;
 	}
 
@@ -250,13 +239,13 @@ int ac_json_ieee80211_parsingjson(struct ac_json_ieee80211_wtpradio* wtpradio, s
 				for(entry = json_object_get_object(jsonradio)->head; entry != NULL; entry = entry->next) {
 					struct ac_json_ieee80211_ops* ops = ac_json_80211_getops_by_jsontype((char*)entry->k);		/* Retrieve JSON handler */
 					if (ops) {
-						void* data = ops->create((struct json_object*)entry->v, radioid);
+						void* data = ops->create_message_element((struct json_object*)entry->v, radioid);
 						if (data) {
 							/* Message element complete */
 							ac_json_ieee80211_addmessageelement(wtpradio, ops->type, data, 1);
 
 							/* Free resource */
-							capwap_get_message_element_ops(ops->type)->free(data);
+							capwap_get_message_element_ops(ops->type)->free_message_element(data);
 						}
 					}
 				}

src/ac/ac_80211_json_addwlan.c

@@ -10,18 +10,18 @@ static void* ac_json_80211_addwlan_createmessageelement(struct json_object* json
 static int ac_json_80211_addwlan_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_addwlan_element* addwlan = (struct capwap_80211_addwlan_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[addwlan->radioid - 1];
-	const struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_ADD_WLAN);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_ADD_WLAN);
 
 	if (item->addwlan) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->addwlan);
+		ops->free_message_element(item->addwlan);
 	}
 
 	item->valid = 1;
-	item->addwlan = (struct capwap_80211_addwlan_element*)ops->clone(addwlan);
+	item->addwlan = (struct capwap_80211_addwlan_element*)ops->clone_message_element(addwlan);
 
 	return 1;
 }
@@ -35,7 +35,7 @@ static void ac_json_80211_addwlan_createjson(struct json_object* jsonparent, voi
 struct ac_json_ieee80211_ops ac_json_80211_addwlan_ops = {
 	.type = CAPWAP_ELEMENT_80211_ADD_WLAN,
 	.json_type = "IEEE80211AddWLAN",
-	.create = ac_json_80211_addwlan_createmessageelement,
+	.create_message_element = ac_json_80211_addwlan_createmessageelement,
 	.add_message_element = ac_json_80211_addwlan_addmessageelement,
 	.create_json = ac_json_80211_addwlan_createjson
 };

src/ac/ac_80211_json_antenna.c

@@ -64,18 +64,18 @@ static void* ac_json_80211_antenna_createmessageelement(struct json_object* json
 static int ac_json_80211_antenna_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_antenna_element* antenna = (struct capwap_80211_antenna_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[antenna->radioid - 1];
-	const struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_ANTENNA);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_ANTENNA);
 
 	if (item->antenna) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->antenna);
+		ops->free_message_element(item->antenna);
 	}
 
 	item->valid = 1;
-	item->antenna = (struct capwap_80211_antenna_element*)ops->clone(antenna);
+	item->antenna = (struct capwap_80211_antenna_element*)ops->clone_message_element(antenna);
 
 	return 1;
 }
@@ -103,7 +103,7 @@ static void ac_json_80211_antenna_createjson(struct json_object* jsonparent, voi
 struct ac_json_ieee80211_ops ac_json_80211_antenna_ops = {
 	.type = CAPWAP_ELEMENT_80211_ANTENNA,
 	.json_type = "IEEE80211Antenna",
-	.create = ac_json_80211_antenna_createmessageelement,
+	.create_message_element = ac_json_80211_antenna_createmessageelement,
 	.add_message_element = ac_json_80211_antenna_addmessageelement,
 	.create_json = ac_json_80211_antenna_createjson
 };

src/ac/ac_80211_json_assignbssid.c

@@ -10,18 +10,18 @@ static void* ac_json_80211_assignbssid_createmessageelement(struct json_object*
 static int ac_json_80211_assignbssid_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_assignbssid_element* assignbssid = (struct capwap_80211_assignbssid_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[assignbssid->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_ASSIGN_BSSID);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_ASSIGN_BSSID);
 
 	if (item->assignbssid) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->assignbssid);
+		ops->free_message_element(item->assignbssid);
 	}
 
 	item->valid = 1;
-	item->assignbssid = (struct capwap_80211_assignbssid_element*)ops->clone(assignbssid);
+	item->assignbssid = (struct capwap_80211_assignbssid_element*)ops->clone_message_element(assignbssid);
 
 	return 1;
 }
@@ -35,7 +35,7 @@ static void ac_json_80211_assignbssid_createjson(struct json_object* jsonparent,
 struct ac_json_ieee80211_ops ac_json_80211_assignbssid_ops = {
 	.type = CAPWAP_ELEMENT_80211_ASSIGN_BSSID,
 	.json_type = "IEEE80211AssignBSSID",
-	.create = ac_json_80211_assignbssid_createmessageelement,
+	.create_message_element = ac_json_80211_assignbssid_createmessageelement,
 	.add_message_element = ac_json_80211_assignbssid_addmessageelement,
 	.create_json = ac_json_80211_assignbssid_createjson
 };

src/ac/ac_80211_json_deletewlan.c

@@ -10,18 +10,18 @@ static void* ac_json_80211_deletewlan_createmessageelement(struct json_object* j
 static int ac_json_80211_deletewlan_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_deletewlan_element* deletewlan = (struct capwap_80211_deletewlan_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[deletewlan->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_DELETE_WLAN);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_DELETE_WLAN);
 
 	if (item->deletewlan) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->deletewlan);
+		ops->free_message_element(item->deletewlan);
 	}
 
 	item->valid = 1;
-	item->deletewlan = (struct capwap_80211_deletewlan_element*)ops->clone(deletewlan);
+	item->deletewlan = (struct capwap_80211_deletewlan_element*)ops->clone_message_element(deletewlan);
 
 	return 1;
 }
@@ -35,7 +35,7 @@ static void ac_json_80211_deletewlan_createjson(struct json_object* jsonparent,
 struct ac_json_ieee80211_ops ac_json_80211_deletewlan_ops = {
 	.type = CAPWAP_ELEMENT_80211_DELETE_WLAN,
 	.json_type = "IEEE80211DeleteWLAN",
-	.create = ac_json_80211_deletewlan_createmessageelement,
+	.create_message_element = ac_json_80211_deletewlan_createmessageelement,
 	.add_message_element = ac_json_80211_deletewlan_addmessageelement,
 	.create_json = ac_json_80211_deletewlan_createjson
 };

src/ac/ac_80211_json_directsequencecontrol.c

@@ -50,18 +50,18 @@ static void* ac_json_80211_directsequencecontrol_createmessageelement(struct jso
 static int ac_json_80211_directsequencecontrol_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_directsequencecontrol_element* directsequencecontrol = (struct capwap_80211_directsequencecontrol_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[directsequencecontrol->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL);
 
 	if (item->directsequencecontrol) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->directsequencecontrol);
+		ops->free_message_element(item->directsequencecontrol);
 	}
 
 	item->valid = 1;
-	item->directsequencecontrol = (struct capwap_80211_directsequencecontrol_element*)ops->clone(directsequencecontrol);
+	item->directsequencecontrol = (struct capwap_80211_directsequencecontrol_element*)ops->clone_message_element(directsequencecontrol);
 
 	return 1;
 }
@@ -82,7 +82,7 @@ static void ac_json_80211_directsequencecontrol_createjson(struct json_object* j
 struct ac_json_ieee80211_ops ac_json_80211_directsequencecontrol_ops = {
 	.type = CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL,
 	.json_type = "IEEE80211DirectSequenceControl",
-	.create = ac_json_80211_directsequencecontrol_createmessageelement,
+	.create_message_element = ac_json_80211_directsequencecontrol_createmessageelement,
 	.add_message_element = ac_json_80211_directsequencecontrol_addmessageelement,
 	.create_json = ac_json_80211_directsequencecontrol_createjson
 };

src/ac/ac_80211_json_ie.c

@@ -11,7 +11,7 @@ static int ac_json_80211_ie_addmessageelement(struct ac_json_ieee80211_wtpradio*
 	struct capwap_80211_ie_element** ieclone;
 	struct capwap_80211_ie_element* ie = (struct capwap_80211_ie_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[ie->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_IE);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_IE);
 
 	if (!item->iearray) {
 		item->iearray = capwap_array_create(sizeof(struct capwap_80211_ie_element*), 0, 0);
@@ -19,7 +19,7 @@ static int ac_json_80211_ie_addmessageelement(struct ac_json_ieee80211_wtpradio*
 
 	item->valid = 1;
 	ieclone = (struct capwap_80211_ie_element**)capwap_array_get_item_pointer(item->iearray, item->iearray->count);
-	*ieclone = (struct capwap_80211_ie_element*)ops->clone(ie);
+	*ieclone = (struct capwap_80211_ie_element*)ops->clone_message_element(ie);
 
 	return 1;
 }
@@ -33,7 +33,7 @@ static void ac_json_80211_ie_createjson(struct json_object* jsonparent, void* da
 struct ac_json_ieee80211_ops ac_json_80211_ie_ops = {
 	.type = CAPWAP_ELEMENT_80211_IE,
 	.json_type = "IEEE80211IE",
-	.create = ac_json_80211_ie_createmessageelement,
+	.create_message_element = ac_json_80211_ie_createmessageelement,
 	.add_message_element = ac_json_80211_ie_addmessageelement,
 	.create_json = ac_json_80211_ie_createjson
 };

src/ac/ac_80211_json_macoperation.c

@@ -77,18 +77,18 @@ static void* ac_json_80211_macoperation_createmessageelement(struct json_object*
 static int ac_json_80211_macoperation_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_macoperation_element* macoperation = (struct capwap_80211_macoperation_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[macoperation->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_MACOPERATION);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_MACOPERATION);
 
 	if (item->macoperation) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->macoperation);
+		ops->free_message_element(item->macoperation);
 	}
 
 	item->valid = 1;
-	item->macoperation = (struct capwap_80211_macoperation_element*)ops->clone(macoperation);
+	item->macoperation = (struct capwap_80211_macoperation_element*)ops->clone_message_element(macoperation);
 
 	return 1;
 }
@@ -112,7 +112,7 @@ static void ac_json_80211_macoperation_createjson(struct json_object* jsonparent
 struct ac_json_ieee80211_ops ac_json_80211_macoperation_ops = {
 	.type = CAPWAP_ELEMENT_80211_MACOPERATION,
 	.json_type = "IEEE80211MACOperation",
-	.create = ac_json_80211_macoperation_createmessageelement,
+	.create_message_element = ac_json_80211_macoperation_createmessageelement,
 	.add_message_element = ac_json_80211_macoperation_addmessageelement,
 	.create_json = ac_json_80211_macoperation_createjson
 };

src/ac/ac_80211_json_miccountermeasures.c

@@ -10,18 +10,18 @@ static void* ac_json_80211_miccountermeasures_createmessageelement(struct json_o
 static int ac_json_80211_miccountermeasures_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_miccountermeasures_element* miccountermeasures = (struct capwap_80211_miccountermeasures_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[miccountermeasures->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES);
 
 	if (item->miccountermeasures) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->miccountermeasures);
+		ops->free_message_element(item->miccountermeasures);
 	}
 
 	item->valid = 1;
-	item->miccountermeasures = (struct capwap_80211_miccountermeasures_element*)ops->clone(miccountermeasures);
+	item->miccountermeasures = (struct capwap_80211_miccountermeasures_element*)ops->clone_message_element(miccountermeasures);
 
 	return 1;
 }
@@ -35,7 +35,7 @@ static void ac_json_80211_miccountermeasures_createjson(struct json_object* json
 struct ac_json_ieee80211_ops ac_json_80211_miccountermeasures_ops = {
 	.type = CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES,
 	.json_type = "IEEE80211MicCounterMeasures",
-	.create = ac_json_80211_miccountermeasures_createmessageelement,
+	.create_message_element = ac_json_80211_miccountermeasures_createmessageelement,
 	.add_message_element = ac_json_80211_miccountermeasures_addmessageelement,
 	.create_json = ac_json_80211_miccountermeasures_createjson
 };

src/ac/ac_80211_json_multidomaincapability.c

@@ -50,18 +50,18 @@ static void* ac_json_80211_multidomaincapability_createmessageelement(struct jso
 static int ac_json_80211_multidomaincapability_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_multidomaincapability_element* multidomaincapability = (struct capwap_80211_multidomaincapability_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[multidomaincapability->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY);
 
 	if (item->multidomaincapability) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->multidomaincapability);
+		ops->free_message_element(item->multidomaincapability);
 	}
 
 	item->valid = 1;
-	item->multidomaincapability = (struct capwap_80211_multidomaincapability_element*)ops->clone(multidomaincapability);
+	item->multidomaincapability = (struct capwap_80211_multidomaincapability_element*)ops->clone_message_element(multidomaincapability);
 
 	return 1;
 }
@@ -82,7 +82,7 @@ static void ac_json_80211_multidomaincapability_createjson(struct json_object* j
 struct ac_json_ieee80211_ops ac_json_80211_multidomaincapability_ops = {
 	.type = CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY,
 	.json_type = "IEEE80211MultiDomainCapability",
-	.create = ac_json_80211_multidomaincapability_createmessageelement,
+	.create_message_element = ac_json_80211_multidomaincapability_createmessageelement,
 	.add_message_element = ac_json_80211_multidomaincapability_addmessageelement,
 	.create_json = ac_json_80211_multidomaincapability_createjson
 };

src/ac/ac_80211_json_ofdmcontrol.c

@@ -50,18 +50,18 @@ static void* ac_json_80211_ofdmcontrol_createmessageelement(struct json_object*
 static int ac_json_80211_ofdmcontrol_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_ofdmcontrol_element* ofdmcontrol = (struct capwap_80211_ofdmcontrol_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[ofdmcontrol->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_OFDMCONTROL);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_OFDMCONTROL);
 
 	if (item->ofdmcontrol) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->ofdmcontrol);
+		ops->free_message_element(item->ofdmcontrol);
 	}
 
 	item->valid = 1;
-	item->ofdmcontrol = (struct capwap_80211_ofdmcontrol_element*)ops->clone(ofdmcontrol);
+	item->ofdmcontrol = (struct capwap_80211_ofdmcontrol_element*)ops->clone_message_element(ofdmcontrol);
 
 	return 1;
 }
@@ -82,7 +82,7 @@ static void ac_json_80211_ofdmcontrol_createjson(struct json_object* jsonparent,
 struct ac_json_ieee80211_ops ac_json_80211_ofdmcontrol_ops = {
 	.type = CAPWAP_ELEMENT_80211_OFDMCONTROL,
 	.json_type = "IEEE80211OFDMControl",
-	.create = ac_json_80211_ofdmcontrol_createmessageelement,
+	.create_message_element = ac_json_80211_ofdmcontrol_createmessageelement,
 	.add_message_element = ac_json_80211_ofdmcontrol_addmessageelement,
 	.create_json = ac_json_80211_ofdmcontrol_createjson
 };

src/ac/ac_80211_json_rateset.c

@@ -41,18 +41,18 @@ static void* ac_json_80211_rateset_createmessageelement(struct json_object* json
 static int ac_json_80211_rateset_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_rateset_element* rateset = (struct capwap_80211_rateset_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[rateset->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_RATESET);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_RATESET);
 
 	if (item->rateset) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->rateset);
+		ops->free_message_element(item->rateset);
 	}
 
 	item->valid = 1;
-	item->rateset = (struct capwap_80211_rateset_element*)ops->clone(rateset);
+	item->rateset = (struct capwap_80211_rateset_element*)ops->clone_message_element(rateset);
 
 	return 1;
 }
@@ -75,7 +75,7 @@ static void ac_json_80211_rateset_createjson(struct json_object* jsonparent, voi
 struct ac_json_ieee80211_ops ac_json_80211_rateset_ops = {
 	.type = CAPWAP_ELEMENT_80211_RATESET,
 	.json_type = "IEEE80211Rateset",
-	.create = ac_json_80211_rateset_createmessageelement,
+	.create_message_element = ac_json_80211_rateset_createmessageelement,
 	.add_message_element = ac_json_80211_rateset_addmessageelement,
 	.create_json = ac_json_80211_rateset_createjson
 };

src/ac/ac_80211_json_rsnaerrorreport.c

@@ -10,18 +10,18 @@ static void* ac_json_80211_rsnaerrorreport_createmessageelement(struct json_obje
 static int ac_json_80211_rsnaerrorreport_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_rsnaerrorreport_element* rsnaerrorreport = (struct capwap_80211_rsnaerrorreport_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[rsnaerrorreport->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT);
 
 	if (item->rsnaerrorreport) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->rsnaerrorreport);
+		ops->free_message_element(item->rsnaerrorreport);
 	}
 
 	item->valid = 1;
-	item->rsnaerrorreport = (struct capwap_80211_rsnaerrorreport_element*)ops->clone(rsnaerrorreport);
+	item->rsnaerrorreport = (struct capwap_80211_rsnaerrorreport_element*)ops->clone_message_element(rsnaerrorreport);
 
 	return 1;
 }
@@ -35,7 +35,7 @@ static void ac_json_80211_rsnaerrorreport_createjson(struct json_object* jsonpar
 struct ac_json_ieee80211_ops ac_json_80211_rsnaerrorreport_ops = {
 	.type = CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT,
 	.json_type = "IEEE80211RSNAErrorReport",
-	.create = ac_json_80211_rsnaerrorreport_createmessageelement,
+	.create_message_element = ac_json_80211_rsnaerrorreport_createmessageelement,
 	.add_message_element = ac_json_80211_rsnaerrorreport_addmessageelement,
 	.create_json = ac_json_80211_rsnaerrorreport_createjson
 };

src/ac/ac_80211_json_statistics.c

@@ -10,18 +10,18 @@ static void* ac_json_80211_statistics_createmessageelement(struct json_object* j
 static int ac_json_80211_statistics_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_statistics_element* statistics = (struct capwap_80211_statistics_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[statistics->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_STATISTICS);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_STATISTICS);
 
 	if (item->statistics) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->statistics);
+		ops->free_message_element(item->statistics);
 	}
 
 	item->valid = 1;
-	item->statistics = (struct capwap_80211_statistics_element*)ops->clone(statistics);
+	item->statistics = (struct capwap_80211_statistics_element*)ops->clone_message_element(statistics);
 
 	return 1;
 }
@@ -35,7 +35,7 @@ static void ac_json_80211_statistics_createjson(struct json_object* jsonparent,
 struct ac_json_ieee80211_ops ac_json_80211_statistics_ops = {
 	.type = CAPWAP_ELEMENT_80211_STATISTICS,
 	.json_type = "IEEE80211Statistics",
-	.create = ac_json_80211_statistics_createmessageelement,
+	.create_message_element = ac_json_80211_statistics_createmessageelement,
 	.add_message_element = ac_json_80211_statistics_addmessageelement,
 	.create_json = ac_json_80211_statistics_createjson
 };

src/ac/ac_80211_json_supportedrates.c

@@ -41,18 +41,18 @@ static void* ac_json_80211_supportedrates_createmessageelement(struct json_objec
 static int ac_json_80211_supportedrates_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_supportedrates_element* supportedrates = (struct capwap_80211_supportedrates_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[supportedrates->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_SUPPORTEDRATES);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_SUPPORTEDRATES);
 
 	if (item->supportedrates) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->supportedrates);
+		ops->free_message_element(item->supportedrates);
 	}
 
 	item->valid = 1;
-	item->supportedrates = (struct capwap_80211_supportedrates_element*)ops->clone(supportedrates);
+	item->supportedrates = (struct capwap_80211_supportedrates_element*)ops->clone_message_element(supportedrates);
 
 	return 1;
 }
@@ -75,7 +75,7 @@ static void ac_json_80211_supportedrates_createjson(struct json_object* jsonpare
 struct ac_json_ieee80211_ops ac_json_80211_supportedrates_ops = {
 	.type = CAPWAP_ELEMENT_80211_SUPPORTEDRATES,
 	.json_type = "IEEE80211SupportedRates",
-	.create = ac_json_80211_supportedrates_createmessageelement,
+	.create_message_element = ac_json_80211_supportedrates_createmessageelement,
 	.add_message_element = ac_json_80211_supportedrates_addmessageelement,
 	.create_json = ac_json_80211_supportedrates_createjson
 };

src/ac/ac_80211_json_txpower.c

@@ -32,18 +32,18 @@ static void* ac_json_80211_txpower_createmessageelement(struct json_object* json
 static int ac_json_80211_txpower_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_txpower_element* txpower = (struct capwap_80211_txpower_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[txpower->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_TXPOWER);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_TXPOWER);
 
 	if (item->txpower) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->txpower);
+		ops->free_message_element(item->txpower);
 	}
 
 	item->valid = 1;
-	item->txpower = (struct capwap_80211_txpower_element*)ops->clone(txpower);
+	item->txpower = (struct capwap_80211_txpower_element*)ops->clone_message_element(txpower);
 
 	return 1;
 }
@@ -62,7 +62,7 @@ static void ac_json_80211_txpower_createjson(struct json_object* jsonparent, voi
 struct ac_json_ieee80211_ops ac_json_80211_txpower_ops = {
 	.type = CAPWAP_ELEMENT_80211_TXPOWER,
 	.json_type = "IEEE80211TxPower",
-	.create = ac_json_80211_txpower_createmessageelement,
+	.create_message_element = ac_json_80211_txpower_createmessageelement,
 	.add_message_element = ac_json_80211_txpower_addmessageelement,
 	.create_json = ac_json_80211_txpower_createjson
 };

src/ac/ac_80211_json_txpowerlevel.c

@@ -41,18 +41,18 @@ static void* ac_json_80211_txpowerlevel_createmessageelement(struct json_object*
 static int ac_json_80211_txpowerlevel_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_txpowerlevel_element* txpowerlevel = (struct capwap_80211_txpowerlevel_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[txpowerlevel->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_TXPOWERLEVEL);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_TXPOWERLEVEL);
 
 	if (item->txpowerlevel) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->txpowerlevel);
+		ops->free_message_element(item->txpowerlevel);
 	}
 
 	item->valid = 1;
-	item->txpowerlevel = (struct capwap_80211_txpowerlevel_element*)ops->clone(txpowerlevel);
+	item->txpowerlevel = (struct capwap_80211_txpowerlevel_element*)ops->clone_message_element(txpowerlevel);
 
 	return 1;
 }
@@ -75,7 +75,7 @@ static void ac_json_80211_txpowerlevel_createjson(struct json_object* jsonparent
 struct ac_json_ieee80211_ops ac_json_80211_txpowerlevel_ops = {
 	.type = CAPWAP_ELEMENT_80211_TXPOWERLEVEL,
 	.json_type = "IEEE80211TXPowerLevel",
-	.create = ac_json_80211_txpowerlevel_createmessageelement,
+	.create_message_element = ac_json_80211_txpowerlevel_createmessageelement,
 	.add_message_element = ac_json_80211_txpowerlevel_addmessageelement,
 	.create_json = ac_json_80211_txpowerlevel_createjson
 };

src/ac/ac_80211_json_updatewlan.c

@@ -10,18 +10,18 @@ static void* ac_json_80211_updatewlan_createmessageelement(struct json_object* j
 static int ac_json_80211_updatewlan_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_updatewlan_element* updatewlan = (struct capwap_80211_updatewlan_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[updatewlan->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_UPDATE_WLAN);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_UPDATE_WLAN);
 
 	if (item->updatewlan) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->updatewlan);
+		ops->free_message_element(item->updatewlan);
 	}
 
 	item->valid = 1;
-	item->updatewlan = (struct capwap_80211_updatewlan_element*)ops->clone(updatewlan);
+	item->updatewlan = (struct capwap_80211_updatewlan_element*)ops->clone_message_element(updatewlan);
 
 	return 1;
 }
@@ -35,7 +35,7 @@ static void ac_json_80211_updatewlan_createjson(struct json_object* jsonparent,
 struct ac_json_ieee80211_ops ac_json_80211_updatewlan_ops = {
 	.type = CAPWAP_ELEMENT_80211_UPDATE_WLAN,
 	.json_type = "IEEE80211UpdateWLAN",
-	.create = ac_json_80211_updatewlan_createmessageelement,
+	.create_message_element = ac_json_80211_updatewlan_createmessageelement,
 	.add_message_element = ac_json_80211_updatewlan_addmessageelement,
 	.create_json = ac_json_80211_updatewlan_createjson
 };

src/ac/ac_80211_json_wtpqos.c

@@ -48,18 +48,18 @@ static void* ac_json_80211_wtpqos_createmessageelement(struct json_object* jsonp
 static int ac_json_80211_wtpqos_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_wtpqos_element* wtpqos = (struct capwap_80211_wtpqos_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[wtpqos->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTP_QOS);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTP_QOS);
 
 	if (item->wtpqos) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->wtpqos);
+		ops->free_message_element(item->wtpqos);
 	}
 
 	item->valid = 1;
-	item->wtpqos = (struct capwap_80211_wtpqos_element*)ops->clone(wtpqos);
+	item->wtpqos = (struct capwap_80211_wtpqos_element*)ops->clone_message_element(wtpqos);
 
 	return 1;
 }
@@ -73,7 +73,7 @@ static void ac_json_80211_wtpqos_createjson(struct json_object* jsonparent, void
 struct ac_json_ieee80211_ops ac_json_80211_wtpqos_ops = {
 	.type = CAPWAP_ELEMENT_80211_WTP_QOS,
 	.json_type = "IEEE80211WTPQoS",
-	.create = ac_json_80211_wtpqos_createmessageelement,
+	.create_message_element = ac_json_80211_wtpqos_createmessageelement,
 	.add_message_element = ac_json_80211_wtpqos_addmessageelement,
 	.create_json = ac_json_80211_wtpqos_createjson
 };

src/ac/ac_80211_json_wtpradioconf.c

@@ -86,18 +86,18 @@ static void* ac_json_80211_wtpradioconf_createmessageelement(struct json_object*
 static int ac_json_80211_wtpradioconf_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_wtpradioconf_element* wtpradioconf = (struct capwap_80211_wtpradioconf_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[wtpradioconf->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTP_RADIO_CONF);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTP_RADIO_CONF);
 
 	if (item->wtpradioconf) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->wtpradioconf);
+		ops->free_message_element(item->wtpradioconf);
 	}
 
 	item->valid = 1;
-	item->wtpradioconf = (struct capwap_80211_wtpradioconf_element*)ops->clone(wtpradioconf);
+	item->wtpradioconf = (struct capwap_80211_wtpradioconf_element*)ops->clone_message_element(wtpradioconf);
 
 	return 1;
 }
@@ -122,7 +122,7 @@ static void ac_json_80211_wtpradioconf_createjson(struct json_object* jsonparent
 struct ac_json_ieee80211_ops ac_json_80211_wtpradioconf_ops = {
 	.type = CAPWAP_ELEMENT_80211_WTP_RADIO_CONF,
 	.json_type = "IEEE80211WTPRadioConfiguration",
-	.create = ac_json_80211_wtpradioconf_createmessageelement,
+	.create_message_element = ac_json_80211_wtpradioconf_createmessageelement,
 	.add_message_element = ac_json_80211_wtpradioconf_addmessageelement,
 	.create_json = ac_json_80211_wtpradioconf_createjson
 };

src/ac/ac_80211_json_wtpradiofailalarm.c

@@ -42,18 +42,18 @@ static void* ac_json_80211_wtpradiofailalarm_createmessageelement(struct json_ob
 static int ac_json_80211_wtpradiofailalarm_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_wtpradiofailalarm_element* wtpradiofailalarm = (struct capwap_80211_wtpradiofailalarm_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[wtpradiofailalarm->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM);
 
 	if (item->wtpradiofailalarm) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->wtpradiofailalarm);
+		ops->free_message_element(item->wtpradiofailalarm);
 	}
 
 	item->valid = 1;
-	item->wtpradiofailalarm = (struct capwap_80211_wtpradiofailalarm_element*)ops->clone(wtpradiofailalarm);
+	item->wtpradiofailalarm = (struct capwap_80211_wtpradiofailalarm_element*)ops->clone_message_element(wtpradiofailalarm);
 
 	return 1;
 }
@@ -73,7 +73,7 @@ static void ac_json_80211_wtpradiofailalarm_createjson(struct json_object* jsonp
 struct ac_json_ieee80211_ops ac_json_80211_wtpradiofailalarm_ops = {
 	.type = CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM,
 	.json_type = "IEEE80211WTPRadioFailAlarm",
-	.create = ac_json_80211_wtpradiofailalarm_createmessageelement,
+	.create_message_element = ac_json_80211_wtpradiofailalarm_createmessageelement,
 	.add_message_element = ac_json_80211_wtpradiofailalarm_addmessageelement,
 	.create_json = ac_json_80211_wtpradiofailalarm_createjson
 };

src/ac/ac_80211_json_wtpradioinformation.c

@@ -32,18 +32,18 @@ static void* ac_json_80211_wtpradioinformation_createmessageelement(struct json_
 static int ac_json_80211_wtpradioinformation_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite) {
 	struct capwap_80211_wtpradioinformation_element* wtpradioinformation = (struct capwap_80211_wtpradioinformation_element*)data;
 	struct ac_json_ieee80211_item* item = &wtpradio->items[wtpradioinformation->radioid - 1];
-	const struct capwap_message_elements_ops *ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION);
+	struct capwap_message_elements_ops* ops = capwap_get_message_element_ops(CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION);
 
 	if (item->wtpradioinformation) {
 		if (!overwrite) {
 			return 0;
 		}
 
-		ops->free(item->wtpradioinformation);
+		ops->free_message_element(item->wtpradioinformation);
 	}
 
 	item->valid = 1;
-	item->wtpradioinformation = (struct capwap_80211_wtpradioinformation_element*)ops->clone(wtpradioinformation);
+	item->wtpradioinformation = (struct capwap_80211_wtpradioinformation_element*)ops->clone_message_element(wtpradioinformation);
 
 	return 1;
 }
@@ -62,7 +62,7 @@ static void ac_json_80211_wtpradioinformation_createjson(struct json_object* jso
 struct ac_json_ieee80211_ops ac_json_80211_wtpradioinformation_ops = {
 	.type = CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION,
 	.json_type = "IEEE80211WTPRadioInformation",
-	.create = ac_json_80211_wtpradioinformation_createmessageelement,
+	.create_message_element = ac_json_80211_wtpradioinformation_createmessageelement,
 	.add_message_element = ac_json_80211_wtpradioinformation_addmessageelement,
 	.create_json = ac_json_80211_wtpradioinformation_createjson
 };

src/ac/ac_backend.c

@@ -66,7 +66,7 @@ static int ac_backend_parsing_closewtpsession_event(const char* idevent, struct
 		ac_session_send_action(session, AC_SESSION_ACTION_NOTIFY_EVENT, 0, (void*)&notify, sizeof(struct ac_session_notify_event_t));
 
 		/* Async close session */
-		log_printf(LOG_DEBUG, "Receive close wtp session for WTP %s", session->wtpid);
+		capwap_logging_debug("Receive close wtp session for WTP %s", session->wtpid);
 		ac_session_send_action(session, AC_SESSION_ACTION_CLOSE, 0, NULL, 0);
 
 		/* */
@@ -138,7 +138,7 @@ static int ac_backend_parsing_resetwtp_event(const char* idevent, struct json_ob
 			ac_session_send_action(session, AC_SESSION_ACTION_NOTIFY_EVENT, 0, (void*)&notify, sizeof(struct ac_session_notify_event_t));
 
 			/* Notify Action */
-			log_printf(LOG_DEBUG, "Receive reset request for WTP %s", session->wtpid);
+			capwap_logging_debug("Receive reset request for WTP %s", session->wtpid);
 			ac_session_send_action(session, AC_SESSION_ACTION_RESET_WTP, 0, (void*)reset, length);
 			result = 0;
 
@@ -289,7 +289,7 @@ static int ac_backend_parsing_addwlan_event(const char* idevent, struct json_obj
 		ac_session_send_action(session, AC_SESSION_ACTION_NOTIFY_EVENT, 0, (void*)&notify, sizeof(struct ac_session_notify_event_t));
 
 		/* Notify Action */
-		log_printf(LOG_DEBUG, "Receive AddWLAN request for WTP %s with SSID: %s", session->wtpid, addwlan->ssid);
+		capwap_logging_debug("Receive AddWLAN request for WTP %s with SSID: %s", session->wtpid, addwlan->ssid);
 		ac_session_send_action(session, AC_SESSION_ACTION_ADDWLAN, 0, (void*)addwlan, length);
 
 		/* */
@@ -506,7 +506,7 @@ static int ac_backend_soap_join(int forcereset) {
 	/* Retrieve AC configuration */
 	if (g_ac_backend.backendsessionid && forcereset) {
 		if (ac_backend_soap_getconfiguration()) {
-			log_printf(LOG_ERR, "Unable to get AC configuration from Backend Server");
+			capwap_logging_error("Unable to get AC configuration from Backend Server");
 			capwap_free(g_ac_backend.backendsessionid);
 			g_ac_backend.backendsessionid = NULL;
 		}
@@ -725,7 +725,7 @@ static void ac_backend_run(void) {
 
 				/* Connection error, change Backend Server */
 				connected = 0;
-				log_printf(LOG_DEBUG, "Lost connection with Backend Server");
+				capwap_logging_debug("Lost connection with Backend Server");
 				capwap_lock_enter(&g_ac_backend.backendlock);
 
 				/* Lost session id */
@@ -738,7 +738,7 @@ static void ac_backend_run(void) {
 		} else {
 			/* Join with a Backend Server */
 			if (!ac_backend_soap_join(forcereset)) {
-				log_printf(LOG_DEBUG, "Joined with Backend Server");
+				capwap_logging_debug("Joined with Backend Server");
 
 				/* Join Complete */
 				connected = 1;
@@ -753,7 +753,7 @@ static void ac_backend_run(void) {
 
 				/* Wait timeout before continue */
 				if (g_ac_backend.errorjoinbackend >= g_ac.availablebackends->count) {
-					log_printf(LOG_DEBUG, "Unable to join with Backend Server");
+					capwap_logging_debug("Unable to join with Backend Server");
 
 					/* */
 					forcereset = 1;
@@ -792,9 +792,9 @@ static void ac_backend_run(void) {
 
 /* */
 static void* ac_backend_thread(void* param) {
-	log_printf(LOG_DEBUG, "Backend start");
+	capwap_logging_debug("Backend start");
 	ac_backend_run();
-	log_printf(LOG_DEBUG, "Backend stop");
+	capwap_logging_debug("Backend stop");
 
 	/* Thread exit */
 	pthread_exit(NULL);
@@ -843,13 +843,13 @@ int ac_backend_start(void) {
 
 	/* */
 	if (!g_ac.backendacid) {
-		log_printf(LOG_ERR, "AC Backend ID isn't set");
+		capwap_logging_error("AC Backend ID isn't set");
 		return 0;
 	} else if (!g_ac.backendversion) {
-		log_printf(LOG_ERR, "Backend Protocol Version isn't set");
+		capwap_logging_error("Backend Protocol Version isn't set");
 		return 0;
 	} else if (!g_ac.availablebackends->count) {
-		log_printf(LOG_ERR, "List of available backends is empty");
+		capwap_logging_error("List of available backends is empty");
 		return 0;
 	}
 
@@ -861,7 +861,7 @@ int ac_backend_start(void) {
 	/* Create thread */
 	result = pthread_create(&g_ac_backend.threadid, NULL, ac_backend_thread, NULL);
 	if (result) {
-		log_printf(LOG_DEBUG, "Unable create backend thread");
+		capwap_logging_debug("Unable create backend thread");
 		return 0;
 	}
 

src/ac/ac_dfa_configure.c

@@ -4,7 +4,7 @@
 #include "ac_session.h"
 #include "ac_json.h"
 #include "ac_wlans.h"
-#include <json-c/json.h>
+#include <json/json.h>
 #include <arpa/inet.h>
 
 /* */
@@ -222,7 +222,7 @@ static struct ac_soap_response* ac_dfa_state_configure_parsing_request(struct ac
 			struct capwap_message_element_itemlist* messageelement = (struct capwap_message_element_itemlist*)search->item;
 
 			/* Parsing only IEEE 802.11 message element */
-			if (IS_80211_MESSAGE_ELEMENTS(messageelement->id)) {
+			if (IS_80211_MESSAGE_ELEMENTS(messageelement->type)) {
 				if (!ac_json_ieee80211_parsingmessageelement(&wtpradio, messageelement)) {
 					json_object_put(jsonparam);
 					return NULL;
@@ -759,7 +759,7 @@ void ac_dfa_state_configure(struct ac_session_t* session, struct capwap_parsed_p
 	/* Send Configure response to WTP */
 	if (!capwap_crypt_sendto_fragmentpacket(&session->dtls, session->responsefragmentpacket)) {
 		/* Response is already created and saved. When receive a re-request, DFA autoresponse */
-		log_printf(LOG_DEBUG, "Warning: error to send configuration status response packet");
+		capwap_logging_debug("Warning: error to send configuration status response packet");
 	}
 
 	/* Change state */

src/ac/ac_dfa_datacheck.c

@@ -3,7 +3,7 @@
 #include "capwap_array.h"
 #include "ac_session.h"
 #include "ac_json.h"
-#include <json-c/json.h>
+#include <json/json.h>
 
 /* */
 static struct ac_soap_response* ac_dfa_state_datacheck_parsing_request(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
@@ -91,7 +91,7 @@ static struct ac_soap_response* ac_dfa_state_datacheck_parsing_request(struct ac
 			struct capwap_message_element_itemlist* messageelement = (struct capwap_message_element_itemlist*)search->item;
 
 			/* Parsing only IEEE 802.11 message element */
-			if (IS_80211_MESSAGE_ELEMENTS(messageelement->id)) {
+			if (IS_80211_MESSAGE_ELEMENTS(messageelement->type)) {
 				if (!ac_json_ieee80211_parsingmessageelement(&wtpradio, messageelement)) {
 					json_object_put(jsonparam);
 					return NULL;
@@ -205,7 +205,7 @@ void ac_dfa_state_datacheck(struct ac_session_t* session, struct capwap_parsed_p
 	/* Send Change event response to WTP */
 	if (!capwap_crypt_sendto_fragmentpacket(&session->dtls, session->responsefragmentpacket)) {
 		/* Response is already created and saved. When receive a re-request, DFA autoresponse */
-		log_printf(LOG_DEBUG, "Warning: error to send change event response packet");
+		capwap_logging_debug("Warning: error to send change event response packet");
 	}
 
 	/* Change state */

src/ac/ac_dfa_join.c

@@ -4,7 +4,7 @@
 #include "ac_session.h"
 #include "ac_backend.h"
 #include "ac_json.h"
-#include <json-c/json.h>
+#include <json/json.h>
 #include <arpa/inet.h>
 
 /* */
@@ -240,7 +240,7 @@ static struct ac_soap_response* ac_dfa_state_join_parsing_request(struct ac_sess
 			struct capwap_message_element_itemlist* messageelement = (struct capwap_message_element_itemlist*)search->item;
 
 			/* Parsing only IEEE 802.11 message element */
-			if (IS_80211_MESSAGE_ELEMENTS(messageelement->id)) {
+			if (IS_80211_MESSAGE_ELEMENTS(messageelement->type)) {
 				if (!ac_json_ieee80211_parsingmessageelement(&wtpradio, messageelement)) {
 					json_object_put(jsonparam);
 					return NULL;
@@ -590,7 +590,7 @@ void ac_dfa_state_join(struct ac_session_t* session, struct capwap_parsed_packet
 						resultcode.code = CAPWAP_RESULTCODE_JOIN_FAILURE_UNKNOWN_SOURCE;
 					}
 				} else {
-					log_printf(LOG_INFO, "WTP Id %s already used in another session", wtpid);
+					capwap_logging_info("WTP Id %s already used in another session", wtpid);
 					resultcode.code = CAPWAP_RESULTCODE_JOIN_FAILURE_UNKNOWN_SOURCE;
 				}
 
@@ -606,7 +606,7 @@ void ac_dfa_state_join(struct ac_session_t* session, struct capwap_parsed_packet
 				char sessionname[33];
 
 				capwap_sessionid_printf(sessionid, sessionname);
-				log_printf(LOG_INFO, "Session Id %s already used in another session", sessionname);
+				capwap_logging_info("Session Id %s already used in another session", sessionname);
 
 				resultcode.code = CAPWAP_RESULTCODE_JOIN_FAILURE_ID_ALREADY_IN_USE;
 			}
@@ -657,7 +657,7 @@ void ac_dfa_state_join(struct ac_session_t* session, struct capwap_parsed_packet
 		}
 	} else {
 		/* Error to send packets */
-		log_printf(LOG_DEBUG, "Warning: error to send join response packet");
+		capwap_logging_debug("Warning: error to send join response packet");
 		ac_session_teardown(session);
 	}
 }

src/ac/ac_dfa_reset.c

@@ -20,7 +20,7 @@ void ac_dfa_state_reset(struct ac_session_t* session, struct capwap_parsed_packe
 		/* Check the success of the Request */
 		resultcode = (struct capwap_resultcode_element*)capwap_get_message_element_data(packet, CAPWAP_ELEMENT_RESULTCODE);
 		if (resultcode && !CAPWAP_RESULTCODE_OK(resultcode->code)) {
-			log_printf(LOG_WARNING, "Receive Reset Response with error: %d", (int)resultcode->code);
+			capwap_logging_warning("Receive Reset Response with error: %d", (int)resultcode->code);
 		}
 
 		/* */

src/ac/ac_dfa_run.c

@@ -58,14 +58,14 @@ static int receive_echo_request(struct ac_session_t* session, struct capwap_pars
 	{
 		char sessionname[33];
 		capwap_sessionid_printf(&session->sessionid, sessionname);
-		log_printf(LOG_DEBUG, "Send Echo Response to %s", sessionname);
+		capwap_logging_debug("Send Echo Response to %s", sessionname);
 	}
 #endif
 
 	/* Send Configure response to WTP */
 	if (!capwap_crypt_sendto_fragmentpacket(&session->dtls, session->responsefragmentpacket)) {
 		/* Response is already created and saved. When receive a re-request, DFA autoresponse */
-		log_printf(LOG_DEBUG, "Warning: error to send echo response packet");
+		capwap_logging_debug("Warning: error to send echo response packet");
 	}
 
 	return 0;
@@ -88,7 +88,7 @@ static void execute_ieee80211_wlan_configuration_addwlan(struct ac_session_t* se
 
 			/* Assign BSSID to session */
 			if (ac_wlans_assign_bssid(session, wlan)) {
-				log_printf(LOG_WARNING, "Unable to add new wlan with radioid: %d, wlanid: %d", (int)assignbssid->radioid, (int)assignbssid->wlanid);
+				capwap_logging_warning("Unable to add new wlan with radioid: %d, wlanid: %d", (int)assignbssid->radioid, (int)assignbssid->wlanid);
 				ac_wlans_free_bssid(wlan);
 
 				/* TODO: add remove wlan from wtp */
@@ -142,7 +142,7 @@ static void receive_ieee80211_wlan_configuration_response(struct ac_session_t* s
 			capwap_packet_rxmng_free(rxmngrequestpacket);
 		}
 	} else {
-		log_printf(LOG_WARNING, "Receive IEEE802.11 WLAN Configuration Response with error: %d", (int)resultcode->code);
+		capwap_logging_warning("Receive IEEE802.11 WLAN Configuration Response with error: %d", (int)resultcode->code);
 	}
 
 	/* */
@@ -170,7 +170,7 @@ static void execute_ieee80211_station_configuration_response_addstation(struct a
 				station = ac_stations_get_station(session, station80211->radioid, wlan->address, addstation->address);
 				if (station) {
 					if (CAPWAP_RESULTCODE_OK(resultcode->code)) {
-						log_printf(LOG_INFO, "Authorized station: %s", station->addrtext);
+						capwap_logging_info("Authorized station: %s", station->addrtext);
 
 						/* */
 						station->flags |= AC_STATION_FLAGS_AUTHORIZED;
@@ -198,7 +198,7 @@ static void execute_ieee80211_station_configuration_response_deletestation(struc
 	/* */
 	station = ac_stations_get_station(session, deletestation->radioid, NULL, deletestation->address);
 	if (station) {
-		log_printf(LOG_INFO, "Deauthorized station: %s with %d result code", station->addrtext, (int)resultcode->code);
+		capwap_logging_info("Deauthorized station: %s with %d result code", station->addrtext, (int)resultcode->code);
 
 		/* */
 		ac_stations_delete_station(session, station);
@@ -258,7 +258,7 @@ void ac_dfa_state_run(struct ac_session_t* session, struct capwap_parsed_packet*
 				{
 					char sessionname[33];
 					capwap_sessionid_printf(&session->sessionid, sessionname);
-					log_printf(LOG_DEBUG, "Receive Echo Request from %s", sessionname);
+					capwap_logging_debug("Receive Echo Request from %s", sessionname);
 				}
 #endif
 

src/ac/ac_discovery.c

@@ -167,7 +167,7 @@ static void ac_discovery_run(void) {
 						struct capwap_packet_txmng* txmngpacket;
 
 						/* */
-						log_printf(LOG_DEBUG, "Receive discovery request packet");
+						capwap_logging_debug("Receive discovery request packet");
 
 						/* Creare discovery response */
 						txmngpacket = ac_create_discovery_response(&packet);
@@ -186,7 +186,7 @@ static void ac_discovery_run(void) {
 
 							/* Send discovery response to WTP */
 							if (!capwap_sendto_fragmentpacket(acpacket->sendsock, responsefragmentpacket, &acpacket->sender)) {
-								log_printf(LOG_DEBUG, "Warning: error to send discovery response packet");
+								capwap_logging_debug("Warning: error to send discovery response packet");
 							}
 
 							/* Don't buffering a packets sent */
@@ -211,9 +211,9 @@ static void ac_discovery_run(void) {
 /* */
 static void* ac_discovery_thread(void* param) {
 	
-	log_printf(LOG_DEBUG, "Discovery start");
+	capwap_logging_debug("Discovery start");
 	ac_discovery_run();
-	log_printf(LOG_DEBUG, "Discovery stop");
+	capwap_logging_debug("Discovery stop");
 
 	/* Thread exit */
 	pthread_exit(NULL);
@@ -234,7 +234,7 @@ int ac_discovery_start(void) {
 	/* Create thread */
 	result = pthread_create(&g_ac_discovery.threadid, NULL, ac_discovery_thread, NULL);
 	if (result) {
-		log_printf(LOG_DEBUG, "Unable create discovery thread");
+		capwap_logging_debug("Unable create discovery thread");
 		return 0;
 	}
 	

src/ac/ac_execute.c

@@ -203,7 +203,7 @@ static void ac_session_msgqueue_parsing_item(struct ac_session_msgqueue_item_t*
 		}
 
 		default: {
-			log_printf(LOG_DEBUG, "Unknown message queue item: %lu", item->message);
+			capwap_logging_debug("Unknown message queue item: %lu", item->message);
 			break;
 		}
 	}
@@ -215,11 +215,11 @@ static void ac_wait_terminate_allsessions(void) {
 
 	/* Wait that list is empty */
 	while (g_ac.sessionsthread->count > 0) {
-		log_printf(LOG_DEBUG, "Waiting for %d session terminate", g_ac.sessionsthread->count);
+		capwap_logging_debug("Waiting for %d session terminate", g_ac.sessionsthread->count);
 
 		/* Receive message queue packet */
 		if (!ac_recvmsgqueue(g_ac.fdmsgsessions[1], &item)) {
-			log_printf(LOG_DEBUG, "Unable to receive message queue");
+			capwap_logging_debug("Unable to receive message queue");
 			break;
 		}
 
@@ -229,7 +229,7 @@ static void ac_wait_terminate_allsessions(void) {
 		}
 	}
 
-	log_printf(LOG_DEBUG, "Close all sessions");
+	capwap_logging_debug("Close all sessions");
 }
 
 /* Initialize message queue */
@@ -682,7 +682,7 @@ static struct ac_session_t* ac_create_session(int sock, union sockaddr_capwap* f
 		/* */
 		capwap_itemlist_insert_after(g_ac.sessionsthread, NULL, itemlist);
 	} else {
-		log_printf(LOG_EMERG, "Unable create session thread, error code %d", result);
+		capwap_logging_fatal("Unable create session thread, error code %d", result);
 		capwap_exit(CAPWAP_OUT_OF_MEMORY);
 	}
 
@@ -828,7 +828,7 @@ int ac_execute(void) {
 
 	/* Set file descriptor pool */
 	if (ac_execute_init_fdspool(&fds, &g_ac.net, g_ac.fdmsgsessions[1]) <= 0) {
-		log_printf(LOG_DEBUG, "Unable to initialize file descriptor pool");
+		capwap_logging_debug("Unable to initialize file descriptor pool");
 		return AC_ERROR_SYSTEM_FAILER;
 	}
 
@@ -841,7 +841,7 @@ int ac_execute(void) {
 	/* Start discovery thread */
 	if (!ac_discovery_start()) {
 		ac_execute_free_fdspool(&fds);
-		log_printf(LOG_DEBUG, "Unable to start discovery thread");
+		capwap_logging_debug("Unable to start discovery thread");
 		return AC_ERROR_SYSTEM_FAILER;
 	}
 
@@ -849,7 +849,7 @@ int ac_execute(void) {
 	if (!ac_backend_start()) {
 		ac_execute_free_fdspool(&fds);
 		ac_discovery_stop();
-		log_printf(LOG_ERR, "Unable start backend management");
+		capwap_logging_error("Unable start backend management");
 		return AC_ERROR_SYSTEM_FAILER;
 	}
 
@@ -859,7 +859,7 @@ int ac_execute(void) {
 		buffersize = sizeof(buffer);
 		index = ac_recvfrom(&fds, buffer, &buffersize, &fromaddr, &toaddr);
 		if (!g_ac.running) {
-			log_printf(LOG_DEBUG, "Closing AC");
+			capwap_logging_debug("Closing AC");
 			break;
 		}
 		

src/ac/ac_ieee80211_data.c

@@ -42,7 +42,7 @@ static void ac_ieee80211_mgmt_authentication_packet(struct ac_session_t* session
 		}
 
 		/* */
-		log_printf(LOG_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 */
 		station->timeoutaction = AC_STATION_TIMEOUT_ACTION_DEAUTHENTICATE;
@@ -62,7 +62,7 @@ static void ac_ieee80211_mgmt_authentication_packet(struct ac_session_t* session
 
 			/* Parsing Information Elements */
 			if (ieee80211_retrieve_information_elements_position(&ieitems, &mgmt->authetication.ie[0], ielength)) {
-				log_printf(LOG_INFO, "Invalid IEEE802.11 Authentication Request from %s station", station->addrtext);
+				capwap_logging_info("Invalid IEEE802.11 Authentication Request from %s station", station->addrtext);
 				return;
 			}
 
@@ -95,14 +95,14 @@ static void ac_ieee80211_mgmt_authentication_packet(struct ac_session_t* session
 			if (responselength > 0) {
 				/* Send authentication response */
 				if (!ac_kmod_send_data(&session->sessionid, wlan->device->radioid, session->binding, buffer, responselength)) {
-					log_printf(LOG_INFO, "Sent IEEE802.11 Authentication Response to %s station with %d status code", station->addrtext, (int)responsestatuscode);
+					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 {
-					log_printf(LOG_WARNING, "Unable to send IEEE802.11 Authentication Response to %s station", station->addrtext);
+					capwap_logging_warning("Unable to send IEEE802.11 Authentication Response to %s station", station->addrtext);
 					ac_stations_delete_station(session, station);
 				}
 			} else {
-				log_printf(LOG_WARNING, "Unable to create IEEE802.11 Authentication Response to %s station", station->addrtext);
+				capwap_logging_warning("Unable to create IEEE802.11 Authentication Response to %s station", station->addrtext);
 				ac_stations_delete_station(session, station);
 			}
 		}
@@ -117,7 +117,7 @@ static void ac_ieee80211_mgmt_authentication_packet(struct ac_session_t* session
 			statuscode = __le16_to_cpu(mgmt->authetication.statuscode);
 
 			/* */
-			log_printf(LOG_INFO, "Receive IEEE802.11 Authentication Response to %s station with %d status code", station->addrtext, (int)statuscode);
+			capwap_logging_info("Receive IEEE802.11 Authentication Response to %s station with %d status code", station->addrtext, (int)statuscode);
 
 			if (statuscode == IEEE80211_STATUS_SUCCESS) {
 				algorithm = __le16_to_cpu(mgmt->authetication.algorithm);
@@ -155,13 +155,13 @@ static void ac_ieee80211_mgmt_association_request_packet(struct ac_session_t* se
 		}
 
 		/* */
-		log_printf(LOG_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 */
-			log_printf(LOG_INFO, "Receive IEEE802.11 Association Request from %s unauthorized station", station->addrtext);
+			capwap_logging_info("Receive IEEE802.11 Association Request from %s unauthorized station", station->addrtext);
 			ac_stations_delete_station(session, station);
 			return;
 		}
@@ -191,7 +191,7 @@ static void ac_ieee80211_mgmt_association_request_packet(struct ac_session_t* se
 
 				/* Parsing Information Elements */
 				if (ieee80211_retrieve_information_elements_position(&ieitems, &mgmt->associationrequest.ie[0], ielength)) {
-					log_printf(LOG_INFO, "Invalid IEEE802.11 Association Request from %s station", station->addrtext);
+					capwap_logging_info("Invalid IEEE802.11 Association Request from %s station", station->addrtext);
 					ac_stations_delete_station(session, station);
 					return;
 				}
@@ -237,17 +237,17 @@ static void ac_ieee80211_mgmt_association_request_packet(struct ac_session_t* se
 				if (responselength > 0) {
 					/* Send association response */
 					if (!ac_kmod_send_data(&session->sessionid, wlan->device->radioid, session->binding, buffer, responselength)) {
-						log_printf(LOG_INFO, "Sent IEEE802.11 Association Response to %s station with %d status code", station->addrtext, (int)resultstatuscode);
+						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(session, station);
 					} else {
-						log_printf(LOG_WARNING, "Unable to send IEEE802.11 Association Response to %s station", station->addrtext);
+						capwap_logging_warning("Unable to send IEEE802.11 Association Response to %s station", station->addrtext);
 						ac_stations_delete_station(session, station);
 					}
 				} else {
-					log_printf(LOG_WARNING, "Unable to create IEEE802.11 Association Response to %s station", station->addrtext);
+					capwap_logging_warning("Unable to create IEEE802.11 Association Response to %s station", station->addrtext);
 					ac_stations_delete_station(session, station);
 				}
 			}
@@ -271,7 +271,7 @@ static void ac_ieee80211_mgmt_association_response_packet(struct ac_session_t* s
 	if (!memcmp(mgmt->bssid, mgmt->sa, MACADDRESS_EUI48_LENGTH) && memcmp(mgmt->bssid, mgmt->da, MACADDRESS_EUI48_LENGTH)) {
 		station = ac_stations_get_station(session, radioid, mgmt->bssid, mgmt->da);
 		if (station && station->wlan && (station->wlan->macmode == CAPWAP_ADD_WLAN_MACMODE_LOCAL)) {
-			log_printf(LOG_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) {
 				/* Get Station Info */

src/ac/ac_json.h

@@ -2,7 +2,7 @@
 #define __AC_JSON_HEADER__
 
 #include "capwap_array.h"
-#include <json-c/json.h>
+#include <json/json.h>
 
 #define IEEE80211_BINDING_JSON_ROOT					"WTPRadio"
 
@@ -61,13 +61,13 @@ struct ac_json_ieee80211_wtpradio {
 /* */
 struct ac_json_ieee80211_ops {
 	/* Message Element Type */
-	struct capwap_message_element_id type;
+	uint16_t type;
 
 	/* Message Element JSON Type */
 	char* json_type;
 
 	/* Build message element */
-	void* (*create)(struct json_object* jsonparent, uint16_t radioid);
+	void* (*create_message_element)(struct json_object* jsonparent, uint16_t radioid);
 	int (*add_message_element)(struct ac_json_ieee80211_wtpradio* wtpradio, void* data, int overwrite);
 
 	/* Build JSON */
@@ -79,9 +79,7 @@ void ac_json_ieee80211_init(struct ac_json_ieee80211_wtpradio* wtpradio);
 void ac_json_ieee80211_free(struct ac_json_ieee80211_wtpradio* wtpradio);
 
 /* */
-int ac_json_ieee80211_addmessageelement(struct ac_json_ieee80211_wtpradio *wtpradio,
+int ac_json_ieee80211_addmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, uint16_t type, void* data, int overwrite);
-					const struct capwap_message_element_id id,
-					void *data, int overwrite);
 int ac_json_ieee80211_parsingmessageelement(struct ac_json_ieee80211_wtpradio* wtpradio, struct capwap_message_element_itemlist* messageelement);
 int ac_json_ieee80211_parsingjson(struct ac_json_ieee80211_wtpradio* wtpradio, struct json_object* jsonroot);
 

src/ac/ac_kmod.c

@@ -191,7 +191,7 @@ static int ac_kmod_link(void) {
 		if (result == -EALREADY) {
 			result = 0;
 		} else {
-			log_printf(LOG_WARNING, "Unable to connect kernel module, error code: %d", result);
+			capwap_logging_warning("Unable to connect kernel module, error code: %d", result);
 		}
 	}
 
@@ -211,7 +211,7 @@ static void ac_kmod_event_receive(int fd, void** params, int paramscount) {
 	/* */
 	res = nl_recvmsgs((struct nl_sock*)params[0], (struct nl_cb*)params[1]);
 	if (res) {
-		log_printf(LOG_WARNING, "Receive kernel module message failed: %d", res);
+		capwap_logging_warning("Receive kernel module message failed: %d", res);
 	}
 }
 
@@ -233,12 +233,12 @@ int ac_kmod_send_keepalive(struct capwap_sessionid_element* sessionid) {
 	nla_put(msg, NLSMARTCAPWAP_ATTR_SESSION_ID, sizeof(struct capwap_sessionid_element), sessionid);
 
 	/* */
-	log_printf(LOG_DEBUG, "Prepare to send keep-alive");
+	capwap_logging_debug("Prepare to send keep-alive");
 	result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
 	if (result) {
-		log_printf(LOG_ERR, "Unable to send keep-alive: %d", result);
+		capwap_logging_error("Unable to send keep-alive: %d", result);
 	}
-	log_printf(LOG_DEBUG, "Sent keep-alive");
+	capwap_logging_debug("Sent keep-alive");
 
 	/* */
 	nlmsg_free(msg);
@@ -270,7 +270,7 @@ int ac_kmod_send_data(struct capwap_sessionid_element* sessionid, uint8_t radioi
 	/* */
 	result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
 	if (result) {
-		log_printf(LOG_ERR, "Unable to send data: %d", result);
+		capwap_logging_error("Unable to send data: %d", result);
 	}
 
 	/* */
@@ -342,7 +342,7 @@ int ac_kmod_createdatachannel(int family, unsigned short port) {
 	/* */
 	result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
 	if (result) {
-		log_printf(LOG_ERR, "Unable to bind kernel socket: %d", result);
+		capwap_logging_error("Unable to bind kernel socket: %d", result);
 	}
 
 	/* */
@@ -372,7 +372,7 @@ int ac_kmod_new_datasession(struct capwap_sessionid_element* sessionid, uint8_t
 	/* */
 	result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
 	if (result) {
-		log_printf(LOG_ERR, "Unable to create data session: %d", result);
+		capwap_logging_error("Unable to create data session: %d", result);
 	}
 
 	/* */
@@ -400,7 +400,7 @@ int ac_kmod_delete_datasession(struct capwap_sessionid_element* sessionid) {
 	/* */
 	result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
 	if (result && (result != ENOENT)) {
-		log_printf(LOG_ERR, "Unable to delete data session: %d", result);
+		capwap_logging_error("Unable to delete data session: %d", result);
 	}
 
 	/* */
@@ -436,7 +436,7 @@ int ac_kmod_addwlan(struct capwap_sessionid_element* sessionid, uint8_t radioid,
 	/* */
 	result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
 	if (result) {
-		log_printf(LOG_ERR, "Unable to add wlan: %d", result);
+		capwap_logging_error("Unable to add wlan: %d", result);
 	}
 
 	/* */
@@ -464,7 +464,7 @@ int ac_kmod_removewlan(struct capwap_sessionid_element* sessionid) {
 	/* */
 	result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
 	if (result && (result != ENOENT)) {
-		log_printf(LOG_ERR, "Unable to remove wlan: %d", result);
+		capwap_logging_error("Unable to remove wlan: %d", result);
 	}
 
 	/* */
@@ -512,7 +512,7 @@ int ac_kmod_create_iface(const char* ifname, uint16_t mtu) {
 	if (!result) {
 		result = (ifindex ? (int)ifindex : -1);
 	} else {
-		log_printf(LOG_ERR, "Unable to create data session: %d", result);
+		capwap_logging_error("Unable to create data session: %d", result);
 	}
 
 	/* */
@@ -540,7 +540,7 @@ int ac_kmod_delete_iface(int ifindex) {
 	/* */
 	result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
 	if (result && (result != ENOENT)) {
-		log_printf(LOG_ERR, "Unable to delete interface: %d", result);
+		capwap_logging_error("Unable to delete interface: %d", result);
 	}
 
 	/* */
@@ -580,7 +580,7 @@ int ac_kmod_authorize_station(struct capwap_sessionid_element* sessionid, const
 	/* */
 	result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
 	if (result) {
-		log_printf(LOG_ERR, "Unable to authorize station: %d", result);
+		capwap_logging_error("Unable to authorize station: %d", result);
 	}
 
 	/* */
@@ -610,7 +610,7 @@ int ac_kmod_deauthorize_station(struct capwap_sessionid_element* sessionid, cons
 	/* */
 	result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
 	if (result) {
-		log_printf(LOG_ERR, "Unable to deauthorize station: %d", result);
+		capwap_logging_error("Unable to deauthorize station: %d", result);
 	}
 
 	/* */
@@ -644,7 +644,7 @@ int ac_kmod_init(void) {
 	/* Get nlsmartcapwap netlink family */
 	g_ac.kmodhandle.nlsmartcapwap_id = genl_ctrl_resolve(g_ac.kmodhandle.nl, NLSMARTCAPWAP_GENL_NAME);
 	if (g_ac.kmodhandle.nlsmartcapwap_id < 0) {
-		log_printf(LOG_WARNING, "Unable to found kernel module");
+		capwap_logging_warning("Unable to found kernel module");
 		ac_kmod_free();
 		return -1;
 	}

src/ac/ac_session.c

@@ -165,12 +165,12 @@ static int ac_session_action_authorizestation_response(struct ac_session_t* sess
 							session->retransmitcount = 0;
 							capwap_timeout_set(session->timeout, session->idtimercontrol, AC_RETRANSMIT_INTERVAL, ac_dfa_retransmition_timeout, session, NULL);
 						} else {
-							log_printf(LOG_WARNING, "Unable to authorize station into kernel module data channel");
+							capwap_logging_warning("Unable to authorize station into kernel module data channel");
 							ac_free_reference_last_request(session);
 							ac_session_teardown(session);
 						}
 					} else {
-						log_printf(LOG_DEBUG, "Warning: error to send Station Configuration Request packet");
+						capwap_logging_debug("Warning: error to send Station Configuration Request packet");
 						ac_free_reference_last_request(session);
 						ac_session_teardown(session);
 					}
@@ -219,7 +219,7 @@ static int ac_session_action_resetwtp(struct ac_session_t* session, struct ac_no
 		ac_dfa_change_state(session, CAPWAP_RESET_STATE);
 		capwap_timeout_set(session->timeout, session->idtimercontrol, AC_RETRANSMIT_INTERVAL, ac_dfa_retransmition_timeout, session, NULL);
 	} else {
-		log_printf(LOG_DEBUG, "Warning: error to send Reset Request packet");
+		capwap_logging_debug("Warning: error to send Reset Request packet");
 		ac_free_reference_last_request(session);
 		ac_session_teardown(session);
 	}
@@ -279,7 +279,7 @@ static int ac_session_action_addwlan(struct ac_session_t* session, struct ac_not
 		session->retransmitcount = 0;
 		capwap_timeout_set(session->timeout, session->idtimercontrol, AC_RETRANSMIT_INTERVAL, ac_dfa_retransmition_timeout, session, NULL);
 	} else {
-		log_printf(LOG_DEBUG, "Warning: error to send WLAN Configuration Request packet");
+		capwap_logging_debug("Warning: error to send WLAN Configuration Request packet");
 		ac_free_reference_last_request(session);
 		ac_session_teardown(session);
 	}
@@ -302,7 +302,7 @@ static int ac_session_action_station_configuration_ieee8011_add_station(struct a
 	response = ac_session_action_authorizestation_request(session, notify->radioid, notify->wlanid, notify->address);
 	if (response) {
 		if (ac_session_action_authorizestation_response(session, response, notify)) {
-			log_printf(LOG_INFO, "Station is not authorized");
+			capwap_logging_info("Station is not authorized");
 			/* TODO kickoff station */
 		}
 
@@ -353,7 +353,7 @@ static int ac_session_action_station_configuration_ieee8011_delete_station(struc
 		session->retransmitcount = 0;
 		capwap_timeout_set(session->timeout, session->idtimercontrol, AC_RETRANSMIT_INTERVAL, ac_dfa_retransmition_timeout, session, NULL);
 	} else {
-		log_printf(LOG_DEBUG, "Warning: error to send Station Configuration Request packet");
+		capwap_logging_debug("Warning: error to send Station Configuration Request packet");
 		ac_free_reference_last_request(session);
 		ac_session_teardown(session);
 	}
@@ -399,7 +399,7 @@ static int ac_session_action_execute(struct ac_session_t* session, struct ac_ses
 			{
 				char sessionname[33];
 				capwap_sessionid_printf(&session->sessionid, sessionname);
-				log_printf(LOG_DEBUG, "Receive Keep-Alive from %s", sessionname);
+				capwap_logging_debug("Receive Keep-Alive from %s", sessionname);
 			}
 #endif
 			/* Send keep-alive response */
@@ -601,7 +601,7 @@ static void ac_dfa_execute(struct ac_session_t* session, struct capwap_parsed_pa
 		}
 
 		default: {
-			log_printf(LOG_DEBUG, "Unknown AC action event: %lu", session->state);
+			capwap_logging_debug("Unknown AC action event: %lu", session->state);
 			ac_session_teardown(session);
 			break;
 		}
@@ -659,7 +659,7 @@ static void ac_session_destroy(struct ac_session_t* session) {
 
 #ifdef DEBUG
 	capwap_sessionid_printf(&session->sessionid, sessionname);
-	log_printf(LOG_DEBUG, "Release Session AC %s", sessionname);
+	capwap_logging_debug("Release Session AC %s", sessionname);
 #endif
 
 	/* Release last reference */
@@ -674,7 +674,7 @@ static void ac_session_destroy(struct ac_session_t* session) {
 	/* Check if all reference is release */
 	while (session->count > 0) {
 #ifdef DEBUG
-		log_printf(LOG_DEBUG, "Wait for release Session AC %s (count=%d)", sessionname, session->count);
+		capwap_logging_debug("Wait for release Session AC %s (count=%d)", sessionname, session->count);
 #endif
 		/* */
 		capwap_event_reset(&session->changereference);
@@ -777,9 +777,9 @@ static void ac_session_run(struct ac_session_t* session) {
 					if (capwap_is_request_type(session->rxmngpacket->ctrlmsg.type) && (session->remotetype == session->rxmngpacket->ctrlmsg.type) && (session->remoteseqnumber == session->rxmngpacket->ctrlmsg.seq)) {
 						/* Retransmit response */
 						if (!capwap_crypt_sendto_fragmentpacket(&session->dtls, session->responsefragmentpacket)) {
-							log_printf(LOG_ERR, "Error to resend response packet");
+							capwap_logging_error("Error to resend response packet");
 						} else {
-							log_printf(LOG_DEBUG, "Retrasmitted control packet");
+							capwap_logging_debug("Retrasmitted control packet");
 						}
 					} else {
 						/* Check message type */
@@ -832,24 +832,24 @@ static void ac_session_run(struct ac_session_t* session) {
 									/* */
 									ac_dfa_execute(session, &packet);
 								} else {
-									log_printf(LOG_DEBUG, "Failed validation parsed control packet");
+									capwap_logging_debug("Failed validation parsed control packet");
 									if (capwap_is_request_type(session->rxmngpacket->ctrlmsg.type)) {
-										log_printf(LOG_WARNING, "Missing Mandatory Message Element, send Response Packet with error");
+										capwap_logging_warning("Missing Mandatory Message Element, send Response Packet with error");
 										ac_send_invalid_request(session, CAPWAP_RESULTCODE_FAILURE_MISSING_MANDATORY_MSG_ELEMENT);
 									}
 								}
 							} else {
-								log_printf(LOG_DEBUG, "Failed parsing packet");
+								capwap_logging_debug("Failed parsing packet");
 								if ((res == UNRECOGNIZED_MESSAGE_ELEMENT) && capwap_is_request_type(session->rxmngpacket->ctrlmsg.type)) {
-									log_printf(LOG_WARNING, "Unrecognized Message Element, send Response Packet with error");
+									capwap_logging_warning("Unrecognized Message Element, send Response Packet with error");
 									ac_send_invalid_request(session, CAPWAP_RESULTCODE_FAILURE_UNRECOGNIZED_MESSAGE_ELEMENT);
 									/* TODO: add the unrecognized message element */
 								}
 							}
 						} else {
-							log_printf(LOG_DEBUG, "Invalid message type");
+							capwap_logging_debug("Invalid message type");
 							if (res == INVALID_REQUEST_MESSAGE_TYPE) {
-								log_printf(LOG_WARNING, "Unexpected Unrecognized Request, send Response Packet with error");
+								capwap_logging_warning("Unexpected Unrecognized Request, send Response Packet with error");
 								ac_send_invalid_request(session, CAPWAP_RESULTCODE_MSG_UNEXPECTED_UNRECOGNIZED_REQUEST);
 							}
 						}
@@ -890,7 +890,7 @@ void ac_dfa_change_state(struct ac_session_t* session, int state) {
 #ifdef DEBUG
 		char sessionname[33];
 		capwap_sessionid_printf(&session->sessionid, sessionname);
-		log_printf(LOG_DEBUG, "Session AC %s change state from %s to %s", sessionname, capwap_dfa_getname(session->state), capwap_dfa_getname(state));
+		capwap_logging_debug("Session AC %s change state from %s to %s", sessionname, capwap_dfa_getname(session->state), capwap_dfa_getname(state));
 #endif
 
 		session->state = state;
@@ -984,9 +984,9 @@ void* ac_session_thread(void* param) {
 	threadid = session->threadid;
 
 	/* */
-	log_printf(LOG_DEBUG, "Session start");
+	capwap_logging_debug("Session start");
 	ac_session_run(session);
-	log_printf(LOG_DEBUG, "Session end");
+	capwap_logging_debug("Session end");
 
 	/* Notify terminate thread */
 	ac_msgqueue_notify_closethread(threadid);
@@ -1100,21 +1100,21 @@ void ac_dfa_retransmition_timeout(struct capwap_timeout* timeout, unsigned long
 	struct ac_session_t* session = (struct ac_session_t*)context;
 
 	if (!session->requestfragmentpacket->count) {
-		log_printf(LOG_WARNING, "Invalid retransmition request packet");
+		capwap_logging_warning("Invalid retransmition request packet");
 		ac_session_teardown(session);
 	} else {
 		session->retransmitcount++;
 		if (session->retransmitcount >= AC_MAX_RETRANSMIT) {
-			log_printf(LOG_INFO, "Retransmition request packet timeout");
+			capwap_logging_info("Retransmition request packet timeout");
 
 			/* Timeout reset state */
 			ac_free_reference_last_request(session);
 			ac_session_teardown(session);
 		} else {
 			/* Retransmit Request */
-			log_printf(LOG_DEBUG, "Retransmition request packet");
+			capwap_logging_debug("Retransmition request packet");
 			if (!capwap_crypt_sendto_fragmentpacket(&session->dtls, session->requestfragmentpacket)) {
-				log_printf(LOG_ERR, "Error to send request packet");
+				capwap_logging_error("Error to send request packet");
 			}
 
 			/* Update timeout */
@@ -1124,6 +1124,6 @@ void ac_dfa_retransmition_timeout(struct capwap_timeout* timeout, unsigned long
 }
 
 void ac_dfa_teardown_timeout(struct capwap_timeout* timeout, unsigned long index, void* context, void* param) {
-	log_printf(LOG_INFO, "Session timeout, teardown");
+	capwap_logging_info("Session timeout, teardown");
 	ac_session_teardown((struct ac_session_t*)context);
 }

src/ac/ac_wlans.c

@@ -45,7 +45,7 @@ static void ac_stations_destroy_station(struct ac_session_t* session, struct ac_
 	ASSERT(station != NULL);
 
 	/* */
-	log_printf(LOG_INFO, "Destroy station: %s", station->addrtext);
+	capwap_logging_info("Destroy station: %s", station->addrtext);
 
 	/* Remove reference from Authoritative Stations List */
 	capwap_rwlock_wrlock(&g_ac.authstationslock);
@@ -166,7 +166,7 @@ int ac_wlans_assign_bssid(struct ac_session_t* session, struct ac_wlan* wlan) {
 	capwap_itemlist_insert_after(session->wlans->devices[wlan->device->radioid - 1].wlans, NULL, wlan->wlanitem);
 
 	/* */
-	log_printf(LOG_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));
+	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 0;
 }
 
@@ -342,7 +342,7 @@ struct ac_station* ac_stations_create_station(struct ac_session_t* session, uint
 	/* */
 	capwap_printf_macaddress(buffer1, bssid, MACADDRESS_EUI48_LENGTH);
 	capwap_printf_macaddress(buffer2, address, MACADDRESS_EUI48_LENGTH);
-	log_printf(LOG_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);
 
 	/* */
 	wlan = ac_wlans_get_bssid(session, radioid, bssid);
@@ -392,7 +392,7 @@ struct ac_station* ac_stations_create_station(struct ac_session_t* session, uint
 			}
 		}
 	} else {
-		log_printf(LOG_WARNING, "Unable to find radioid: %d, bssid: %s", (int)radioid, buffer1);
+		capwap_logging_warning("Unable to find radioid: %d, bssid: %s", (int)radioid, buffer1);
 	}
 
 	return station;
@@ -479,7 +479,7 @@ void ac_stations_timeout(struct capwap_timeout* timeout, unsigned long index, vo
 	if (station->idtimeout == index) {
 		switch (station->timeoutaction) {
 			case AC_STATION_TIMEOUT_ACTION_DEAUTHENTICATE: {
-				log_printf(LOG_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_t*)param, station);
 				break;
 			}

src/common/binding/ieee80211/ieee80211.h

@@ -500,80 +500,6 @@ struct ieee80211_ie_wmm_information_element {
 	uint8_t qos_info;
 } STRUCT_PACKED;
 
-#define IEEE80211_HT_MCS_MASK_LEN               10
-
-struct ieee80211_mcs_info {
-        uint8_t rx_mask[IEEE80211_HT_MCS_MASK_LEN];
-        uint16_t rx_highest;
-        uint8_t tx_params;
-        uint8_t reserved[3];
-} STRUCT_PACKED;
-
-/**
- * struct ieee80211_ht_cap - HT capabilities
- *
- * This structure is the "HT capabilities element" as
- * described in 802.11n D5.0 7.3.2.57
- */
-
-#define IEEE80211_IE_HT_CAPABILITY	45
-
-struct ieee80211_ht_cap {
-        uint16_t cap_info;
-        uint8_t ampdu_params_info;
-
-        /* 16 bytes MCS information */
-        struct ieee80211_mcs_info mcs;
-
-        uint16_t extended_ht_cap_info;
-        uint32_t tx_BF_cap_info;
-        uint8_t antenna_selection_info;
-} STRUCT_PACKED;
-
-struct ieee80211_ie_ht_cap {
-	uint8_t id;
-	uint8_t len;
-	struct ieee80211_ht_cap ht_cap;
-} STRUCT_PACKED;
-
-
-/* 802.11n HT capabilities masks (for cap_info) */
-#define IEEE80211_HT_CAP_LDPC_CODING            0x0001
-#define IEEE80211_HT_CAP_SUP_WIDTH_20_40        0x0002
-#define IEEE80211_HT_CAP_SM_PS                  0x000C
-#define         IEEE80211_HT_CAP_SM_PS_SHIFT    2
-#define IEEE80211_HT_CAP_GRN_FLD                0x0010
-#define IEEE80211_HT_CAP_SGI_20                 0x0020
-#define IEEE80211_HT_CAP_SGI_40                 0x0040
-#define IEEE80211_HT_CAP_TX_STBC                0x0080
-#define IEEE80211_HT_CAP_RX_STBC                0x0300
-#define         IEEE80211_HT_CAP_RX_STBC_SHIFT  8
-#define IEEE80211_HT_CAP_DELAY_BA               0x0400
-#define IEEE80211_HT_CAP_MAX_AMSDU              0x0800
-#define IEEE80211_HT_CAP_DSSSCCK40              0x1000
-#define IEEE80211_HT_CAP_RESERVED               0x2000
-#define IEEE80211_HT_CAP_40MHZ_INTOLERANT       0x4000
-#define IEEE80211_HT_CAP_LSIG_TXOP_PROT         0x8000
-
-/**
- * struct ieee80211_ht_operation - HT operation IE
- *
- * This structure is the "HT operation element" as
- * described in 802.11n-2009 7.3.2.57
- */
-
-#define IEEE80211_IE_HT_OPERATION	61
-
-struct ieee80211_ht_operation {
-	uint8_t id;
-	uint8_t len;
-        uint8_t primary_chan;
-        uint8_t ht_param;
-        uint16_t operation_mode;
-        uint16_t stbc_param;
-        uint8_t basic_set[16];
-} STRUCT_PACKED;
-
 /* 802.11 All information elements */
 struct ieee80211_ie_items {
 	struct ieee80211_ie_ssid *ssid;
@@ -588,8 +514,6 @@ struct ieee80211_ie_items {
 	struct ieee80211_ie_power_constraint *power_constraint;
 	struct ieee80211_ie_ssid_list *ssid_list;
 	struct ieee80211_ie_wmm_information_element *wmm_ie;
-	struct ieee80211_ie_ht_cap *ht_cap;
-	struct ieee80211_ht_operation *ht_oper;
 };
 
 /* IEEE 802.11 functions */

src/common/capwap.h

@@ -76,7 +76,7 @@ void capwap_daemon(void);
 
 /* */
 #define capwap_outofmemory()						do {																	\
-														log_printf(LOG_EMERG, "Out of memory %s(%d)", __FILE__, __LINE__);	\
+														capwap_logging_fatal("Out of memory %s(%d)", __FILE__, __LINE__);	\
 														capwap_exit(CAPWAP_OUT_OF_MEMORY); 									\
 													} while(0)
 

src/common/capwap_debug.c

@@ -36,14 +36,14 @@ void* capwap_alloc_debug(size_t size, const char* file, const int line) {
 
 	/* Request size > 0 */
 	if (size <= 0) {
-		log_printf(LOG_DEBUG, "%s(%d): Invalid memory size %zu", file, line, size);
+		capwap_logging_debug("%s(%d): Invalid memory size %d", file, line, size);
 		exit(CAPWAP_ASSERT_CONDITION);
 	}
 
 	/* Alloc block with memory block */
 	block = (struct capwap_memory_block*)malloc(sizeof(struct capwap_memory_block) + size);
 	if (!block) {
-		log_printf(LOG_DEBUG, "Out of memory %s(%d)", file, line);
+		capwap_logging_debug("Out of memory %s(%d)", file, line);
 		exit(CAPWAP_OUT_OF_MEMORY);
 	}
 
@@ -69,19 +69,19 @@ void capwap_free_debug(void* p, const char* file, const int line) {
 	struct capwap_memory_block* prevblock;
 
 	if (!p) {
-		log_printf(LOG_DEBUG, "%s(%d): Free NULL pointer", file, line);
+		capwap_logging_debug("%s(%d): Free NULL pointer", file, line);
 		exit(CAPWAP_ASSERT_CONDITION);
 	}
 
 	/* Memory block */
 	if ((size_t)p <= sizeof(struct capwap_memory_block)) {
-		log_printf(LOG_DEBUG, "%s(%d): Invalid pointer", file, line);
+		capwap_logging_debug("%s(%d): Invalid pointer", file, line);
 		exit(CAPWAP_ASSERT_CONDITION);
 	}
 
 	block = (struct capwap_memory_block*)((char*)p - sizeof(struct capwap_memory_block));
 	if (block->item != p) {
-		log_printf(LOG_DEBUG, "%s(%d): Invalid pointer", file, line);
+		capwap_logging_debug("%s(%d): Invalid pointer", file, line);
 		exit(CAPWAP_ASSERT_CONDITION);
 	}
 
@@ -107,7 +107,7 @@ void capwap_free_debug(void* p, const char* file, const int line) {
 		findblock = findblock->next;
 	}
 	
-	log_printf(LOG_DEBUG, "%s(%d): Unable to find memory block", file, line);
+	capwap_logging_debug("%s(%d): Unable to find memory block", file, line);
 }
 
 /* Dump memory alloced */
@@ -119,8 +119,7 @@ void capwap_dump_memory(void) {
 
 	findblock = g_memoryblocks;
 	while (findblock != NULL) {
-		log_printf(LOG_DEBUG, "%s(%d): block at %p, %zu bytes long",
+		capwap_logging_debug("%s(%d): block at %p, %d bytes long", findblock->file, findblock->line, findblock->item, findblock->size);
-				     findblock->file, findblock->line, findblock->item, findblock->size);
 
 #ifdef USE_DEBUG_BACKTRACE
 		backtrace_functions = backtrace_symbols(findblock->backtrace, findblock->backtrace_count);
@@ -129,7 +128,7 @@ void capwap_dump_memory(void) {
 
 			/* Skipping capwap_alloc_debug function print out */
 			for (j = 1; j < findblock->backtrace_count; j++) {
-				log_printf(LOG_DEBUG, "\t%s", backtrace_functions[j]);
+				capwap_logging_debug("\t%s", backtrace_functions[j]);
 			}
 
 			free(backtrace_functions);
@@ -144,9 +143,9 @@ void capwap_dump_memory(void) {
 /* Check if all memory is free */
 int capwap_check_memory_leak(int verbose) {
 	if ((g_memoryblocks != NULL) && (verbose != 0)) {
-		log_printf(LOG_DEBUG, "*** Detected memory leaks ! ***");
+		capwap_logging_debug("*** Detected memory leaks ! ***");
 		capwap_dump_memory();
-		log_printf(LOG_DEBUG, "*******************************");
+		capwap_logging_debug("*******************************");
 	}
 
 	return ((g_memoryblocks != NULL) ? 1 : 0);
@@ -168,7 +167,7 @@ void capwap_backtrace_callstack(void) {
 
 			/* Skipping capwap_backtrace_callstack function print out */
 			for (i = 1; i < count; i++) {
-				log_printf(LOG_DEBUG, "\t%s", functions[i]);
+				capwap_logging_debug("\t%s", functions[i]);
 			}
 
 			free(functions);

src/common/capwap_debug.h

@@ -1,12 +1,9 @@
 #ifndef __CAPWAP_DEBUG_HEADER__
 #define __CAPWAP_DEBUG_HEADER__
 
-#define MACSTR "%02x:%02x:%02x:%02x:%02x:%02x"
-#define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
-
 #ifdef DEBUG
 
-#define ASSERT(expr)				if (!(expr)) { log_printf(LOG_EMERG, "Assertion failed \'%s\': %s(%d)", #expr, __FILE__, __LINE__); capwap_exit(CAPWAP_ASSERT_CONDITION); }
+#define ASSERT(expr)				if (!(expr)) { capwap_logging_fatal("Assertion failed \'%s\': %s(%d)", #expr, __FILE__, __LINE__); capwap_exit(CAPWAP_ASSERT_CONDITION); }
 
 /* Custom memory management */
 #define capwap_alloc(x)				capwap_alloc_debug(x, __FILE__, __LINE__)
@@ -32,7 +29,7 @@ void capwap_backtrace_callstack(void);
 /* Standard memory management */
 #define capwap_alloc(l)					({ void* __x = malloc(l); if (!__x) capwap_outofmemory(); __x; })
 #define capwap_free(x)					free(x)
-#define capwap_check_memory_leak(x)			(0)
+#define capwap_check_memory_leak(x)
 #define capwap_dump_memory()
 #define capwap_backtrace_callstack()
 

src/common/capwap_dtls.c

@@ -33,7 +33,7 @@ static int capwap_bio_method_recv(WOLFSSL* ssl, char* buffer, int length, void*
 	/* Check DTLS Capwap Preamble */
 	dtlspreamble = (struct capwap_dtls_header*)dtls->buffer;
 	if ((dtlspreamble->preamble.version != CAPWAP_PROTOCOL_VERSION) || (dtlspreamble->preamble.type != CAPWAP_PREAMBLE_DTLS_HEADER)) {
-		log_printf(LOG_DEBUG, "Wrong DTLS Capwap Preamble");
+		capwap_logging_debug("Wrong DTLS Capwap Preamble");
 		return WOLFSSL_CBIO_ERR_GENERAL;		/* Wrong DTLS Capwap Preamble */
 	}
 
@@ -75,7 +75,7 @@ static int capwap_bio_method_send(WOLFSSL* ssl, char* buffer, int length, void*
 	/* Send packet */
 	err = capwap_sendto(dtls->sock, data, length + sizeof(struct capwap_dtls_header), &dtls->peeraddr);
 	if (err <= 0) {
-		log_printf(LOG_WARNING, "Unable to send crypt packet, sentto return error %d", err);
+		capwap_logging_warning("Unable to send crypt packet, sentto return error %d", err);
 		return WOLFSSL_CBIO_ERR_GENERAL;
 	}
 
@@ -236,7 +236,7 @@ int capwap_crypt_createcontext(struct capwap_dtls_context* dtlscontext, struct c
 	/* Alloc context */
 	dtlscontext->sslcontext = (void*)wolfSSL_CTX_new(((param->type == CAPWAP_DTLS_SERVER) ? wolfDTLSv1_server_method() : wolfDTLSv1_client_method()));
 	if (!dtlscontext->sslcontext) {
-		log_printf(LOG_DEBUG, "Error to initialize dtls context");
+		capwap_logging_debug("Error to initialize dtls context");
 		return 0;
 	}
 
@@ -249,42 +249,42 @@ int capwap_crypt_createcontext(struct capwap_dtls_context* dtlscontext, struct c
 	if (dtlscontext->mode == CAPWAP_DTLS_MODE_CERTIFICATE) {
 		/* Check context */
 		if (!param->cert.filecert || !strlen(param->cert.filecert)) {
-			log_printf(LOG_DEBUG, "Error, request certificate file");
+			capwap_logging_debug("Error, request certificate file");
 			capwap_crypt_freecontext(dtlscontext);
 			return 0;
 		} else if (!param->cert.filekey || !strlen(param->cert.filekey)) {
-			log_printf(LOG_DEBUG, "Error, request privatekey file");
+			capwap_logging_debug("Error, request privatekey file");
 			capwap_crypt_freecontext(dtlscontext);
 			return 0;
 		} else if (!param->cert.fileca || !strlen(param->cert.fileca)) {
-			log_printf(LOG_DEBUG, "Error, request ca file");
+			capwap_logging_debug("Error, request ca file");
 			capwap_crypt_freecontext(dtlscontext);
 			return 0;
 		}
 
 		/* Public certificate */
 		if (!wolfSSL_CTX_use_certificate_file((WOLFSSL_CTX*)dtlscontext->sslcontext, param->cert.filecert, SSL_FILETYPE_PEM)) {
-			log_printf(LOG_DEBUG, "Error to load certificate file");
+			capwap_logging_debug("Error to load certificate file");
 			capwap_crypt_freecontext(dtlscontext);
 			return 0;
 		}
 
 		/* Private key */
 		if (!wolfSSL_CTX_use_PrivateKey_file((WOLFSSL_CTX*)dtlscontext->sslcontext, param->cert.filekey, SSL_FILETYPE_PEM)) {
-			log_printf(LOG_DEBUG, "Error to load private key file");
+			capwap_logging_debug("Error to load private key file");
 			capwap_crypt_freecontext(dtlscontext);
 			return 0;
 		}
 
 		if (!wolfSSL_CTX_check_private_key((WOLFSSL_CTX*)dtlscontext->sslcontext)) {
-			log_printf(LOG_DEBUG, "Error to check private key");
+			capwap_logging_debug("Error to check private key");
 			capwap_crypt_freecontext(dtlscontext);
 			return 0;
 		}
 
 		/* Certificate Authority */
 		if (!wolfSSL_CTX_load_verify_locations((WOLFSSL_CTX*)dtlscontext->sslcontext, param->cert.fileca, NULL)) {
-			log_printf(LOG_DEBUG, "Error to load ca file");
+			capwap_logging_debug("Error to load ca file");
 			capwap_crypt_freecontext(dtlscontext);
 			return 0;
 		}
@@ -299,7 +299,7 @@ int capwap_crypt_createcontext(struct capwap_dtls_context* dtlscontext, struct c
 				TLS_DHE_RSA_WITH_AES_256_CBC_SHA
 		*/
 		if (!wolfSSL_CTX_set_cipher_list((WOLFSSL_CTX*)dtlscontext->sslcontext, "AES128-SHA:DHE-RSA-AES128-SHA:AES256-SHA:DHE-RSA-AES256-SHA")) {
-			log_printf(LOG_DEBUG, "Error to select cipher list");
+			capwap_logging_debug("Error to select cipher list");
 			capwap_crypt_freecontext(dtlscontext);
 			return 0;
 		}
@@ -311,7 +311,7 @@ int capwap_crypt_createcontext(struct capwap_dtls_context* dtlscontext, struct c
 				TLS_DHE_PSK_WITH_AES_256_CBC_SHA
 		*/
 		if (!wolfSSL_CTX_set_cipher_list((WOLFSSL_CTX*)dtlscontext->sslcontext, "PSK-AES128-CBC-SHA:PSK-AES256-CBC-SHA")) {
-			log_printf(LOG_DEBUG, "Error to select cipher list");
+			capwap_logging_debug("Error to select cipher list");
 			capwap_crypt_freecontext(dtlscontext);
 			return 0;
 		}
@@ -321,7 +321,7 @@ int capwap_crypt_createcontext(struct capwap_dtls_context* dtlscontext, struct c
 			if (param->presharedkey.hint) {
 				wolfSSL_CTX_use_psk_identity_hint((WOLFSSL_CTX*)dtlscontext->sslcontext, param->presharedkey.hint);
 			} else {
-				log_printf(LOG_DEBUG, "Error to presharedkey hint");
+				capwap_logging_debug("Error to presharedkey hint");
 				capwap_crypt_freecontext(dtlscontext);
 				return 0;
 			}
@@ -331,7 +331,7 @@ int capwap_crypt_createcontext(struct capwap_dtls_context* dtlscontext, struct c
 		dtlscontext->presharedkey.identity = capwap_duplicate_string(param->presharedkey.identity);
 		dtlscontext->presharedkey.pskkeylength = capwap_crypt_psk_to_bin(param->presharedkey.pskkey, &dtlscontext->presharedkey.pskkey);
 		if (!dtlscontext->presharedkey.pskkeylength) {
-			log_printf(LOG_DEBUG, "Error to presharedkey");
+			capwap_logging_debug("Error to presharedkey");
 			capwap_crypt_freecontext(dtlscontext);
 			return 0;
 		}
@@ -343,7 +343,7 @@ int capwap_crypt_createcontext(struct capwap_dtls_context* dtlscontext, struct c
 			wolfSSL_CTX_set_psk_client_callback((WOLFSSL_CTX*)dtlscontext->sslcontext, capwap_crypt_psk_client);
 		}
 	} else {
-		log_printf(LOG_DEBUG, "Invalid DTLS mode");
+		capwap_logging_debug("Invalid DTLS mode");
 		capwap_crypt_freecontext(dtlscontext);
 		return 0;
 	}
@@ -383,7 +383,7 @@ int capwap_crypt_createsession(struct capwap_dtls* dtls, struct capwap_dtls_cont
 	/* Create ssl session */
 	dtls->sslsession = (void*)wolfSSL_new((WOLFSSL_CTX*)dtlscontext->sslcontext);
 	if (!dtls->sslsession) {
-		log_printf(LOG_DEBUG, "Error to initialize dtls session");
+		capwap_logging_debug("Error to initialize dtls session");
 		return 0;
 	}
 
@@ -498,7 +498,7 @@ int capwap_crypt_sendto(struct capwap_dtls* dtls, void* buffer, int size) {
 	if (!dtls->enable) {
 		err = capwap_sendto(dtls->sock, buffer, size, &dtls->peeraddr);
 		if (err <= 0) {
-			log_printf(LOG_WARNING, "Unable to send plain packet, sentto return error %d", err);
+			capwap_logging_warning("Unable to send plain packet, sentto return error %d", err);
 		}
 
 		return err;
@@ -535,7 +535,7 @@ int capwap_crypt_sendto_fragmentpacket(struct capwap_dtls* dtls, struct capwap_l
 
 		err = capwap_crypt_sendto(dtls, fragmentpacket->buffer, fragmentpacket->offset);
 		if (err <= 0) {
-			log_printf(LOG_WARNING, "Unable to send crypt fragment, sentto return error %d", err);
+			capwap_logging_warning("Unable to send crypt fragment, sentto return error %d", err);
 			return 0;
 		}
 
@@ -572,7 +572,7 @@ int capwap_decrypt_packet(struct capwap_dtls* dtls, void* encrybuffer, int size,
 	/* */	
 	if (dtls->action == CAPWAP_DTLS_ACTION_HANDSHAKE) {
 		if (capwap_crypt_handshake(dtls) == CAPWAP_HANDSHAKE_ERROR) {
-			log_printf(LOG_DEBUG, "Error in DTLS handshake");
+			capwap_logging_debug("Error in DTLS handshake");
 			result = CAPWAP_ERROR_CLOSE;			/* Error handshake */
 		} else {
 			result = CAPWAP_ERROR_AGAIN;			/* Don't parsing DTLS packet */

src/common/capwap_element.c

@@ -4,131 +4,136 @@
 #include "capwap_array.h"
 
 /* */
-#define element_ops(Id, Ops) [(Id) - CAPWAP_MESSAGE_ELEMENTS_START] = &(Ops)
+int capwap_get_message_element_category(uint16_t type) {
-static const struct capwap_message_elements_ops * capwap_message_elements[] = {
+	switch (type) {
-	element_ops(CAPWAP_ELEMENT_ACDESCRIPTION_TYPE,			capwap_element_acdescriptor_ops),
+		case CAPWAP_ELEMENT_ACNAMEPRIORITY:
-	element_ops(CAPWAP_ELEMENT_ACIPV4LIST_TYPE,			capwap_element_acipv4list_ops),
+		case CAPWAP_ELEMENT_CONTROLIPV4:
-	element_ops(CAPWAP_ELEMENT_ACIPV6LIST_TYPE,			capwap_element_acipv6list_ops),
+		case CAPWAP_ELEMENT_CONTROLIPV6:
-	element_ops(CAPWAP_ELEMENT_ACNAME_TYPE,				capwap_element_acname_ops),
+		case CAPWAP_ELEMENT_DECRYPTERRORREPORTPERIOD:
-	element_ops(CAPWAP_ELEMENT_ACNAMEPRIORITY_TYPE,			capwap_element_acnamepriority_ops),
+		case CAPWAP_ELEMENT_RADIOADMSTATE:
-	element_ops(CAPWAP_ELEMENT_ACTIMESTAMP_TYPE,			capwap_element_actimestamp_ops),
+		case CAPWAP_ELEMENT_RADIOOPRSTATE:
-	element_ops(CAPWAP_ELEMENT_ADDMACACL_TYPE,			capwap_element_addmacacl_ops),
+		case CAPWAP_ELEMENT_RETURNEDMESSAGE:
-	element_ops(CAPWAP_ELEMENT_ADDSTATION_TYPE,			capwap_element_addstation_ops),
+		case CAPWAP_ELEMENT_VENDORPAYLOAD:
-	element_ops(CAPWAP_ELEMENT_CONTROLIPV4_TYPE,			capwap_element_controlipv4_ops),
+		case CAPWAP_ELEMENT_80211_ANTENNA:
-	element_ops(CAPWAP_ELEMENT_CONTROLIPV6_TYPE,			capwap_element_controlipv6_ops),
+		case CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL:
-	element_ops(CAPWAP_ELEMENT_TIMERS_TYPE,				capwap_element_timers_ops),
+		case CAPWAP_ELEMENT_80211_IE:
-	element_ops(CAPWAP_ELEMENT_DATATRANSFERDATA_TYPE,		capwap_element_datatransferdata_ops),
+		case CAPWAP_ELEMENT_80211_MACOPERATION:
-	element_ops(CAPWAP_ELEMENT_DATATRANSFERMODE_TYPE,		capwap_element_datatransfermode_ops),
+		case CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY:
-	element_ops(CAPWAP_ELEMENT_DECRYPTERRORREPORT_TYPE,		capwap_element_decrypterrorreport_ops),
+		case CAPWAP_ELEMENT_80211_OFDMCONTROL:
-	element_ops(CAPWAP_ELEMENT_DECRYPTERRORREPORTPERIOD_TYPE,	capwap_element_decrypterrorreportperiod_ops),
+		case CAPWAP_ELEMENT_80211_RATESET:
-	element_ops(CAPWAP_ELEMENT_DELETEMACACL_TYPE,			capwap_element_deletemacacl_ops),
+		case CAPWAP_ELEMENT_80211_STATISTICS:
-	element_ops(CAPWAP_ELEMENT_DELETESTATION_TYPE,			capwap_element_deletestation_ops),
+		case CAPWAP_ELEMENT_80211_SUPPORTEDRATES:
-	element_ops(CAPWAP_ELEMENT_DISCOVERYTYPE_TYPE,			capwap_element_discoverytype_ops),
+		case CAPWAP_ELEMENT_80211_TXPOWER:
-	element_ops(CAPWAP_ELEMENT_DUPLICATEIPV4_TYPE,			capwap_element_duplicateipv4_ops),
+		case CAPWAP_ELEMENT_80211_TXPOWERLEVEL:
-	element_ops(CAPWAP_ELEMENT_DUPLICATEIPV6_TYPE,			capwap_element_duplicateipv6_ops),
+		case CAPWAP_ELEMENT_80211_WTP_QOS:
-	element_ops(CAPWAP_ELEMENT_IDLETIMEOUT_TYPE,			capwap_element_idletimeout_ops),
+		case CAPWAP_ELEMENT_80211_WTP_RADIO_CONF:
-	element_ops(CAPWAP_ELEMENT_IMAGEDATA_TYPE,			capwap_element_imagedata_ops),
+		case CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION: {
-	element_ops(CAPWAP_ELEMENT_IMAGEIDENTIFIER_TYPE,		capwap_element_imageidentifier_ops),
+			return CAPWAP_MESSAGE_ELEMENT_ARRAY;
-	element_ops(CAPWAP_ELEMENT_IMAGEINFO_TYPE,			capwap_element_imageinfo_ops),
-	element_ops(CAPWAP_ELEMENT_INITIATEDOWNLOAD_TYPE,		capwap_element_initdownload_ops),
-	element_ops(CAPWAP_ELEMENT_LOCATION_TYPE,			capwap_element_location_ops),
-	element_ops(CAPWAP_ELEMENT_MAXIMUMLENGTH_TYPE,			capwap_element_maximumlength_ops),
-	element_ops(CAPWAP_ELEMENT_LOCALIPV4_TYPE,			capwap_element_localipv4_ops),
-	element_ops(CAPWAP_ELEMENT_RADIOADMSTATE_TYPE,			capwap_element_radioadmstate_ops),
-	element_ops(CAPWAP_ELEMENT_RADIOOPRSTATE_TYPE,			capwap_element_radiooprstate_ops),
-	element_ops(CAPWAP_ELEMENT_RESULTCODE_TYPE,			capwap_element_resultcode_ops),
-	element_ops(CAPWAP_ELEMENT_RETURNEDMESSAGE_TYPE,		capwap_element_returnedmessage_ops),
-	element_ops(CAPWAP_ELEMENT_SESSIONID_TYPE,			capwap_element_sessionid_ops),
-	element_ops(CAPWAP_ELEMENT_STATISTICSTIMER_TYPE,		capwap_element_statisticstimer_ops),
-	element_ops(CAPWAP_ELEMENT_VENDORPAYLOAD_TYPE,			capwap_element_vendorpayload_ops),
-	element_ops(CAPWAP_ELEMENT_WTPBOARDDATA_TYPE,			capwap_element_wtpboarddata_ops),
-	element_ops(CAPWAP_ELEMENT_WTPDESCRIPTOR_TYPE,			capwap_element_wtpdescriptor_ops),
-	element_ops(CAPWAP_ELEMENT_WTPFALLBACK_TYPE,			capwap_element_wtpfallback_ops),
-	element_ops(CAPWAP_ELEMENT_WTPFRAMETUNNELMODE_TYPE,		capwap_element_wtpframetunnelmode_ops),
-	element_ops(CAPWAP_ELEMENT_WTPMACTYPE_TYPE,			capwap_element_wtpmactype_ops),
-	element_ops(CAPWAP_ELEMENT_WTPNAME_TYPE,			capwap_element_wtpname_ops),
-	element_ops(CAPWAP_ELEMENT_WTPRADIOSTAT_TYPE,			capwap_element_wtpradiostat_ops),
-	element_ops(CAPWAP_ELEMENT_WTPREBOOTSTAT_TYPE,			capwap_element_wtprebootstat_ops),
-	element_ops(CAPWAP_ELEMENT_WTPSTATICIPADDRESS_TYPE,		capwap_element_wtpstaticipaddress_ops),
-	element_ops(CAPWAP_ELEMENT_LOCALIPV6_TYPE,			capwap_element_localipv6_ops),
-	element_ops(CAPWAP_ELEMENT_TRANSPORT_TYPE,			capwap_element_transport_ops),
-	element_ops(CAPWAP_ELEMENT_MTUDISCOVERY_TYPE,			capwap_element_mtudiscovery_ops),
-	element_ops(CAPWAP_ELEMENT_ECNSUPPORT_TYPE,			capwap_element_ecnsupport_ops)
-};
-#undef element_ops
-
-/* */
-#define element_ops(Id, Ops) [(Id) - CAPWAP_80211_MESSAGE_ELEMENTS_START] = &(Ops)
-static const struct capwap_message_elements_ops * capwap_80211_message_elements[] = {
-	element_ops(CAPWAP_ELEMENT_80211_ADD_WLAN_TYPE,				capwap_element_80211_addwlan_ops),
-	element_ops(CAPWAP_ELEMENT_80211_ANTENNA_TYPE,				capwap_element_80211_antenna_ops),
-	element_ops(CAPWAP_ELEMENT_80211_ASSIGN_BSSID_TYPE,			capwap_element_80211_assignbssid_ops),
-	element_ops(CAPWAP_ELEMENT_80211_DELETE_WLAN_TYPE,			capwap_element_80211_deletewlan_ops),
-	element_ops(CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL_TYPE,		capwap_element_80211_directsequencecontrol_ops),
-	element_ops(CAPWAP_ELEMENT_80211_IE_TYPE,				capwap_element_80211_ie_ops),
-	element_ops(CAPWAP_ELEMENT_80211_MACOPERATION_TYPE,			capwap_element_80211_macoperation_ops),
-	element_ops(CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES_TYPE,		capwap_element_80211_miccountermeasures_ops),
-	element_ops(CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY_TYPE,		capwap_element_80211_multidomaincapability_ops),
-	element_ops(CAPWAP_ELEMENT_80211_OFDMCONTROL_TYPE,			capwap_element_80211_ofdmcontrol_ops),
-	element_ops(CAPWAP_ELEMENT_80211_RATESET_TYPE,				capwap_element_80211_rateset_ops),
-	element_ops(CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT_TYPE,		capwap_element_80211_rsnaerrorreport_ops),
-	element_ops(CAPWAP_ELEMENT_80211_STATION_TYPE,				capwap_element_80211_station_ops),
-	element_ops(CAPWAP_ELEMENT_80211_STATION_QOS_PROFILE_TYPE,		capwap_element_80211_stationqos_ops),
-	element_ops(CAPWAP_ELEMENT_80211_STATION_SESSION_KEY_PROFILE_TYPE,	capwap_element_80211_stationkey_ops),
-	element_ops(CAPWAP_ELEMENT_80211_STATISTICS_TYPE,			capwap_element_80211_statistics_ops),
-	element_ops(CAPWAP_ELEMENT_80211_SUPPORTEDRATES_TYPE,			capwap_element_80211_supportedrates_ops),
-	element_ops(CAPWAP_ELEMENT_80211_TXPOWER_TYPE,				capwap_element_80211_txpower_ops),
-	element_ops(CAPWAP_ELEMENT_80211_TXPOWERLEVEL_TYPE,			capwap_element_80211_txpowerlevel_ops),
-	element_ops(CAPWAP_ELEMENT_80211_UPDATE_STATION_QOS_TYPE,		capwap_element_80211_updatestationqos_ops),
-	element_ops(CAPWAP_ELEMENT_80211_UPDATE_WLAN_TYPE,			capwap_element_80211_updatewlan_ops),
-	element_ops(CAPWAP_ELEMENT_80211_WTP_QOS_TYPE,				capwap_element_80211_wtpqos_ops),
-	element_ops(CAPWAP_ELEMENT_80211_WTP_RADIO_CONF_TYPE,			capwap_element_80211_wtpradioconf_ops),
-	element_ops(CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM_TYPE,		capwap_element_80211_wtpradiofailalarm_ops),
-	element_ops(CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION_TYPE,		capwap_element_80211_wtpradioinformation_ops)
-};
-#undef element_ops
-
-/* */
-#define element_ops(Id, Ops) [(Id) - 1] = &(Ops)
-static const struct capwap_message_elements_ops * capwap_vendor_travelping_message_elements[] = {
-	element_ops(CAPWAP_ELEMENT_80211N_RADIO_CONF_TYPE,	capwap_element_80211n_radioconf_ops),
-	element_ops(CAPWAP_ELEMENT_80211N_STATION_INFO_TYPE,	capwap_element_80211n_station_info_ops)
-};
-#undef element_ops
-
-/* */
-const struct capwap_message_elements_ops *
-capwap_get_message_element_ops(const struct capwap_message_element_id id)
-{
-#define ARRAY_SIZE(x)  (sizeof((x)) / sizeof((x)[0]))
-
-	switch (id.vendor) {
-	case 0:
-		if (id.type >= CAPWAP_MESSAGE_ELEMENTS_START &&
-		    id.type - CAPWAP_MESSAGE_ELEMENTS_START < ARRAY_SIZE(capwap_message_elements)) {
-			return capwap_message_elements[id.type - CAPWAP_MESSAGE_ELEMENTS_START];
 		}
-		else if (id.type >= CAPWAP_80211_MESSAGE_ELEMENTS_START &&
-			 id.type - CAPWAP_80211_MESSAGE_ELEMENTS_START < ARRAY_SIZE(capwap_80211_message_elements)) {
-			return capwap_80211_message_elements[id.type - CAPWAP_80211_MESSAGE_ELEMENTS_START];
-		}
-		break;
-
-	case CAPWAP_VENDOR_TRAVELPING_ID:
-		if (id.type >= 1 &&
-		    id.type - 1 < ARRAY_SIZE(capwap_vendor_travelping_message_elements))
-			return capwap_vendor_travelping_message_elements[id.type - 1];
-		break;
 	}
 
-	return NULL;
+	return CAPWAP_MESSAGE_ELEMENT_SINGLE;
-#undef ARRAY_SIZE
 }
 
 /* */
-struct capwap_list_item* capwap_get_message_element(struct capwap_parsed_packet* packet,
+static struct capwap_message_elements_ops* capwap_message_elements[] = {
-						    const struct capwap_message_element_id id)
+	/* CAPWAP_ELEMENT_ACDESCRIPTION */ &capwap_element_acdescriptor_ops,
-{
+	/* CAPWAP_ELEMENT_ACIPV4LIST */ &capwap_element_acipv4list_ops,
+	/* CAPWAP_ELEMENT_ACIPV6LIST */ &capwap_element_acipv6list_ops,
+	/* CAPWAP_ELEMENT_ACNAME */ &capwap_element_acname_ops,
+	/* CAPWAP_ELEMENT_ACNAMEPRIORITY */ &capwap_element_acnamepriority_ops,
+	/* CAPWAP_ELEMENT_ACTIMESTAMP */ &capwap_element_actimestamp_ops,
+	/* CAPWAP_ELEMENT_ADDMACACL */ &capwap_element_addmacacl_ops,
+	/* CAPWAP_ELEMENT_ADDSTATION */ &capwap_element_addstation_ops,
+	/* Reserved */ NULL,
+	/* CAPWAP_ELEMENT_CONTROLIPV4 */ &capwap_element_controlipv4_ops,
+	/* CAPWAP_ELEMENT_CONTROLIPV6 */ &capwap_element_controlipv6_ops,
+	/* CAPWAP_ELEMENT_TIMERS */ &capwap_element_timers_ops,
+	/* CAPWAP_ELEMENT_DATATRANSFERDATA */ &capwap_element_datatransferdata_ops,
+	/* CAPWAP_ELEMENT_DATATRANSFERMODE */ &capwap_element_datatransfermode_ops,
+	/* CAPWAP_ELEMENT_DECRYPTERRORREPORT */ &capwap_element_decrypterrorreport_ops,
+	/* CAPWAP_ELEMENT_DECRYPTERRORREPORTPERIOD */ &capwap_element_decrypterrorreportperiod_ops,
+	/* CAPWAP_ELEMENT_DELETEMACACL */ &capwap_element_deletemacacl_ops,
+	/* CAPWAP_ELEMENT_DELETESTATION */ &capwap_element_deletestation_ops,
+	/* Reserved */ NULL,
+	/* CAPWAP_ELEMENT_DISCOVERYTYPE */ &capwap_element_discoverytype_ops,
+	/* CAPWAP_ELEMENT_DUPLICATEIPV4 */ &capwap_element_duplicateipv4_ops,
+	/* CAPWAP_ELEMENT_DUPLICATEIPV6 */ &capwap_element_duplicateipv6_ops,
+	/* CAPWAP_ELEMENT_IDLETIMEOUT */ &capwap_element_idletimeout_ops,
+	/* CAPWAP_ELEMENT_IMAGEDATA */ &capwap_element_imagedata_ops,
+	/* CAPWAP_ELEMENT_IMAGEIDENTIFIER */ &capwap_element_imageidentifier_ops,
+	/* CAPWAP_ELEMENT_IMAGEINFO */ &capwap_element_imageinfo_ops,
+	/* CAPWAP_ELEMENT_INITIATEDOWNLOAD */ &capwap_element_initdownload_ops,
+	/* CAPWAP_ELEMENT_LOCATION */ &capwap_element_location_ops,
+	/* CAPWAP_ELEMENT_MAXIMUMLENGTH */ &capwap_element_maximumlength_ops,
+	/* CAPWAP_ELEMENT_LOCALIPV4 */ &capwap_element_localipv4_ops,
+	/* CAPWAP_ELEMENT_RADIOADMSTATE */ &capwap_element_radioadmstate_ops,
+	/* CAPWAP_ELEMENT_RADIOOPRSTATE */ &capwap_element_radiooprstate_ops,
+	/* CAPWAP_ELEMENT_RESULTCODE */ &capwap_element_resultcode_ops,
+	/* CAPWAP_ELEMENT_RETURNEDMESSAGE */ &capwap_element_returnedmessage_ops,
+	/* CAPWAP_ELEMENT_SESSIONID */ &capwap_element_sessionid_ops,
+	/* CAPWAP_ELEMENT_STATISTICSTIMER */ &capwap_element_statisticstimer_ops,
+	/* CAPWAP_ELEMENT_VENDORPAYLOAD */ &capwap_element_vendorpayload_ops,
+	/* CAPWAP_ELEMENT_WTPBOARDDATA */ &capwap_element_wtpboarddata_ops,
+	/* CAPWAP_ELEMENT_WTPDESCRIPTOR */ &capwap_element_wtpdescriptor_ops,
+	/* CAPWAP_ELEMENT_WTPFALLBACK */ &capwap_element_wtpfallback_ops,
+	/* CAPWAP_ELEMENT_WTPFRAMETUNNELMODE */ &capwap_element_wtpframetunnelmode_ops,
+	/* Reserved */ NULL,
+	/* Reserved */ NULL,
+	/* CAPWAP_ELEMENT_WTPMACTYPE */ &capwap_element_wtpmactype_ops,
+	/* CAPWAP_ELEMENT_WTPNAME */ &capwap_element_wtpname_ops,
+	/* Reserved */ NULL,
+	/* CAPWAP_ELEMENT_WTPRADIOSTAT */ &capwap_element_wtpradiostat_ops,
+	/* CAPWAP_ELEMENT_WTPREBOOTSTAT */ &capwap_element_wtprebootstat_ops,
+	/* CAPWAP_ELEMENT_WTPSTATICIPADDRESS */ &capwap_element_wtpstaticipaddress_ops,
+	/* CAPWAP_ELEMENT_LOCALIPV6 */ &capwap_element_localipv6_ops,
+	/* CAPWAP_ELEMENT_TRANSPORT */ &capwap_element_transport_ops,
+	/* CAPWAP_ELEMENT_MTUDISCOVERY */ &capwap_element_mtudiscovery_ops,
+	/* CAPWAP_ELEMENT_ECNSUPPORT */ &capwap_element_ecnsupport_ops
+};
+
+/* */
+static struct capwap_message_elements_ops* capwap_80211_message_elements[] = {
+	/* CAPWAP_ELEMENT_80211_ADD_WLAN */ &capwap_element_80211_addwlan_ops,
+	/* CAPWAP_ELEMENT_80211_ANTENNA */ &capwap_element_80211_antenna_ops,
+	/* CAPWAP_ELEMENT_80211_ASSIGN_BSSID */ &capwap_element_80211_assignbssid_ops,
+	/* CAPWAP_ELEMENT_80211_DELETE_WLAN */ &capwap_element_80211_deletewlan_ops,
+	/* CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL */ &capwap_element_80211_directsequencecontrol_ops,
+	/* CAPWAP_ELEMENT_80211_IE */ &capwap_element_80211_ie_ops,
+	/* CAPWAP_ELEMENT_80211_MACOPERATION */ &capwap_element_80211_macoperation_ops,
+	/* CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES */ &capwap_element_80211_miccountermeasures_ops,
+	/* CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY */ &capwap_element_80211_multidomaincapability_ops,
+	/* CAPWAP_ELEMENT_80211_OFDMCONTROL */ &capwap_element_80211_ofdmcontrol_ops,
+	/* CAPWAP_ELEMENT_80211_RATESET */ &capwap_element_80211_rateset_ops,
+	/* CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT */ &capwap_element_80211_rsnaerrorreport_ops,
+	/* CAPWAP_ELEMENT_80211_STATION */ &capwap_element_80211_station_ops,
+	/* CAPWAP_ELEMENT_80211_STATION_QOS_PROFILE */ &capwap_element_80211_stationqos_ops,
+	/* CAPWAP_ELEMENT_80211_STATION_SESSION_KEY_PROFILE */ &capwap_element_80211_stationkey_ops,
+	/* CAPWAP_ELEMENT_80211_STATISTICS */ &capwap_element_80211_statistics_ops,
+	/* CAPWAP_ELEMENT_80211_SUPPORTEDRATES */ &capwap_element_80211_supportedrates_ops,
+	/* CAPWAP_ELEMENT_80211_TXPOWER */ &capwap_element_80211_txpower_ops,
+	/* CAPWAP_ELEMENT_80211_TXPOWERLEVEL */ &capwap_element_80211_txpowerlevel_ops,
+	/* CAPWAP_ELEMENT_80211_UPDATE_STATION_QOS */ &capwap_element_80211_updatestationqos_ops,
+	/* CAPWAP_ELEMENT_80211_UPDATE_WLAN */ &capwap_element_80211_updatewlan_ops,
+	/* CAPWAP_ELEMENT_80211_WTP_QOS */ &capwap_element_80211_wtpqos_ops,
+	/* CAPWAP_ELEMENT_80211_WTP_RADIO_CONF */ &capwap_element_80211_wtpradioconf_ops,
+	/* CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM */ &capwap_element_80211_wtpradiofailalarm_ops,
+	/* CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION */ &capwap_element_80211_wtpradioinformation_ops
+};
+
+/* */
+struct capwap_message_elements_ops* capwap_get_message_element_ops(unsigned short code) {
+	if (IS_MESSAGE_ELEMENTS(code)) {
+		return capwap_message_elements[code - CAPWAP_MESSAGE_ELEMENTS_START];
+	} else if (IS_80211_MESSAGE_ELEMENTS(code)) {
+		return capwap_80211_message_elements[code - CAPWAP_80211_MESSAGE_ELEMENTS_START];
+	}
+	
+	return NULL;
+}
+
+/* */
+struct capwap_list_item* capwap_get_message_element(struct capwap_parsed_packet* packet, uint16_t type) {
 	struct capwap_list_item* search;
 
 	ASSERT(packet != NULL);
@@ -136,10 +141,11 @@ struct capwap_list_item* capwap_get_message_element(struct capwap_parsed_packet*
 
 	search = packet->messages->first;
 	while (search) {
-		struct capwap_message_element_itemlist* messageelement =
+		struct capwap_message_element_itemlist* messageelement = (struct capwap_message_element_itemlist*)search->item;
-			(struct capwap_message_element_itemlist*)search->item;
+
-		if ((id.vendor == messageelement->id.vendor) && (id.type == messageelement->id.type))
+		if (messageelement->type == type) {
 			return search;
+		}
 
 		/* */
 		search = search->next;
@@ -149,14 +155,12 @@ struct capwap_list_item* capwap_get_message_element(struct capwap_parsed_packet*
 }
 
 /* */
-void* capwap_get_message_element_data(struct capwap_parsed_packet* packet,
+void* capwap_get_message_element_data(struct capwap_parsed_packet* packet, uint16_t type) {
-				      const struct capwap_message_element_id id)
-{
 	struct capwap_list_item* itemlist;
 	struct capwap_message_element_itemlist* messageelement;
 
 	/* Retrieve item list */
-	itemlist = capwap_get_message_element(packet, id);
+	itemlist = capwap_get_message_element(packet, type);
 	if (!itemlist) {
 		return NULL;
 	}
@@ -189,75 +193,53 @@ int capwap_parsing_packet(struct capwap_packet_rxmng* rxmngpacket, struct capwap
 	/* */
 	bodylength = rxmngpacket->ctrlmsg.length - CAPWAP_CONTROL_MESSAGE_MIN_LENGTH;
 	while (bodylength > 0) {
-		struct capwap_message_element_id id = { .vendor = 0 };
+		uint16_t type;
 		uint16_t msglength;
+		int category;
 		struct capwap_list_item* itemlist;
 		struct capwap_message_element_itemlist* messageelement;
-		void *element;
+		struct capwap_message_elements_ops* read_ops;
-		const struct capwap_message_elements_ops* read_ops;
 
 		/* Get type and length */
 		rxmngpacket->readerpacketallowed = sizeof(struct capwap_message_element);
-		if (rxmngpacket->read_ops.read_u16((capwap_message_elements_handle)rxmngpacket, &id.type) != sizeof(uint16_t) ||
+		if (rxmngpacket->read_ops.read_u16((capwap_message_elements_handle)rxmngpacket, &type) != sizeof(uint16_t)) {
-		    rxmngpacket->read_ops.read_u16((capwap_message_elements_handle)rxmngpacket, &msglength) != sizeof(uint16_t) ||
-		    msglength > bodylength)
 			return INVALID_MESSAGE_ELEMENT;
+		}
+
+		/* Check type */
+		capwap_logging_debug("MESSAGE ELEMENT: %d", type);
+		if (!IS_VALID_MESSAGE_ELEMENTS(type)) {
+			return UNRECOGNIZED_MESSAGE_ELEMENT;
+		}
+
+		/* Check binding */
+		if (IS_80211_MESSAGE_ELEMENTS(type) && (binding != CAPWAP_WIRELESS_BINDING_IEEE80211)) {
+			return UNRECOGNIZED_MESSAGE_ELEMENT;
+		}
+
+		if (rxmngpacket->read_ops.read_u16((capwap_message_elements_handle)rxmngpacket, &msglength) != sizeof(uint16_t)) {
+			return INVALID_MESSAGE_ELEMENT;
+		}
+
+		/* Check length */
+		if (msglength > bodylength) {
+			return INVALID_MESSAGE_ELEMENT;
+		}
+
+		/* Reader function */
+		read_ops = capwap_get_message_element_ops(type);
+		capwap_logging_debug("read_ops: %p", read_ops);
+		if (!read_ops) {
+			return INVALID_MESSAGE_ELEMENT;
+		}
 
 		/* Allowed to parsing only the size of message element */
 		rxmngpacket->readerpacketallowed = msglength;
 
-		/* Check binding */
-		if (IS_80211_MESSAGE_ELEMENTS(id) &&
-		    (binding != CAPWAP_WIRELESS_BINDING_IEEE80211))
-			return UNRECOGNIZED_MESSAGE_ELEMENT;
-
-		log_printf(LOG_DEBUG, "MESSAGE ELEMENT: %d", id.type);
-
-		if (id.type == CAPWAP_ELEMENT_VENDORPAYLOAD_TYPE) {
-			struct capwap_message_element_id vendor_id;
-
-			if (msglength < 7) {
-				log_printf(LOG_DEBUG, "Invalid Vendor Specific Payload element: underbuffer");
-				return INVALID_MESSAGE_ELEMENT;
-			}
-			if ((msglength - 6) > CAPWAP_VENDORPAYLOAD_MAXLENGTH) {
-				log_printf(LOG_DEBUG, "Invalid Vendor Specific Payload element: overbuffer");
-				return INVALID_MESSAGE_ELEMENT;
-			}
-
-			rxmngpacket->read_ops.read_u32((capwap_message_elements_handle)rxmngpacket, &vendor_id.vendor);
-			rxmngpacket->read_ops.read_u16((capwap_message_elements_handle)rxmngpacket, &vendor_id.type);
-
-			log_printf(LOG_DEBUG, "VENDOR MESSAGE ELEMENT: %06x:%d", vendor_id.vendor, vendor_id.type);
-
-			read_ops = capwap_get_message_element_ops(vendor_id);
-			log_printf(LOG_DEBUG, "vendor read_ops: %p", read_ops);
-			if (read_ops) {
-				id = vendor_id;
-				element = read_ops->parse((capwap_message_elements_handle)rxmngpacket, &rxmngpacket->read_ops);
-			} else {
-				read_ops = capwap_get_message_element_ops(id);
-				element = capwap_unknown_vendorpayload_element_parsing((capwap_message_elements_handle)rxmngpacket,
-										       &rxmngpacket->read_ops, msglength - 6, vendor_id);
-			}
-		} else {
-			/* Reader function */
-			read_ops = capwap_get_message_element_ops(id);
-			log_printf(LOG_DEBUG, "read_ops: %p", read_ops);
-
-			if (!read_ops)
-				return UNRECOGNIZED_MESSAGE_ELEMENT;
-
-			/* Get message element */
-			element = read_ops->parse((capwap_message_elements_handle)rxmngpacket, &rxmngpacket->read_ops);
-		}
-
-		if (!element)
-			return INVALID_MESSAGE_ELEMENT;
-
 		/* */
-		itemlist = capwap_get_message_element(packet, id);
+		itemlist = capwap_get_message_element(packet, type);
-		if (read_ops->category == CAPWAP_MESSAGE_ELEMENT_SINGLE) {
+		category = capwap_get_message_element_category(type);
+		if (category == CAPWAP_MESSAGE_ELEMENT_SINGLE) {
 			/* Check for multiple message element */
 			if (itemlist) {
 				return INVALID_MESSAGE_ELEMENT;
@@ -266,14 +248,18 @@ int capwap_parsing_packet(struct capwap_packet_rxmng* rxmngpacket, struct capwap
 			/* Create new message element */
 			itemlist = capwap_itemlist_create(sizeof(struct capwap_message_element_itemlist));
 			messageelement = (struct capwap_message_element_itemlist*)itemlist->item;
-			messageelement->id = id;
+			messageelement->type = type;
 			messageelement->category = CAPWAP_MESSAGE_ELEMENT_SINGLE;
-			messageelement->data = element;
+			messageelement->data = read_ops->parsing_message_element((capwap_message_elements_handle)rxmngpacket, &rxmngpacket->read_ops);
+			if (!messageelement->data) { 
+				capwap_itemlist_free(itemlist);
+				return INVALID_MESSAGE_ELEMENT; 
+			}
 
 			/* */
 			capwap_itemlist_insert_after(packet->messages, NULL, itemlist);
-		}
+		} else if (category == CAPWAP_MESSAGE_ELEMENT_ARRAY) {
-		else if (read_ops->category == CAPWAP_MESSAGE_ELEMENT_ARRAY) {
+			void* datamsgelement;
 			struct capwap_array* arraymessageelement;
 
 			if (itemlist) {
@@ -285,7 +271,7 @@ int capwap_parsing_packet(struct capwap_packet_rxmng* rxmngpacket, struct capwap
 				/* */
 				itemlist = capwap_itemlist_create(sizeof(struct capwap_message_element_itemlist));
 				messageelement = (struct capwap_message_element_itemlist*)itemlist->item;
-				messageelement->id = id;
+				messageelement->type = type;
 				messageelement->category = CAPWAP_MESSAGE_ELEMENT_ARRAY;
 				messageelement->data = (void*)arraymessageelement;
 
@@ -293,8 +279,14 @@ int capwap_parsing_packet(struct capwap_packet_rxmng* rxmngpacket, struct capwap
 				capwap_itemlist_insert_after(packet->messages, NULL, itemlist);
 			}
 
+			/* Get message element */
+			datamsgelement = read_ops->parsing_message_element((capwap_message_elements_handle)rxmngpacket, &rxmngpacket->read_ops);
+			if (!datamsgelement) { 
+				return INVALID_MESSAGE_ELEMENT;
+			}
+
 			/* */
-			*(void **)capwap_array_get_item_pointer(arraymessageelement, arraymessageelement->count) = element;
+			memcpy(capwap_array_get_item_pointer(arraymessageelement, arraymessageelement->count), &datamsgelement, sizeof(void*));
 		}
 
 		/* Check if read all data of message element */
@@ -638,7 +630,7 @@ void capwap_free_parsed_packet(struct capwap_parsed_packet* packet) {
 	int i;
 	struct capwap_list_item* itemlist;
 	struct capwap_message_element_itemlist* messageelement;
-	const struct capwap_message_elements_ops* msgops;
+	struct capwap_message_elements_ops* msgops;
 
 	ASSERT(packet != NULL);
 
@@ -647,15 +639,15 @@ void capwap_free_parsed_packet(struct capwap_parsed_packet* packet) {
 		while (itemlist) {
 			messageelement = (struct capwap_message_element_itemlist*)itemlist->item;
 			if (messageelement->data) {
-				msgops = capwap_get_message_element_ops(messageelement->id);
+				msgops = capwap_get_message_element_ops(messageelement->type);
 
 				if (messageelement->category == CAPWAP_MESSAGE_ELEMENT_SINGLE) {
-					msgops->free(messageelement->data);
+					msgops->free_message_element(messageelement->data);
 				} else if (messageelement->category == CAPWAP_MESSAGE_ELEMENT_ARRAY) {
 					struct capwap_array* arraymessageelement = (struct capwap_array*)messageelement->data;
 
 					for (i = 0; i < arraymessageelement->count; i++) {
-						msgops->free(*(void**)capwap_array_get_item_pointer(arraymessageelement, i));
+						msgops->free_message_element(*(void**)capwap_array_get_item_pointer(arraymessageelement, i));
 					}
 
 					/* */

src/common/capwap_element.h

@@ -4,12 +4,6 @@
 #include "capwap_array.h"
 #include "capwap_list.h"
 
-struct capwap_message_element_id
-{
-	uint32_t vendor;
-	uint16_t type;
-};
-
 /* */
 typedef void* capwap_message_elements_handle;
 struct capwap_write_message_elements_ops {
@@ -27,25 +21,21 @@ struct capwap_read_message_elements_ops {
 	int (*read_block)(capwap_message_elements_handle handle, uint8_t* data, unsigned short length);
 };
 
-struct capwap_message_elements_ops
+struct capwap_message_elements_ops {
-{
-	int category;
-
 	/* Build message element */
-	void (*create)(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func);
+	void (*create_message_element)(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func);
 
 	/* Parsing message element */
-	void* (*parse)(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func);
+	void* (*parsing_message_element)(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func);
 
 	/* Memory management */
-	void* (*clone)(void*);
+	void* (*clone_message_element)(void*);
-	void (*free)(void*);
+	void (*free_message_element)(void*);
 };
 
-const struct capwap_message_elements_ops *capwap_get_message_element_ops(const struct capwap_message_element_id id);
+struct capwap_message_elements_ops* capwap_get_message_element_ops(unsigned short code);
 
 /*********************************************************************************************************************/
-
 /* Standard message elements */
 #include "capwap_element_acdescriptor.h"				/* 00001 */
 #include "capwap_element_acipv4list.h"					/* 00002 */
@@ -128,16 +118,13 @@ const struct capwap_message_elements_ops *capwap_get_message_element_ops(const s
 #include "capwap_element_80211_wtpradiofailalarm.h"		/* 01047 */
 #include "capwap_element_80211_wtpradioinformation.h"	/* 01048 */
 
-#include "capwap_vendor_travelping.h"
-
 /*********************************************************************************************************************/
 #define CAPWAP_MESSAGE_ELEMENT_SINGLE			0
 #define CAPWAP_MESSAGE_ELEMENT_ARRAY			1
 int capwap_get_message_element_category(uint16_t type);
 
-struct capwap_message_element_itemlist
+struct capwap_message_element_itemlist {
-{
+	uint16_t type;
-	struct capwap_message_element_id id;
 	int category;
 	void* data;
 };
@@ -156,9 +143,7 @@ int capwap_parsing_packet(struct capwap_packet_rxmng* rxmngpacket, struct capwap
 int capwap_validate_parsed_packet(struct capwap_parsed_packet* packet, struct capwap_array* returnedmessage);
 void capwap_free_parsed_packet(struct capwap_parsed_packet* packet);
 
-struct capwap_list_item *capwap_get_message_element(struct capwap_parsed_packet *packet,
+struct capwap_list_item* capwap_get_message_element(struct capwap_parsed_packet* packet, uint16_t type);
-				      const struct capwap_message_element_id id);
+void* capwap_get_message_element_data(struct capwap_parsed_packet* packet, uint16_t type);
-void *capwap_get_message_element_data(struct capwap_parsed_packet *packet,
-				      const struct capwap_message_element_id id);
 
 #endif /* __CAPWAP_ELEMENT_HEADER__ */

src/common/capwap_element_80211_addwlan.c

@@ -99,7 +99,7 @@ static void* capwap_80211_addwlan_element_parsing(capwap_message_elements_handle
 
 	length = func->read_ready(handle);
 	if (length < 20) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Add WLAN element: underbuffer");
+		capwap_logging_debug("Invalid IEEE 802.11 Add WLAN element: underbuffer");
 		return NULL;
 	}
 
@@ -113,11 +113,11 @@ static void* capwap_80211_addwlan_element_parsing(capwap_message_elements_handle
 
 	if (!IS_VALID_RADIOID(data->radioid)) {
 		capwap_80211_addwlan_element_free((void*)data);
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Add WLAN element: invalid radioid");
+		capwap_logging_debug("Invalid IEEE 802.11 Add WLAN element: invalid radioid");
 		return NULL;
 	} else if (!IS_VALID_WLANID(data->wlanid)) {
 		capwap_80211_addwlan_element_free((void*)data);
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Add WLAN element: invalid wlanid");
+		capwap_logging_debug("Invalid IEEE 802.11 Add WLAN element: invalid wlanid");
 		return NULL;
 	}
 
@@ -141,7 +141,7 @@ static void* capwap_80211_addwlan_element_parsing(capwap_message_elements_handle
 	length = func->read_ready(handle);
 	if (!length || (length > CAPWAP_ADD_WLAN_SSID_LENGTH)) {
 		capwap_80211_addwlan_element_free((void*)data);
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Add WLAN element: invalid ssid");
+		capwap_logging_debug("Invalid IEEE 802.11 Add WLAN element: invalid ssid");
 		return NULL;
 	}
 
@@ -153,10 +153,9 @@ static void* capwap_80211_addwlan_element_parsing(capwap_message_elements_handle
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_addwlan_ops = {
+struct capwap_message_elements_ops capwap_element_80211_addwlan_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_SINGLE,
+	.create_message_element = capwap_80211_addwlan_element_create,
-	.create = capwap_80211_addwlan_element_create,
+	.parsing_message_element = capwap_80211_addwlan_element_parsing,
-	.parse = capwap_80211_addwlan_element_parsing,
+	.clone_message_element = capwap_80211_addwlan_element_clone,
-	.clone = capwap_80211_addwlan_element_clone,
+	.free_message_element = capwap_80211_addwlan_element_free
-	.free = capwap_80211_addwlan_element_free
 };

src/common/capwap_element_80211_addwlan.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_ADD_WLAN_HEADER__
 #define __CAPWAP_ELEMENT_80211_ADD_WLAN_HEADER__
 
-#define CAPWAP_ELEMENT_80211_ADD_WLAN_VENDOR				0
+#define CAPWAP_ELEMENT_80211_ADD_WLAN				1024
-#define CAPWAP_ELEMENT_80211_ADD_WLAN_TYPE				1024
-#define CAPWAP_ELEMENT_80211_ADD_WLAN					(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_ADD_WLAN_VENDOR, .type = CAPWAP_ELEMENT_80211_ADD_WLAN_TYPE }
-
 
 #define CAPWAP_ADD_WLAN_GROUPTSC_LENGTH				6
 #define CAPWAP_ADD_WLAN_SSID_LENGTH					32
@@ -62,6 +59,6 @@ struct capwap_80211_addwlan_element {
 	uint8_t* ssid;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_addwlan_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_addwlan_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_ADD_WLAN_HEADER__ */

src/common/capwap_element_80211_antenna.c

@@ -75,13 +75,13 @@ static void* capwap_80211_antenna_element_parsing(capwap_message_elements_handle
 
 	length = func->read_ready(handle);
 	if (length < 5) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Antenna element");
+		capwap_logging_debug("Invalid IEEE 802.11 Antenna element");
 		return NULL;
 	}
 
 	length -= 4;
 	if (length > CAPWAP_ANTENNASELECTIONS_MAXLENGTH) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Antenna element");
+		capwap_logging_debug("Invalid IEEE 802.11 Antenna element");
 		return NULL;
 	}
 
@@ -94,7 +94,7 @@ static void* capwap_80211_antenna_element_parsing(capwap_message_elements_handle
 	func->read_u8(handle, &data->radioid);
 	if (!IS_VALID_RADIOID(data->radioid)) {
 		capwap_80211_antenna_element_free((void*)data);
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Antenna element element: invalid radio");
+		capwap_logging_debug("Invalid IEEE 802.11 Antenna element element: invalid radio");
 		return NULL;
 	}
 
@@ -104,7 +104,7 @@ static void* capwap_80211_antenna_element_parsing(capwap_message_elements_handle
 
 	/* Check */
 	if (count != length) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Antenna element");
+		capwap_logging_debug("Invalid IEEE 802.11 Antenna element");
 		capwap_free(data);
 		return NULL;
 	}
@@ -142,10 +142,9 @@ void capwap_element_80211_antenna_copy(struct capwap_80211_antenna_element* dst,
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_antenna_ops = {
+struct capwap_message_elements_ops capwap_element_80211_antenna_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_ARRAY,
+	.create_message_element = capwap_80211_antenna_element_create,
-	.create = capwap_80211_antenna_element_create,
+	.parsing_message_element = capwap_80211_antenna_element_parsing,
-	.parse = capwap_80211_antenna_element_parsing,
+	.clone_message_element = capwap_80211_antenna_element_clone,
-	.clone = capwap_80211_antenna_element_clone,
+	.free_message_element = capwap_80211_antenna_element_free
-	.free = capwap_80211_antenna_element_free
 };

src/common/capwap_element_80211_antenna.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_ANTENNA_HEADER__
 #define __CAPWAP_ELEMENT_80211_ANTENNA_HEADER__
 
-#define CAPWAP_ELEMENT_80211_ANTENNA_VENDOR			0
+#define CAPWAP_ELEMENT_80211_ANTENNA			1025
-#define CAPWAP_ELEMENT_80211_ANTENNA_TYPE			1025
-#define CAPWAP_ELEMENT_80211_ANTENNA				(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_ANTENNA_VENDOR, .type = CAPWAP_ELEMENT_80211_ANTENNA_TYPE }
-
 
 #define CAPWAP_ANTENNA_DIVERSITY_DISABLE		0
 #define CAPWAP_ANTENNA_DIVERSITY_ENABLE			1
@@ -26,7 +23,7 @@ struct capwap_80211_antenna_element {
 	struct capwap_array* selections;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_antenna_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_antenna_ops;
 void capwap_element_80211_antenna_copy(struct capwap_80211_antenna_element* dst, struct capwap_80211_antenna_element* src);
 
 #endif /* __CAPWAP_ELEMENT_80211_ANTENNA_HEADER__ */

src/common/capwap_element_80211_assignbssid.c

@@ -36,7 +36,7 @@ static void* capwap_80211_assignbssid_element_parsing(capwap_message_elements_ha
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 8) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Assigned WTP BSSID element");
+		capwap_logging_debug("Invalid IEEE 802.11 Assigned WTP BSSID element");
 		return NULL;
 	}
 
@@ -67,10 +67,9 @@ static void capwap_80211_assignbssid_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_assignbssid_ops = {
+struct capwap_message_elements_ops capwap_element_80211_assignbssid_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_SINGLE,
+	.create_message_element = capwap_80211_assignbssid_element_create,
-	.create = capwap_80211_assignbssid_element_create,
+	.parsing_message_element = capwap_80211_assignbssid_element_parsing,
-	.parse = capwap_80211_assignbssid_element_parsing,
+	.clone_message_element = capwap_80211_assignbssid_element_clone,
-	.clone = capwap_80211_assignbssid_element_clone,
+	.free_message_element = capwap_80211_assignbssid_element_free
-	.free = capwap_80211_assignbssid_element_free
 };

src/common/capwap_element_80211_assignbssid.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_ASSIGN_BSSID_HEADER__
 #define __CAPWAP_ELEMENT_80211_ASSIGN_BSSID_HEADER__
 
-#define CAPWAP_ELEMENT_80211_ASSIGN_BSSID_VENDOR		0
+#define CAPWAP_ELEMENT_80211_ASSIGN_BSSID		1026
-#define CAPWAP_ELEMENT_80211_ASSIGN_BSSID_TYPE		1026
-#define CAPWAP_ELEMENT_80211_ASSIGN_BSSID			(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_ASSIGN_BSSID_VENDOR, .type = CAPWAP_ELEMENT_80211_ASSIGN_BSSID_TYPE }
-
 
 struct capwap_80211_assignbssid_element {
 	uint8_t radioid;
@@ -12,6 +9,6 @@ struct capwap_80211_assignbssid_element {
 	uint8_t bssid[MACADDRESS_EUI48_LENGTH];
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_assignbssid_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_assignbssid_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_ASSIGN_BSSID_HEADER__ */

src/common/capwap_element_80211_deletewlan.c

@@ -33,7 +33,7 @@ static void* capwap_80211_deletewlan_element_parsing(capwap_message_elements_han
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 2) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Delete WLAN element");
+		capwap_logging_debug("Invalid IEEE 802.11 Delete WLAN element");
 		return NULL;
 	}
 
@@ -63,10 +63,9 @@ static void capwap_80211_deletewlan_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_deletewlan_ops = {
+struct capwap_message_elements_ops capwap_element_80211_deletewlan_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_SINGLE,
+	.create_message_element = capwap_80211_deletewlan_element_create,
-	.create = capwap_80211_deletewlan_element_create,
+	.parsing_message_element = capwap_80211_deletewlan_element_parsing,
-	.parse = capwap_80211_deletewlan_element_parsing,
+	.clone_message_element = capwap_80211_deletewlan_element_clone,
-	.clone = capwap_80211_deletewlan_element_clone,
+	.free_message_element = capwap_80211_deletewlan_element_free
-	.free = capwap_80211_deletewlan_element_free
 };

src/common/capwap_element_80211_deletewlan.h

@@ -1,16 +1,13 @@
 #ifndef __CAPWAP_ELEMENT_80211_DELETE_WLAN_HEADER__
 #define __CAPWAP_ELEMENT_80211_DELETE_WLAN_HEADER__
 
-#define CAPWAP_ELEMENT_80211_DELETE_WLAN_VENDOR		0
+#define CAPWAP_ELEMENT_80211_DELETE_WLAN		1027
-#define CAPWAP_ELEMENT_80211_DELETE_WLAN_TYPE		1027
-#define CAPWAP_ELEMENT_80211_DELETE_WLAN			(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_DELETE_WLAN_VENDOR, .type = CAPWAP_ELEMENT_80211_DELETE_WLAN_TYPE }
-
 
 struct capwap_80211_deletewlan_element {
 	uint8_t radioid;
 	uint8_t wlanid;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_deletewlan_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_deletewlan_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_DELETE_WLAN_HEADER__ */

src/common/capwap_element_80211_directsequencecontrol.c

@@ -54,7 +54,7 @@ static void* capwap_80211_directsequencecontrol_element_parsing(capwap_message_e
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 8) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Direct Sequence Control element");
+		capwap_logging_debug("Invalid IEEE 802.11 Direct Sequence Control element");
 		return NULL;
 	}
 
@@ -66,7 +66,7 @@ static void* capwap_80211_directsequencecontrol_element_parsing(capwap_message_e
 	func->read_u8(handle, &data->radioid);
 	if (!IS_VALID_RADIOID(data->radioid)) {
 		capwap_80211_directsequencecontrol_element_free((void*)data);
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Direct Sequence Control element: invalid radio");
+		capwap_logging_debug("Invalid IEEE 802.11 Direct Sequence Control element: invalid radio");
 		return NULL;
 	}
 
@@ -79,10 +79,9 @@ static void* capwap_80211_directsequencecontrol_element_parsing(capwap_message_e
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_directsequencecontrol_ops = {
+struct capwap_message_elements_ops capwap_element_80211_directsequencecontrol_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_ARRAY,
+	.create_message_element = capwap_80211_directsequencecontrol_element_create,
-	.create = capwap_80211_directsequencecontrol_element_create,
+	.parsing_message_element = capwap_80211_directsequencecontrol_element_parsing,
-	.parse = capwap_80211_directsequencecontrol_element_parsing,
+	.clone_message_element = capwap_80211_directsequencecontrol_element_clone,
-	.clone = capwap_80211_directsequencecontrol_element_clone,
+	.free_message_element = capwap_80211_directsequencecontrol_element_free
-	.free = capwap_80211_directsequencecontrol_element_free
 };

src/common/capwap_element_80211_directsequencecontrol.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL_HEADER__
 #define __CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL_HEADER__
 
-#define CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL_VENDOR			0
+#define CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL			1028
-#define CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL_TYPE			1028
-#define CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL				(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL_VENDOR, .type = CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL_TYPE }
-
 
 #define CAPWAP_DSCONTROL_CCA_EDONLY				1
 #define CAPWAP_DSCONTROL_CCA_CSONLY				2
@@ -20,6 +17,6 @@ struct capwap_80211_directsequencecontrol_element {
 	uint32_t enerydetectthreshold;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_directsequencecontrol_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_directsequencecontrol_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL_HEADER__ */

src/common/capwap_element_80211_ie.c

@@ -37,7 +37,7 @@ static void* capwap_80211_ie_element_parsing(capwap_message_elements_handle hand
 
 	length = func->read_ready(handle);
 	if (length < 4) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Information Element element");
+		capwap_logging_debug("Invalid IEEE 802.11 Information Element element");
 		return NULL;
 	}
 
@@ -83,10 +83,9 @@ static void capwap_80211_ie_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_ie_ops = {
+struct capwap_message_elements_ops capwap_element_80211_ie_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_ARRAY,
+	.create_message_element = capwap_80211_ie_element_create,
-	.create = capwap_80211_ie_element_create,
+	.parsing_message_element = capwap_80211_ie_element_parsing,
-	.parse = capwap_80211_ie_element_parsing,
+	.clone_message_element = capwap_80211_ie_element_clone,
-	.clone = capwap_80211_ie_element_clone,
+	.free_message_element = capwap_80211_ie_element_free
-	.free = capwap_80211_ie_element_free
 };

src/common/capwap_element_80211_ie.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_IE_HEADER__
 #define __CAPWAP_ELEMENT_80211_IE_HEADER__
 
-#define CAPWAP_ELEMENT_80211_IE_VENDOR				0
+#define CAPWAP_ELEMENT_80211_IE				1029
-#define CAPWAP_ELEMENT_80211_IE_TYPE				1029
-#define CAPWAP_ELEMENT_80211_IE					(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_IE_VENDOR, .type = CAPWAP_ELEMENT_80211_IE_TYPE }
-
 
 #define CAPWAP_IE_BEACONS_ASSOCIATED				0x80
 #define CAPWAP_IE_PROBE_RESPONSE_ASSOCIATED			0x40
@@ -17,6 +14,6 @@ struct capwap_80211_ie_element {
 	uint8_t* ie;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_ie_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_ie_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_IE_HEADER__ */

src/common/capwap_element_80211_macoperation.c

@@ -46,7 +46,7 @@ static void* capwap_80211_macoperation_element_parsing(capwap_message_elements_h
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 16) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 MAC Operation element");
+		capwap_logging_debug("Invalid IEEE 802.11 MAC Operation element");
 		return NULL;
 	}
 
@@ -82,10 +82,9 @@ static void capwap_80211_macoperation_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_macoperation_ops = {
+struct capwap_message_elements_ops capwap_element_80211_macoperation_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_ARRAY,
+	.create_message_element = capwap_80211_macoperation_element_create,
-	.create = capwap_80211_macoperation_element_create,
+	.parsing_message_element = capwap_80211_macoperation_element_parsing,
-	.parse = capwap_80211_macoperation_element_parsing,
+	.clone_message_element = capwap_80211_macoperation_element_clone,
-	.clone = capwap_80211_macoperation_element_clone,
+	.free_message_element = capwap_80211_macoperation_element_free
-	.free = capwap_80211_macoperation_element_free
 };

src/common/capwap_element_80211_macoperation.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_MACOPERATION_HEADER__
 #define __CAPWAP_ELEMENT_80211_MACOPERATION_HEADER__
 
-#define CAPWAP_ELEMENT_80211_MACOPERATION_VENDOR			0
+#define CAPWAP_ELEMENT_80211_MACOPERATION			1030
-#define CAPWAP_ELEMENT_80211_MACOPERATION_TYPE			1030
-#define CAPWAP_ELEMENT_80211_MACOPERATION				(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_MACOPERATION_VENDOR, .type = CAPWAP_ELEMENT_80211_MACOPERATION_TYPE }
-
 
 struct capwap_80211_macoperation_element {
 	uint8_t radioid;
@@ -16,6 +13,6 @@ struct capwap_80211_macoperation_element {
 	uint32_t rxmsdulifetime;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_macoperation_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_macoperation_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_MACOPERATION_HEADER__ */

src/common/capwap_element_80211_miccountermeasures.c

@@ -36,7 +36,7 @@ static void* capwap_80211_miccountermeasures_element_parsing(capwap_message_elem
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 8) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 MIC Countermeasures element");
+		capwap_logging_debug("Invalid IEEE 802.11 MIC Countermeasures element");
 		return NULL;
 	}
 
@@ -67,10 +67,9 @@ static void capwap_80211_miccountermeasures_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_miccountermeasures_ops = {
+struct capwap_message_elements_ops capwap_element_80211_miccountermeasures_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_SINGLE,
+	.create_message_element = capwap_80211_miccountermeasures_element_create,
-	.create = capwap_80211_miccountermeasures_element_create,
+	.parsing_message_element = capwap_80211_miccountermeasures_element_parsing,
-	.parse = capwap_80211_miccountermeasures_element_parsing,
+	.clone_message_element = capwap_80211_miccountermeasures_element_clone,
-	.clone = capwap_80211_miccountermeasures_element_clone,
+	.free_message_element = capwap_80211_miccountermeasures_element_free
-	.free = capwap_80211_miccountermeasures_element_free
 };

src/common/capwap_element_80211_miccountermeasures.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES_HEADER__
 #define __CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES_HEADER__
 
-#define CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES_VENDOR			0
+#define CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES			1031
-#define CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES_TYPE			1031
-#define CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES				(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES_VENDOR, .type = CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES_TYPE }
-
 
 struct capwap_80211_miccountermeasures_element {
 	uint8_t radioid;
@@ -12,6 +9,6 @@ struct capwap_80211_miccountermeasures_element {
 	uint8_t address[MACADDRESS_EUI48_LENGTH];
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_miccountermeasures_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_miccountermeasures_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_MIC_COUNTERMEASURES_HEADER__ */

src/common/capwap_element_80211_multidomaincapability.c

@@ -39,7 +39,7 @@ static void* capwap_80211_multidomaincapability_element_parsing(capwap_message_e
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 8) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Multi-Domain Capability element");
+		capwap_logging_debug("Invalid IEEE 802.11 Multi-Domain Capability element");
 		return NULL;
 	}
 
@@ -72,10 +72,9 @@ static void capwap_80211_multidomaincapability_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_multidomaincapability_ops = {
+struct capwap_message_elements_ops capwap_element_80211_multidomaincapability_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_ARRAY,
+	.create_message_element = capwap_80211_multidomaincapability_element_create,
-	.create = capwap_80211_multidomaincapability_element_create,
+	.parsing_message_element = capwap_80211_multidomaincapability_element_parsing,
-	.parse = capwap_80211_multidomaincapability_element_parsing,
+	.clone_message_element = capwap_80211_multidomaincapability_element_clone,
-	.clone = capwap_80211_multidomaincapability_element_clone,
+	.free_message_element = capwap_80211_multidomaincapability_element_free
-	.free = capwap_80211_multidomaincapability_element_free
 };

src/common/capwap_element_80211_multidomaincapability.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY_HEADER__
 #define __CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY_HEADER__
 
-#define CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY_VENDOR			0
+#define CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY			1032
-#define CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY_TYPE			1032
-#define CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY				(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY_VENDOR, .type = CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY_TYPE }
-
 
 struct capwap_80211_multidomaincapability_element {
 	uint8_t radioid;
@@ -13,6 +10,6 @@ struct capwap_80211_multidomaincapability_element {
 	uint16_t maxtxpowerlevel;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_multidomaincapability_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_multidomaincapability_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY_HEADER__ */

src/common/capwap_element_80211_ofdmcontrol.c

@@ -39,7 +39,7 @@ static void* capwap_80211_ofdmcontrol_element_parsing(capwap_message_elements_ha
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 8) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 OFDM Control element");
+		capwap_logging_debug("Invalid IEEE 802.11 OFDM Control element");
 		return NULL;
 	}
 
@@ -72,10 +72,9 @@ static void capwap_80211_ofdmcontrol_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_ofdmcontrol_ops = {
+struct capwap_message_elements_ops capwap_element_80211_ofdmcontrol_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_ARRAY,
+	.create_message_element = capwap_80211_ofdmcontrol_element_create,
-	.create = capwap_80211_ofdmcontrol_element_create,
+	.parsing_message_element = capwap_80211_ofdmcontrol_element_parsing,
-	.parse = capwap_80211_ofdmcontrol_element_parsing,
+	.clone_message_element = capwap_80211_ofdmcontrol_element_clone,
-	.clone = capwap_80211_ofdmcontrol_element_clone,
+	.free_message_element = capwap_80211_ofdmcontrol_element_free
-	.free = capwap_80211_ofdmcontrol_element_free
 };

src/common/capwap_element_80211_ofdmcontrol.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_OFDMCONTROL_HEADER__
 #define __CAPWAP_ELEMENT_80211_OFDMCONTROL_HEADER__
 
-#define CAPWAP_ELEMENT_80211_OFDMCONTROL_VENDOR			0
+#define CAPWAP_ELEMENT_80211_OFDMCONTROL			1033
-#define CAPWAP_ELEMENT_80211_OFDMCONTROL_TYPE			1033
-#define CAPWAP_ELEMENT_80211_OFDMCONTROL				(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_OFDMCONTROL_VENDOR, .type = CAPWAP_ELEMENT_80211_OFDMCONTROL_TYPE }
-
 
 #define CAPWAP_OFDMCONTROL_BAND_515_525				0x01
 #define CAPWAP_OFDMCONTROL_BAND_525_535				0x02
@@ -22,6 +19,6 @@ struct capwap_80211_ofdmcontrol_element {
 	uint32_t tithreshold;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_ofdmcontrol_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_ofdmcontrol_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_OFDMCONTROL_HEADER__ */

src/common/capwap_element_80211_rateset.c

@@ -35,13 +35,13 @@ static void* capwap_80211_rateset_element_parsing(capwap_message_elements_handle
 
 	length = func->read_ready(handle);
 	if (length < 3) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Rate Set element");
+		capwap_logging_debug("Invalid IEEE 802.11 Rate Set element");
 		return NULL;
 	}
 
 	length -= 1;
 	if (length > CAPWAP_RATESET_MAXLENGTH) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Rate Set element");
+		capwap_logging_debug("Invalid IEEE 802.11 Rate Set element");
 		return NULL;
 	}
 
@@ -72,10 +72,9 @@ static void capwap_80211_rateset_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_rateset_ops = {
+struct capwap_message_elements_ops capwap_element_80211_rateset_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_ARRAY,
+	.create_message_element = capwap_80211_rateset_element_create,
-	.create = capwap_80211_rateset_element_create,
+	.parsing_message_element = capwap_80211_rateset_element_parsing,
-	.parse = capwap_80211_rateset_element_parsing,
+	.clone_message_element = capwap_80211_rateset_element_clone,
-	.clone = capwap_80211_rateset_element_clone,
+	.free_message_element = capwap_80211_rateset_element_free
-	.free = capwap_80211_rateset_element_free
 };

src/common/capwap_element_80211_rateset.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_RATESET_HEADER__
 #define __CAPWAP_ELEMENT_80211_RATESET_HEADER__
 
-#define CAPWAP_ELEMENT_80211_RATESET_VENDOR		0
+#define CAPWAP_ELEMENT_80211_RATESET		1034
-#define CAPWAP_ELEMENT_80211_RATESET_TYPE		1034
-#define CAPWAP_ELEMENT_80211_RATESET			(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_RATESET_VENDOR, .type = CAPWAP_ELEMENT_80211_RATESET_TYPE }
-
 
 #define CAPWAP_RATESET_MINLENGTH			2
 #define CAPWAP_RATESET_MAXLENGTH			8
@@ -15,6 +12,6 @@ struct capwap_80211_rateset_element {
 	uint8_t rateset[CAPWAP_RATESET_MAXLENGTH];
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_rateset_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_rateset_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_RATESET_HEADER__ */

src/common/capwap_element_80211_rsnaerrorreport.c

@@ -61,7 +61,7 @@ static void* capwap_80211_rsnaerrorreport_element_parsing(capwap_message_element
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 40) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 RSNA Error Report From Station element");
+		capwap_logging_debug("Invalid IEEE 802.11 RSNA Error Report From Station element");
 		return NULL;
 	}
 
@@ -100,10 +100,9 @@ static void capwap_80211_rsnaerrorreport_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_rsnaerrorreport_ops = {
+struct capwap_message_elements_ops capwap_element_80211_rsnaerrorreport_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_SINGLE,
+	.create_message_element = capwap_80211_rsnaerrorreport_element_create,
-	.create = capwap_80211_rsnaerrorreport_element_create,
+	.parsing_message_element = capwap_80211_rsnaerrorreport_element_parsing,
-	.parse = capwap_80211_rsnaerrorreport_element_parsing,
+	.clone_message_element = capwap_80211_rsnaerrorreport_element_clone,
-	.clone = capwap_80211_rsnaerrorreport_element_clone,
+	.free_message_element = capwap_80211_rsnaerrorreport_element_free
-	.free = capwap_80211_rsnaerrorreport_element_free
 };

src/common/capwap_element_80211_rsnaerrorreport.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT_HEADER__
 #define __CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT_HEADER__
 
-#define CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT_VENDOR		0
+#define CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT		1035
-#define CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT_TYPE		1035
-#define CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT			(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT_VENDOR, .type = CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT_TYPE }
-
 
 struct capwap_80211_rsnaerrorreport_element {
 	uint8_t client[MACADDRESS_EUI48_LENGTH];
@@ -19,6 +16,6 @@ struct capwap_80211_rsnaerrorreport_element {
 	uint32_t tkipreplays;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_rsnaerrorreport_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_rsnaerrorreport_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_RSNA_ERROR_REPORT_HEADER__ */

src/common/capwap_element_80211_station.c

@@ -46,13 +46,13 @@ static void* capwap_80211_station_element_parsing(capwap_message_elements_handle
 
 	length = func->read_ready(handle);
 	if (length < 14) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Station element");
+		capwap_logging_debug("Invalid IEEE 802.11 Station element");
 		return NULL;
 	}
 
 	length -= 13;
 	if (length > CAPWAP_STATION_RATES_MAXLENGTH) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Station element");
+		capwap_logging_debug("Invalid IEEE 802.11 Station element");
 		return NULL;
 	}
 
@@ -88,10 +88,9 @@ static void capwap_80211_station_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_station_ops = {
+struct capwap_message_elements_ops capwap_element_80211_station_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_SINGLE,
+	.create_message_element = capwap_80211_station_element_create,
-	.create = capwap_80211_station_element_create,
+	.parsing_message_element = capwap_80211_station_element_parsing,
-	.parse = capwap_80211_station_element_parsing,
+	.clone_message_element = capwap_80211_station_element_clone,
-	.clone = capwap_80211_station_element_clone,
+	.free_message_element = capwap_80211_station_element_free
-	.free = capwap_80211_station_element_free
 };

src/common/capwap_element_80211_station.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_STATION_HEADER__
 #define __CAPWAP_ELEMENT_80211_STATION_HEADER__
 
-#define CAPWAP_ELEMENT_80211_STATION_VENDOR		0
+#define CAPWAP_ELEMENT_80211_STATION		1036
-#define CAPWAP_ELEMENT_80211_STATION_TYPE		1036
-#define CAPWAP_ELEMENT_80211_STATION			(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_STATION_VENDOR, .type = CAPWAP_ELEMENT_80211_STATION_TYPE }
-
 
 #define CAPWAP_STATION_RATES_MAXLENGTH			128
 
@@ -19,6 +16,6 @@ struct capwap_80211_station_element {
 	uint8_t supportedrates[CAPWAP_STATION_RATES_MAXLENGTH];
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_station_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_station_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_STATION_HEADER__ */

src/common/capwap_element_80211_stationkey.c

@@ -48,7 +48,7 @@ static void* capwap_80211_stationkey_element_parsing(capwap_message_elements_han
 
 	length = func->read_ready(handle);
 	if (length < 25) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Station Session Key element");
+		capwap_logging_debug("Invalid IEEE 802.11 Station Session Key element");
 		return NULL;
 	}
 
@@ -96,10 +96,9 @@ static void capwap_80211_stationkey_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_stationkey_ops = {
+struct capwap_message_elements_ops capwap_element_80211_stationkey_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_SINGLE,
+	.create_message_element = capwap_80211_stationkey_element_create,
-	.create = capwap_80211_stationkey_element_create,
+	.parsing_message_element = capwap_80211_stationkey_element_parsing,
-	.parse = capwap_80211_stationkey_element_parsing,
+	.clone_message_element = capwap_80211_stationkey_element_clone,
-	.clone = capwap_80211_stationkey_element_clone,
+	.free_message_element = capwap_80211_stationkey_element_free
-	.free = capwap_80211_stationkey_element_free
 };

src/common/capwap_element_80211_stationkey.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_STATION_SESSION_KEY_HEADER__
 #define __CAPWAP_ELEMENT_80211_STATION_SESSION_KEY_HEADER__
 
-#define CAPWAP_ELEMENT_80211_STATION_SESSION_KEY_PROFILE_VENDOR		0
+#define CAPWAP_ELEMENT_80211_STATION_SESSION_KEY_PROFILE		1038
-#define CAPWAP_ELEMENT_80211_STATION_SESSION_KEY_PROFILE_TYPE		1038
-#define CAPWAP_ELEMENT_80211_STATION_SESSION_KEY_PROFILE			(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_STATION_SESSION_KEY_PROFILE_VENDOR, .type = CAPWAP_ELEMENT_80211_STATION_SESSION_KEY_PROFILE_TYPE }
-
 
 #define CAPWAP_STATION_SESSION_KEY_PAIRWISE_TSC_LENGTH			6
 #define CAPWAP_STATION_SESSION_KEY_PAIRWISE_RSC_LENGTH			6
@@ -21,6 +18,6 @@ struct capwap_80211_stationkey_element {
 	uint8_t* key;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_stationkey_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_stationkey_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_STATION_SESSION_KEY_HEADER__ */

src/common/capwap_element_80211_stationqos.c

@@ -36,7 +36,7 @@ static void* capwap_80211_stationqos_element_parsing(capwap_message_elements_han
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 8) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Station QoS Profile element");
+		capwap_logging_debug("Invalid IEEE 802.11 Station QoS Profile element");
 		return NULL;
 	}
 
@@ -67,10 +67,9 @@ static void capwap_80211_stationqos_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_stationqos_ops = {
+struct capwap_message_elements_ops capwap_element_80211_stationqos_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_SINGLE,
+	.create_message_element = capwap_80211_stationqos_element_create,
-	.create = capwap_80211_stationqos_element_create,
+	.parsing_message_element = capwap_80211_stationqos_element_parsing,
-	.parse = capwap_80211_stationqos_element_parsing,
+	.clone_message_element = capwap_80211_stationqos_element_clone,
-	.clone = capwap_80211_stationqos_element_clone,
+	.free_message_element = capwap_80211_stationqos_element_free
-	.free = capwap_80211_stationqos_element_free
 };

src/common/capwap_element_80211_stationqos.h

@@ -1,16 +1,13 @@
 #ifndef __CAPWAP_ELEMENT_80211_STATION_QOS_PROFILE_HEADER__
 #define __CAPWAP_ELEMENT_80211_STATION_QOS_PROFILE_HEADER__
 
-#define CAPWAP_ELEMENT_80211_STATION_QOS_PROFILE_VENDOR		0
+#define CAPWAP_ELEMENT_80211_STATION_QOS_PROFILE		1037
-#define CAPWAP_ELEMENT_80211_STATION_QOS_PROFILE_TYPE		1037
-#define CAPWAP_ELEMENT_80211_STATION_QOS_PROFILE			(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_STATION_QOS_PROFILE_VENDOR, .type = CAPWAP_ELEMENT_80211_STATION_QOS_PROFILE_TYPE }
-
 
 struct capwap_80211_stationqos_element {
 	uint8_t address[MACADDRESS_EUI48_LENGTH];
 	uint8_t priority;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_stationqos_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_stationqos_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_STATION_QOS_PROFILE_HEADER__ */

src/common/capwap_element_80211_statistics.c

@@ -91,7 +91,7 @@ static void* capwap_80211_statistics_element_parsing(capwap_message_elements_han
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 80) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Statistics element");
+		capwap_logging_debug("Invalid IEEE 802.11 Statistics element");
 		return NULL;
 	}
 
@@ -140,10 +140,9 @@ static void capwap_80211_statistics_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_statistics_ops = {
+struct capwap_message_elements_ops capwap_element_80211_statistics_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_ARRAY,
+	.create_message_element = capwap_80211_statistics_element_create,
-	.create = capwap_80211_statistics_element_create,
+	.parsing_message_element = capwap_80211_statistics_element_parsing,
-	.parse = capwap_80211_statistics_element_parsing,
+	.clone_message_element = capwap_80211_statistics_element_clone,
-	.clone = capwap_80211_statistics_element_clone,
+	.free_message_element = capwap_80211_statistics_element_free
-	.free = capwap_80211_statistics_element_free
 };

src/common/capwap_element_80211_statistics.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_STATISTICS_HEADER__
 #define __CAPWAP_ELEMENT_80211_STATISTICS_HEADER__
 
-#define CAPWAP_ELEMENT_80211_STATISTICS_VENDOR				0
+#define CAPWAP_ELEMENT_80211_STATISTICS				1039
-#define CAPWAP_ELEMENT_80211_STATISTICS_TYPE				1039
-#define CAPWAP_ELEMENT_80211_STATISTICS					(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_STATISTICS_VENDOR, .type = CAPWAP_ELEMENT_80211_STATISTICS_TYPE }
-
 
 struct capwap_80211_statistics_element {
 	uint8_t radioid;
@@ -29,6 +26,6 @@ struct capwap_80211_statistics_element {
 	uint32_t qoscfpollsunusable;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_statistics_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_statistics_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_STATISTICS_HEADER__ */

src/common/capwap_element_80211_supportedrates.c

@@ -35,13 +35,13 @@ static void* capwap_80211_supportedrates_element_parsing(capwap_message_elements
 
 	length = func->read_ready(handle);
 	if (length < 3) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Supported Rates element");
+		capwap_logging_debug("Invalid IEEE 802.11 Supported Rates element");
 		return NULL;
 	}
 
 	length -= 1;
 	if (length > CAPWAP_RATESET_MAXLENGTH) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Supported Rates element");
+		capwap_logging_debug("Invalid IEEE 802.11 Supported Rates element");
 		return NULL;
 	}
 
@@ -72,10 +72,9 @@ static void capwap_80211_supportedrates_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_supportedrates_ops = {
+struct capwap_message_elements_ops capwap_element_80211_supportedrates_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_ARRAY,
+	.create_message_element = capwap_80211_supportedrates_element_create,
-	.create = capwap_80211_supportedrates_element_create,
+	.parsing_message_element = capwap_80211_supportedrates_element_parsing,
-	.parse = capwap_80211_supportedrates_element_parsing,
+	.clone_message_element = capwap_80211_supportedrates_element_clone,
-	.clone = capwap_80211_supportedrates_element_clone,
+	.free_message_element = capwap_80211_supportedrates_element_free
-	.free = capwap_80211_supportedrates_element_free
 };

src/common/capwap_element_80211_supportedrates.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_SUPPORTEDRATES_HEADER__
 #define __CAPWAP_ELEMENT_80211_SUPPORTEDRATES_HEADER__
 
-#define CAPWAP_ELEMENT_80211_SUPPORTEDRATES_VENDOR		0
+#define CAPWAP_ELEMENT_80211_SUPPORTEDRATES		1040
-#define CAPWAP_ELEMENT_80211_SUPPORTEDRATES_TYPE		1040
-#define CAPWAP_ELEMENT_80211_SUPPORTEDRATES			(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_SUPPORTEDRATES_VENDOR, .type = CAPWAP_ELEMENT_80211_SUPPORTEDRATES_TYPE }
-
 
 #define CAPWAP_SUPPORTEDRATES_MINLENGTH			2
 #define CAPWAP_SUPPORTEDRATES_MAXLENGTH			8
@@ -15,6 +12,6 @@ struct capwap_80211_supportedrates_element {
 	uint8_t supportedrates[CAPWAP_SUPPORTEDRATES_MAXLENGTH];
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_supportedrates_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_supportedrates_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_SUPPORTEDRATES_HEADER__ */

src/common/capwap_element_80211_txpower.c

@@ -35,7 +35,7 @@ static void* capwap_80211_txpower_element_parsing(capwap_message_elements_handle
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 4) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Tx Power element");
+		capwap_logging_debug("Invalid IEEE 802.11 Tx Power element");
 		return NULL;
 	}
 
@@ -66,10 +66,9 @@ static void capwap_80211_txpower_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_txpower_ops = {
+struct capwap_message_elements_ops capwap_element_80211_txpower_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_ARRAY,
+	.create_message_element = capwap_80211_txpower_element_create,
-	.create = capwap_80211_txpower_element_create,
+	.parsing_message_element = capwap_80211_txpower_element_parsing,
-	.parse = capwap_80211_txpower_element_parsing,
+	.clone_message_element = capwap_80211_txpower_element_clone,
-	.clone = capwap_80211_txpower_element_clone,
+	.free_message_element = capwap_80211_txpower_element_free
-	.free = capwap_80211_txpower_element_free
 };

src/common/capwap_element_80211_txpower.h

@@ -1,16 +1,13 @@
 #ifndef __CAPWAP_ELEMENT_80211_TXPOWER_HEADER__
 #define __CAPWAP_ELEMENT_80211_TXPOWER_HEADER__
 
-#define CAPWAP_ELEMENT_80211_TXPOWER_VENDOR				0
+#define CAPWAP_ELEMENT_80211_TXPOWER				1041
-#define CAPWAP_ELEMENT_80211_TXPOWER_TYPE				1041
-#define CAPWAP_ELEMENT_80211_TXPOWER					(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_TXPOWER_VENDOR, .type = CAPWAP_ELEMENT_80211_TXPOWER_TYPE }
-
 
 struct capwap_80211_txpower_element {
 	uint8_t radioid;
 	uint16_t currenttxpower;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_txpower_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_txpower_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_TXPOWER_HEADER__ */

src/common/capwap_element_80211_txpowerlevel.c

@@ -40,13 +40,13 @@ static void* capwap_80211_txpowerlevel_element_parsing(capwap_message_elements_h
 
 	length = func->read_ready(handle);
 	if (length < 4) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Tx Power Level element");
+		capwap_logging_debug("Invalid IEEE 802.11 Tx Power Level element");
 		return NULL;
 	}
 
 	length -= 2;
 	if ((length % sizeof(uint16_t)) || ((length / sizeof(uint16_t)) > CAPWAP_TXPOWERLEVEL_MAXLENGTH)) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Tx Power Level element");
+		capwap_logging_debug("Invalid IEEE 802.11 Tx Power Level element");
 		return NULL;
 	}
 
@@ -60,7 +60,7 @@ static void* capwap_80211_txpowerlevel_element_parsing(capwap_message_elements_h
 
 	/* Check */
 	if ((data->numlevels * sizeof(uint16_t)) != length) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Tx Power Level element");
+		capwap_logging_debug("Invalid IEEE 802.11 Tx Power Level element");
 		capwap_free(data);
 		return NULL;
 	}
@@ -87,10 +87,9 @@ static void capwap_80211_txpowerlevel_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_txpowerlevel_ops = {
+struct capwap_message_elements_ops capwap_element_80211_txpowerlevel_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_ARRAY,
+	.create_message_element = capwap_80211_txpowerlevel_element_create,
-	.create = capwap_80211_txpowerlevel_element_create,
+	.parsing_message_element = capwap_80211_txpowerlevel_element_parsing,
-	.parse = capwap_80211_txpowerlevel_element_parsing,
+	.clone_message_element = capwap_80211_txpowerlevel_element_clone,
-	.clone = capwap_80211_txpowerlevel_element_clone,
+	.free_message_element = capwap_80211_txpowerlevel_element_free
-	.free = capwap_80211_txpowerlevel_element_free
 };

src/common/capwap_element_80211_txpowerlevel.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_TXPOWERLEVEL_HEADER__
 #define __CAPWAP_ELEMENT_80211_TXPOWERLEVEL_HEADER__
 
-#define CAPWAP_ELEMENT_80211_TXPOWERLEVEL_VENDOR				0
+#define CAPWAP_ELEMENT_80211_TXPOWERLEVEL				1042
-#define CAPWAP_ELEMENT_80211_TXPOWERLEVEL_TYPE				1042
-#define CAPWAP_ELEMENT_80211_TXPOWERLEVEL					(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_TXPOWERLEVEL_VENDOR, .type = CAPWAP_ELEMENT_80211_TXPOWERLEVEL_TYPE }
-
 
 #define CAPWAP_TXPOWERLEVEL_MAXLENGTH					8
 
@@ -14,6 +11,6 @@ struct capwap_80211_txpowerlevel_element {
 	uint16_t powerlevel[CAPWAP_TXPOWERLEVEL_MAXLENGTH];
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_txpowerlevel_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_txpowerlevel_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_TXPOWERLEVEL_HEADER__ */

src/common/capwap_element_80211_updatestationqos.c

@@ -47,7 +47,7 @@ static void* capwap_80211_updatestationqos_element_parsing(capwap_message_elemen
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 14) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Update Station QoS element");
+		capwap_logging_debug("Invalid IEEE 802.11 Update Station QoS element");
 		return NULL;
 	}
 
@@ -83,10 +83,9 @@ static void capwap_80211_updatestationqos_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_updatestationqos_ops = {
+struct capwap_message_elements_ops capwap_element_80211_updatestationqos_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_SINGLE,
+	.create_message_element = capwap_80211_updatestationqos_element_create,
-	.create = capwap_80211_updatestationqos_element_create,
+	.parsing_message_element = capwap_80211_updatestationqos_element_parsing,
-	.parse = capwap_80211_updatestationqos_element_parsing,
+	.clone_message_element = capwap_80211_updatestationqos_element_clone,
-	.clone = capwap_80211_updatestationqos_element_clone,
+	.free_message_element = capwap_80211_updatestationqos_element_free
-	.free = capwap_80211_updatestationqos_element_free
 };

src/common/capwap_element_80211_updatestationqos.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_UPDATE_STATION_QOS_HEADER__
 #define __CAPWAP_ELEMENT_80211_UPDATE_STATION_QOS_HEADER__
 
-#define CAPWAP_ELEMENT_80211_UPDATE_STATION_QOS_VENDOR		0
+#define CAPWAP_ELEMENT_80211_UPDATE_STATION_QOS		1043
-#define CAPWAP_ELEMENT_80211_UPDATE_STATION_QOS_TYPE		1043
-#define CAPWAP_ELEMENT_80211_UPDATE_STATION_QOS			(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_UPDATE_STATION_QOS_VENDOR, .type = CAPWAP_ELEMENT_80211_UPDATE_STATION_QOS_TYPE }
-
 
 #define CAPWAP_UPDATE_STATION_QOS_SUBELEMENTS				4
 
@@ -22,6 +19,6 @@ struct capwap_80211_updatestationqos_element {
 	struct capwap_80211_updatestationqos_subelement qos[CAPWAP_UPDATE_STATION_QOS_SUBELEMENTS];
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_updatestationqos_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_updatestationqos_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_UPDATE_STATION_QOS_HEADER__ */

src/common/capwap_element_80211_updatewlan.c

@@ -73,7 +73,7 @@ static void* capwap_80211_updatewlan_element_parsing(capwap_message_elements_han
 
 	length = func->read_ready(handle);
 	if (length < 8) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Update WLAN element");
+		capwap_logging_debug("Invalid IEEE 802.11 Update WLAN element");
 		return NULL;
 	}
 
@@ -93,7 +93,7 @@ static void* capwap_80211_updatewlan_element_parsing(capwap_message_elements_han
 
 	if (length != data->keylength) {
 		capwap_80211_updatewlan_element_free((void*)data);
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Update WLAN element");
+		capwap_logging_debug("Invalid IEEE 802.11 Update WLAN element");
 		return NULL;
 	} else if (data->keylength > 0) {
 		data->key = (uint8_t*)capwap_alloc(data->keylength);
@@ -104,10 +104,9 @@ static void* capwap_80211_updatewlan_element_parsing(capwap_message_elements_han
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_updatewlan_ops = {
+struct capwap_message_elements_ops capwap_element_80211_updatewlan_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_SINGLE,
+	.create_message_element = capwap_80211_updatewlan_element_create,
-	.create = capwap_80211_updatewlan_element_create,
+	.parsing_message_element = capwap_80211_updatewlan_element_parsing,
-	.parse = capwap_80211_updatewlan_element_parsing,
+	.clone_message_element = capwap_80211_updatewlan_element_clone,
-	.clone = capwap_80211_updatewlan_element_clone,
+	.free_message_element = capwap_80211_updatewlan_element_free
-	.free = capwap_80211_updatewlan_element_free
 };

src/common/capwap_element_80211_updatewlan.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_UPDATE_WLAN_HEADER__
 #define __CAPWAP_ELEMENT_80211_UPDATE_WLAN_HEADER__
 
-#define CAPWAP_ELEMENT_80211_UPDATE_WLAN_VENDOR				0
+#define CAPWAP_ELEMENT_80211_UPDATE_WLAN				1044
-#define CAPWAP_ELEMENT_80211_UPDATE_WLAN_TYPE				1044
-#define CAPWAP_ELEMENT_80211_UPDATE_WLAN					(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_UPDATE_WLAN_VENDOR, .type = CAPWAP_ELEMENT_80211_UPDATE_WLAN_TYPE }
-
 
 #define CAPWAP_UPDATE_WLAN_CAPABILITY_ESS				0x8000
 #define CAPWAP_UPDATE_WLAN_CAPABILITY_IBSS				0x4000
@@ -37,6 +34,6 @@ struct capwap_80211_updatewlan_element {
 	uint8_t* key;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_updatewlan_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_updatewlan_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_UPDATE_WLAN_HEADER__ */

src/common/capwap_element_80211_wtpqos.c

@@ -51,7 +51,7 @@ static void* capwap_80211_wtpqos_element_parsing(capwap_message_elements_handle
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 34) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 WTP QoS element");
+		capwap_logging_debug("Invalid IEEE 802.11 WTP QoS element");
 		return NULL;
 	}
 
@@ -91,10 +91,9 @@ static void capwap_80211_wtpqos_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_wtpqos_ops = {
+struct capwap_message_elements_ops capwap_element_80211_wtpqos_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_ARRAY,
+	.create_message_element = capwap_80211_wtpqos_element_create,
-	.create = capwap_80211_wtpqos_element_create,
+	.parsing_message_element = capwap_80211_wtpqos_element_parsing,
-	.parse = capwap_80211_wtpqos_element_parsing,
+	.clone_message_element = capwap_80211_wtpqos_element_clone,
-	.clone = capwap_80211_wtpqos_element_clone,
+	.free_message_element = capwap_80211_wtpqos_element_free
-	.free = capwap_80211_wtpqos_element_free
 };

src/common/capwap_element_80211_wtpqos.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_WTP_QOS_HEADER__
 #define __CAPWAP_ELEMENT_80211_WTP_QOS_HEADER__
 
-#define CAPWAP_ELEMENT_80211_WTP_QOS_VENDOR				0
+#define CAPWAP_ELEMENT_80211_WTP_QOS				1045
-#define CAPWAP_ELEMENT_80211_WTP_QOS_TYPE				1045
-#define CAPWAP_ELEMENT_80211_WTP_QOS					(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_WTP_QOS_VENDOR, .type = CAPWAP_ELEMENT_80211_WTP_QOS_TYPE }
-
 
 #define CAPWAP_WTP_QOS_SUBELEMENT_VOICE				0
 #define CAPWAP_WTP_QOS_SUBELEMENT_VIDEO				1
@@ -32,6 +29,6 @@ struct capwap_80211_wtpqos_element {
 	struct capwap_80211_wtpqos_subelement qos[CAPWAP_WTP_QOS_SUBELEMENTS];
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_wtpqos_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_wtpqos_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_WTP_QOS_HEADER__ */

src/common/capwap_element_80211_wtpradioconf.c

@@ -44,7 +44,7 @@ static void* capwap_80211_wtpradioconf_element_parsing(capwap_message_elements_h
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 16) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 WTP WLAN Radio Configuration element");
+		capwap_logging_debug("Invalid IEEE 802.11 WTP WLAN Radio Configuration element");
 		return NULL;
 	}
 
@@ -79,10 +79,9 @@ static void capwap_80211_wtpradioconf_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_wtpradioconf_ops = {
+struct capwap_message_elements_ops capwap_element_80211_wtpradioconf_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_ARRAY,
+	.create_message_element = capwap_80211_wtpradioconf_element_create,
-	.create = capwap_80211_wtpradioconf_element_create,
+	.parsing_message_element = capwap_80211_wtpradioconf_element_parsing,
-	.parse = capwap_80211_wtpradioconf_element_parsing,
+	.clone_message_element = capwap_80211_wtpradioconf_element_clone,
-	.clone = capwap_80211_wtpradioconf_element_clone,
+	.free_message_element = capwap_80211_wtpradioconf_element_free
-	.free = capwap_80211_wtpradioconf_element_free
 };

src/common/capwap_element_80211_wtpradioconf.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_WTP_RADIO_CONF_HEADER__
 #define __CAPWAP_ELEMENT_80211_WTP_RADIO_CONF_HEADER__
 
-#define CAPWAP_ELEMENT_80211_WTP_RADIO_CONF_VENDOR					0
+#define CAPWAP_ELEMENT_80211_WTP_RADIO_CONF					1046
-#define CAPWAP_ELEMENT_80211_WTP_RADIO_CONF_TYPE					1046
-#define CAPWAP_ELEMENT_80211_WTP_RADIO_CONF						(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_WTP_RADIO_CONF_VENDOR, .type = CAPWAP_ELEMENT_80211_WTP_RADIO_CONF_TYPE }
-
 
 #define CAPWAP_WTP_RADIO_CONF_COUNTRY_LENGTH				4
 
@@ -21,6 +18,6 @@ struct capwap_80211_wtpradioconf_element {
 	uint8_t country[CAPWAP_WTP_RADIO_CONF_COUNTRY_LENGTH];
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_wtpradioconf_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_wtpradioconf_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_WTP_RADIO_CONF_HEADER__ */

src/common/capwap_element_80211_wtpradiofailalarm.c

@@ -35,7 +35,7 @@ static void* capwap_80211_wtpradiofailalarm_element_parsing(capwap_message_eleme
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 4) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 WTP Radio Fail Alarm Indication element");
+		capwap_logging_debug("Invalid IEEE 802.11 WTP Radio Fail Alarm Indication element");
 		return NULL;
 	}
 
@@ -67,10 +67,9 @@ static void capwap_80211_wtpradiofailalarm_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_wtpradiofailalarm_ops = {
+struct capwap_message_elements_ops capwap_element_80211_wtpradiofailalarm_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_SINGLE,
+	.create_message_element = capwap_80211_wtpradiofailalarm_element_create,
-	.create = capwap_80211_wtpradiofailalarm_element_create,
+	.parsing_message_element = capwap_80211_wtpradiofailalarm_element_parsing,
-	.parse = capwap_80211_wtpradiofailalarm_element_parsing,
+	.clone_message_element = capwap_80211_wtpradiofailalarm_element_clone,
-	.clone = capwap_80211_wtpradiofailalarm_element_clone,
+	.free_message_element = capwap_80211_wtpradiofailalarm_element_free
-	.free = capwap_80211_wtpradiofailalarm_element_free
 };

src/common/capwap_element_80211_wtpradiofailalarm.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM_HEADER__
 #define __CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM_HEADER__
 
-#define CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM_VENDOR			0
+#define CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM			1047
-#define CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM_TYPE			1047
-#define CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM				(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM_VENDOR, .type = CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM_TYPE }
-
 
 #define CAPWAP_WTP_RADIO_FAIL_ALARM_TYPE_RECEIVER			1
 #define CAPWAP_WTP_RADIO_FAIL_ALARM_TYPE_TRANSMITTER		2
@@ -16,6 +13,6 @@ struct capwap_80211_wtpradiofailalarm_element {
 	uint8_t pad;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_wtpradiofailalarm_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_wtpradiofailalarm_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_WTP_RADIO_FAIL_ALARM_HEADER__ */

src/common/capwap_element_80211_wtpradioinformation.c

@@ -36,7 +36,7 @@ static void* capwap_80211_wtpradioinformation_element_parsing(capwap_message_ele
 	ASSERT(func != NULL);
 
 	if (func->read_ready(handle) != 5) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11 WTP Radio Information element");
+		capwap_logging_debug("Invalid IEEE 802.11 WTP Radio Information element");
 		return NULL;
 	}
 
@@ -66,10 +66,9 @@ static void capwap_80211_wtpradioinformation_element_free(void* data) {
 }
 
 /* */
-const struct capwap_message_elements_ops capwap_element_80211_wtpradioinformation_ops = {
+struct capwap_message_elements_ops capwap_element_80211_wtpradioinformation_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_ARRAY,
+	.create_message_element = capwap_80211_wtpradioinformation_element_create,
-	.create = capwap_80211_wtpradioinformation_element_create,
+	.parsing_message_element = capwap_80211_wtpradioinformation_element_parsing,
-	.parse = capwap_80211_wtpradioinformation_element_parsing,
+	.clone_message_element = capwap_80211_wtpradioinformation_element_clone,
-	.clone = capwap_80211_wtpradioinformation_element_clone,
+	.free_message_element = capwap_80211_wtpradioinformation_element_free
-	.free = capwap_80211_wtpradioinformation_element_free
 };

src/common/capwap_element_80211_wtpradioinformation.h

@@ -1,10 +1,7 @@
 #ifndef __CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION_HEADER__
 #define __CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION_HEADER__
 
-#define CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION_VENDOR			0
+#define CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION			1048
-#define CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION_TYPE			1048
-#define CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION				(struct capwap_message_element_id){ .vendor = CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION_VENDOR, .type = CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION_TYPE }
-
 
 #define CAPWAP_RADIO_TYPE_80211B			0x00000001
 #define CAPWAP_RADIO_TYPE_80211A			0x00000002
@@ -17,6 +14,6 @@ struct capwap_80211_wtpradioinformation_element {
 	uint32_t radiotype;
 };
 
-extern const struct capwap_message_elements_ops capwap_element_80211_wtpradioinformation_ops;
+extern struct capwap_message_elements_ops capwap_element_80211_wtpradioinformation_ops;
 
 #endif /* __CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION_HEADER__ */

src/common/capwap_element_80211n_radioconf.c

@@ -1,93 +0,0 @@
-#include "capwap.h"
-#include "capwap_element.h"
-
-/*
- *    0                   1                   2                   3
- *    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
- *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
- *   |    Radio ID   |S|P|N|G|B|     |    MaxSup MCS | Max MandMCS   |
- *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
- *   |    TxAntenna  |    RxAntenna  |         Reserved              |
- *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
- *
- * Type:   TBD1 for IEEE 802.11n WLAN Radio Configuration
- *
- */
-
-/* */
-static void
-capwap_80211n_radioconf_element_create(void *data,
-				       capwap_message_elements_handle handle,
-				       struct capwap_write_message_elements_ops *func)
-{
-	struct capwap_80211n_radioconf_element *element = (struct capwap_80211n_radioconf_element *)data;
-
-	ASSERT(data != NULL);
-
-	func->write_u8(handle, element->radioid);
-	func->write_u8(handle, element->flags & CAPWAP_80211N_RADIO_CONF_MASK);
-	func->write_u8(handle, element->maxsupmcs);
-	func->write_u8(handle, element->maxmandmcs);
-	func->write_u8(handle, element->txant);
-	func->write_u8(handle, element->rxant);
-	func->write_u16(handle, 0);
-}
-
-/* */
-static void *
-capwap_80211n_radioconf_element_parsing(capwap_message_elements_handle handle,
-					struct capwap_read_message_elements_ops *func)
-{
-	struct capwap_80211n_radioconf_element *data;
-	uint16_t reserved;
-
-	ASSERT(handle != NULL);
-	ASSERT(func != NULL);
-
-	if (func->read_ready(handle) != 8) {
-		log_printf(LOG_DEBUG, "Invalid IEEE 802.11n Radio Configuration element");
-		return NULL;
-	}
-
-	/* */
-	data = (struct capwap_80211n_radioconf_element*)capwap_alloc(sizeof(struct capwap_80211n_radioconf_element));
-	memset(data, 0, sizeof(struct capwap_80211n_radioconf_element));
-
-	/* Retrieve data */
-	func->read_u8(handle, &data->radioid);
-	func->read_u8(handle, &data->flags);
-	func->read_u8(handle, &data->maxsupmcs);
-	func->read_u8(handle, &data->maxmandmcs);
-	func->read_u8(handle, &data->txant);
-	func->read_u8(handle, &data->rxant);
-	func->read_u16(handle, &reserved);
-
-	return data;
-}
-
-/* */
-static void *
-capwap_80211n_radioconf_element_clone(void *data)
-{
-	ASSERT(data != NULL);
-
-	return capwap_clone(data, sizeof(struct capwap_80211n_radioconf_element));
-}
-
-/* */
-static void
-capwap_80211n_radioconf_element_free(void* data)
-{
-	ASSERT(data != NULL);
-
-	capwap_free(data);
-}
-
-/* */
-const struct capwap_message_elements_ops capwap_element_80211n_radioconf_ops = {
-	.category = CAPWAP_MESSAGE_ELEMENT_ARRAY,
-	.create = capwap_80211n_radioconf_element_create,
-	.parse = capwap_80211n_radioconf_element_parsing,
-	.clone = capwap_80211n_radioconf_element_clone,
-	.free = capwap_80211n_radioconf_element_free
-};