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

Improve memory administration for tx/rx packet manager

Browse Source
This commit is contained in:
vemax78
2013-05-27 21:33:23 +02:00
parent 9157cc278b
commit 6c55b4d71f
126 changed files with 5383 additions and 7894 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/common/capwap_dtls.c
View File

@ -295,6 +295,12 @@ int capwap_crypt_init() {
/* */
void capwap_crypt_free() {
/* Clear error queue */
ERR_clear_error();
ERR_remove_state(0);
ERR_remove_thread_state(NULL);
/* */
#ifdef CAPWAP_MULTITHREADING_ENABLE
int i;
int numlocks;
@ -313,20 +319,17 @@ void capwap_crypt_free() {
capwap_free(l_mutex_buffer);
l_mutex_buffer = NULL;
#endif
/* */
ERR_remove_state(0);
ERR_free_strings();
RAND_cleanup();
ENGINE_cleanup();
EVP_cleanup();
OBJ_cleanup();
CONF_modules_finish();
CONF_modules_free();
CONF_modules_unload(1);
CRYPTO_cleanup_all_ex_data();
sk_SSL_COMP_free (SSL_COMP_get_compression_methods());
}
@ -637,7 +640,9 @@ int capwap_crypt_createsession(struct capwap_dtls* dtls, int sessiontype, struct
/* */
SSL_set_read_ahead((SSL*)dtls->sslsession, 1);
/* */
ERR_clear_error();
if (dtlscontext->type == CAPWAP_DTLS_SERVER) {
SSL_set_accept_state((SSL*)dtls->sslsession);
} else {
@ -706,7 +711,7 @@ int capwap_crypt_open(struct capwap_dtls* dtls, struct sockaddr_storage* peeradd
void capwap_crypt_close(struct capwap_dtls* dtls) {
ASSERT(dtls != NULL);
ASSERT(dtls->enable != 0);
if ((dtls->action == CAPWAP_DTLS_ACTION_DATA) || (dtls->action == CAPWAP_DTLS_ACTION_SHUTDOWN)) {
SSL_shutdown((SSL*)dtls->sslsession);
}
@ -751,7 +756,7 @@ void capwap_crypt_change_dtls(struct capwap_dtls* dtls, struct capwap_dtls* newd
/* */
void capwap_crypt_freesession(struct capwap_dtls* dtls) {
ASSERT(dtls != NULL);
/* Free SSL session */
if (dtls->sslsession) {
struct capwap_app_data* appdata = (struct capwap_app_data*)SSL_get_ex_data(dtls->sslsession, 0);
@ -761,7 +766,13 @@ void capwap_crypt_freesession(struct capwap_dtls* dtls) {
SSL_free((SSL*)dtls->sslsession);
}
/* */
ERR_clear_error();
ERR_remove_state(0);
ERR_remove_thread_state(NULL);
/* */
memset(dtls, 0, sizeof(struct capwap_dtls));
}
@ -785,6 +796,31 @@ int capwap_crypt_sendto(struct capwap_dtls* dtls, int sock, void* buffer, int si
return SSL_write((SSL*)dtls->sslsession, buffer, size);
}
/* */
int capwap_crypt_sendto_fragmentpacket(struct capwap_dtls* dtls, int sock, struct capwap_list* fragmentlist, struct sockaddr_storage* sendfromaddr, struct sockaddr_storage* sendtoaddr) {
struct capwap_list_item* item;
ASSERT(sock >= 0);
ASSERT(fragmentlist != NULL);
ASSERT(sendtoaddr != NULL);
item = fragmentlist->first;
while (item) {
struct capwap_fragment_packet_item* fragmentpacket = (struct capwap_fragment_packet_item*)item->item;
ASSERT(fragmentpacket != NULL);
ASSERT(fragmentpacket->offset > 0);
if (!capwap_crypt_sendto(dtls, sock, fragmentpacket->buffer, fragmentpacket->offset, sendfromaddr, sendtoaddr)) {
return 0;
}
/* */
item = item->next;
}
return 1;
}
/* */
int capwap_decrypt_packet(struct capwap_dtls* dtls, void* encrybuffer, int size, void* plainbuffer, int maxsize) {
int sslerror;

3
src/common/capwap_dtls.h
View File

@ -1,6 +1,8 @@
#ifndef __CAPWAP_DTLS_HEADER__
#define __CAPWAP_DTLS_HEADER__
#include "capwap_list.h"
#define CAPWAP_DTLS_CLIENT 0
#define CAPWAP_DTLS_SERVER 1
@ -106,6 +108,7 @@ void capwap_crypt_change_bio_send(struct capwap_dtls* dtls, capwap_bio_send bios
void capwap_crypt_change_dtls(struct capwap_dtls* dtls, struct capwap_dtls* newdtls);
int capwap_crypt_sendto(struct capwap_dtls* dtls, int sock, void* buffer, int size, struct sockaddr_storage* sendfromaddr, struct sockaddr_storage* sendtoaddr);
int capwap_crypt_sendto_fragmentpacket(struct capwap_dtls* dtls, int sock, struct capwap_list* fragmentlist, struct sockaddr_storage* sendfromaddr, struct sockaddr_storage* sendtoaddr);
int capwap_decrypt_packet(struct capwap_dtls* dtls, void* encrybuffer, int size, void* plainbuffer, int maxsize);
#endif /* __CAPWAP_DTLS_HEADER__ */

2105
src/common/capwap_element.c
View File

File diff suppressed because it is too large Load Diff

268
src/common/capwap_element.h
View File

@ -1,6 +1,7 @@
#ifndef __CAPWAP_ELEMENT_HEADER__
#define __CAPWAP_ELEMENT_HEADER__
#include "capwap_rfc.h"
#include "capwap_array.h"
#include "capwap_list.h"
@ -16,26 +17,33 @@
#define CAPWAP_80211_MESSAGE_ELEMENTS_COUNT ((CAPWAP_80211_MESSAGE_ELEMENTS_STOP - CAPWAP_80211_MESSAGE_ELEMENTS_START) + 1)
#define IS_80211_MESSAGE_ELEMENTS(x) (((x >= CAPWAP_80211_MESSAGE_ELEMENTS_START) && (x <= CAPWAP_80211_MESSAGE_ELEMENTS_STOP)) ? 1 : 0)
/* Message element */
struct capwap_message_element {
unsigned short type;
unsigned short length;
char data[0];
} __attribute__((__packed__));
typedef struct capwap_message_element*(*capwap_create_message_element)(void* data, unsigned long length);
typedef int(*capwap_validate_message_element)(struct capwap_message_element* element);
typedef void*(*capwap_parsing_message_element)(struct capwap_message_element* element);
typedef void(*capwap_free_message_element)(void*);
struct capwap_message_elements_func {
capwap_create_message_element create;
capwap_validate_message_element check;
capwap_parsing_message_element parsing;
capwap_free_message_element free;
/* */
typedef void* capwap_message_elements_handle;
struct capwap_write_message_elements_ops {
int (*write_u8)(capwap_message_elements_handle handle, uint8_t data);
int (*write_u16)(capwap_message_elements_handle handle, uint16_t data);
int (*write_u32)(capwap_message_elements_handle handle, uint32_t data);
int (*write_block)(capwap_message_elements_handle handle, uint8_t* data, unsigned short length);
};
struct capwap_message_elements_func* capwap_get_message_element(unsigned long code);
struct capwap_read_message_elements_ops {
unsigned short (*read_ready)(capwap_message_elements_handle handle);
int (*read_u8)(capwap_message_elements_handle handle, uint8_t* data);
int (*read_u16)(capwap_message_elements_handle handle, uint16_t* data);
int (*read_u32)(capwap_message_elements_handle handle, uint32_t* data);
int (*read_block)(capwap_message_elements_handle handle, uint8_t* data, unsigned short length);
};
struct capwap_message_elements_ops {
/* Build message element */
void (*create_message_element)(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func);
/* Parsing message element */
void* (*parsing_message_element)(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func);
void (*free_parsed_message_element)(void*);
};
struct capwap_message_elements_ops* capwap_get_message_element_ops(unsigned short code);
/*********************************************************************************************************************/
/* Standard message elements */
@ -106,192 +114,66 @@ struct capwap_message_elements_func* capwap_get_message_element(unsigned long co
#include "capwap_element_80211_wtpradioinformation.h" /* 01048 */
/*********************************************************************************************************************/
struct capwap_element_discovery_request {
struct capwap_discoverytype_element* discoverytype;
struct capwap_wtpboarddata_element* wtpboarddata;
struct capwap_wtpdescriptor_element* wtpdescriptor;
struct capwap_wtpframetunnelmode_element* wtpframetunnel;
struct capwap_wtpmactype_element* wtpmactype;
struct capwap_mtudiscovery_element* mtudiscovery;
struct capwap_vendorpayload_element* vendorpayload;
union {
struct {
struct capwap_array* wtpradioinformation;
} ieee80211;
} binding;
};
void capwap_init_element_discovery_request(struct capwap_element_discovery_request* element, unsigned short binding);
int capwap_parsing_element_discovery_request(struct capwap_element_discovery_request* element, struct capwap_list_item* item);
void capwap_free_element_discovery_request(struct capwap_element_discovery_request* element, unsigned short binding);
/* */
struct capwap_element_discovery_response {
struct capwap_message_elements {
struct capwap_acdescriptor_element* acdescriptor;
struct capwap_acipv4list_element* acipv4list;
struct capwap_acipv6list_element* acipv6list;
struct capwap_acname_element* acname;
struct capwap_array* controlipv4;
struct capwap_array* controlipv6;
struct capwap_vendorpayload_element* vendorpayload;
union {
struct {
struct capwap_array* wtpradioinformation;
} ieee80211;
} binding;
};
void capwap_init_element_discovery_response(struct capwap_element_discovery_response* element, unsigned short binding);
int capwap_parsing_element_discovery_response(struct capwap_element_discovery_response* element, struct capwap_list_item* item);
void capwap_free_element_discovery_response(struct capwap_element_discovery_response* element, unsigned short binding);
/* */
struct capwap_element_join_request {
struct capwap_location_element* locationdata;
struct capwap_wtpboarddata_element* wtpboarddata;
struct capwap_wtpdescriptor_element* wtpdescriptor;
struct capwap_wtpname_element* wtpname;
struct capwap_sessionid_element* sessionid;
struct capwap_wtpframetunnelmode_element* wtpframetunnel;
struct capwap_wtpmactype_element* wtpmactype;
struct capwap_ecnsupport_element* ecnsupport;
struct capwap_localipv4_element* localipv4;
struct capwap_localipv6_element* localipv6;
struct capwap_transport_element* trasport;
struct capwap_maximumlength_element* maxiumlength;
struct capwap_wtprebootstat_element* wtprebootstat;
struct capwap_vendorpayload_element* vendorpayload;
union {
struct {
struct capwap_array* wtpradioinformation;
} ieee80211;
} binding;
};
void capwap_init_element_join_request(struct capwap_element_join_request* element, unsigned short binding);
int capwap_parsing_element_join_request(struct capwap_element_join_request* element, struct capwap_list_item* item);
void capwap_free_element_join_request(struct capwap_element_join_request* element, unsigned short binding);
/* */
struct capwap_element_join_response {
struct capwap_resultcode_element* resultcode;
struct capwap_array* returnedmessage;
struct capwap_acdescriptor_element* acdescriptor;
struct capwap_acname_element* acname;
struct capwap_ecnsupport_element* ecnsupport;
struct capwap_array* controlipv4;
struct capwap_array* controlipv6;
struct capwap_localipv4_element* localipv4;
struct capwap_localipv6_element* localipv6;
capwap_acipv4list_element_array* acipv4list;
capwap_acipv6list_element_array* acipv6list;
struct capwap_transport_element* trasport;
struct capwap_imageidentifier_element* imageidentifier;
struct capwap_maximumlength_element* maxiumlength;
struct capwap_vendorpayload_element* vendorpayload;
union {
struct {
struct capwap_array* wtpradioinformation;
} ieee80211;
} binding;
};
void capwap_init_element_join_response(struct capwap_element_join_response* element, unsigned short binding);
int capwap_parsing_element_join_response(struct capwap_element_join_response* element, struct capwap_list_item* item);
void capwap_free_element_join_response(struct capwap_element_join_response* element, unsigned short binding);
/* */
struct capwap_element_configurationstatus_request {
struct capwap_acname_element* acname;
struct capwap_array* radioadmstatus;
struct capwap_statisticstimer_element* statisticstimer;
struct capwap_wtprebootstat_element* wtprebootstat;
struct capwap_array* acnamepriority;
struct capwap_transport_element* trasport;
struct capwap_wtpstaticipaddress_element* wtpstaticipaddress;
struct capwap_vendorpayload_element* vendorpayload;
};
void capwap_init_element_configurationstatus_request(struct capwap_element_configurationstatus_request* element, unsigned short binding);
int capwap_parsing_element_configurationstatus_request(struct capwap_element_configurationstatus_request* element, struct capwap_list_item* item);
void capwap_free_element_configurationstatus_request(struct capwap_element_configurationstatus_request* element, unsigned short binding);
/* */
struct capwap_element_configurationstatus_response {
struct capwap_array* controlipv4;
struct capwap_array* controlipv6;
struct capwap_timers_element* timers;
struct capwap_array* decrypterrorresultperiod;
struct capwap_array* decrypterrorreportperiod;
struct capwap_discoverytype_element* discoverytype;
struct capwap_idletimeout_element* idletimeout;
struct capwap_wtpfallback_element* wtpfallback;
capwap_acipv4list_element_array* acipv4list;
capwap_acipv6list_element_array* acipv6list;
struct capwap_array* radiooprstatus;
struct capwap_wtpstaticipaddress_element* wtpstaticipaddress;
struct capwap_vendorpayload_element* vendorpayload;
};
void capwap_init_element_configurationstatus_response(struct capwap_element_configurationstatus_response* element, unsigned short binding);
int capwap_parsing_element_configurationstatus_response(struct capwap_element_configurationstatus_response* element, struct capwap_list_item* item);
void capwap_free_element_configurationstatus_response(struct capwap_element_configurationstatus_response* element, unsigned short binding);
/* */
struct capwap_element_changestateevent_request {
struct capwap_array* radiooprstatus;
struct capwap_imageidentifier_element* imageidentifier;
struct capwap_location_element* location;
struct capwap_maximumlength_element* maximumlength;
struct capwap_localipv4_element* localipv4;
struct capwap_array* radioadmstate;
struct capwap_array* radiooprstate;
struct capwap_resultcode_element* resultcode;
struct capwap_array* returnedmessage;
struct capwap_sessionid_element* sessionid;
struct capwap_statisticstimer_element* statisticstimer;
struct capwap_vendorpayload_element* vendorpayload;
struct capwap_wtpboarddata_element* wtpboarddata;
struct capwap_wtpdescriptor_element* wtpdescriptor;
struct capwap_wtpfallback_element* wtpfallback;
struct capwap_wtpframetunnelmode_element* wtpframetunnel;
struct capwap_wtpmactype_element* wtpmactype;
struct capwap_wtpname_element* wtpname;
struct capwap_wtprebootstat_element* wtprebootstat;
struct capwap_wtpstaticipaddress_element* wtpstaticipaddress;
struct capwap_localipv6_element* localipv6;
struct capwap_transport_element* transport;
struct capwap_mtudiscovery_element* mtudiscovery;
struct capwap_ecnsupport_element* ecnsupport;
union {
struct {
struct capwap_array* antenna;
struct capwap_array* directsequencecontrol;
struct capwap_array* macoperation;
struct capwap_array* multidomaincapability;
struct capwap_array* ofdmcontrol;
struct capwap_array* rateset;
struct capwap_array* supportedrates;
struct capwap_array* txpower;
struct capwap_array* txpowerlevel;
struct capwap_array* wtpradioinformation;
} ieee80211;
};
};
void capwap_init_element_changestateevent_request(struct capwap_element_changestateevent_request* element, unsigned short binding);
int capwap_parsing_element_changestateevent_request(struct capwap_element_changestateevent_request* element, struct capwap_list_item* item);
void capwap_free_element_changestateevent_request(struct capwap_element_changestateevent_request* element, unsigned short binding);
/* */
struct capwap_element_changestateevent_response {
struct capwap_vendorpayload_element* vendorpayload;
struct capwap_parsed_packet {
struct capwap_packet_rxmng* rxmngpacket;
struct capwap_connection* connection;
struct capwap_message_elements messageelements;
};
void capwap_init_element_changestateevent_response(struct capwap_element_changestateevent_response* element, unsigned short binding);
int capwap_parsing_element_changestateevent_response(struct capwap_element_changestateevent_response* element, struct capwap_list_item* item);
void capwap_free_element_changestateevent_response(struct capwap_element_changestateevent_response* element, unsigned short binding);
/* */
struct capwap_element_echo_request {
struct capwap_vendorpayload_element* vendorpayload;
};
void capwap_init_element_echo_request(struct capwap_element_echo_request* element, unsigned short binding);
int capwap_parsing_element_echo_request(struct capwap_element_echo_request* element, struct capwap_list_item* item);
void capwap_free_element_echo_request(struct capwap_element_echo_request* element, unsigned short binding);
/* */
struct capwap_element_echo_response {
struct capwap_vendorpayload_element* vendorpayload;
};
void capwap_init_element_echo_response(struct capwap_element_echo_response* element, unsigned short binding);
int capwap_parsing_element_echo_response(struct capwap_element_echo_response* element, struct capwap_list_item* item);
void capwap_free_element_echo_response(struct capwap_element_echo_response* element, unsigned short binding);
/* */
struct capwap_element_reset_request {
struct capwap_imageidentifier_element* imageidentifier;
struct capwap_vendorpayload_element* vendorpayload;
};
void capwap_init_element_reset_request(struct capwap_element_reset_request* element, unsigned short binding);
int capwap_parsing_element_reset_request(struct capwap_element_reset_request* element, struct capwap_list_item* item);
void capwap_free_element_reset_request(struct capwap_element_reset_request* element, unsigned short binding);
/* */
struct capwap_element_reset_response {
struct capwap_resultcode_element* resultcode;
struct capwap_vendorpayload_element* vendorpayload;
};
void capwap_init_element_reset_response(struct capwap_element_reset_response* element, unsigned short binding);
int capwap_parsing_element_reset_response(struct capwap_element_reset_response* element, struct capwap_list_item* item);
void capwap_free_element_reset_response(struct capwap_element_reset_response* element, unsigned short binding);
int capwap_parsing_packet(struct capwap_packet_rxmng* rxmngpacket, struct capwap_connection* connection, struct capwap_parsed_packet* packet);
int capwap_validate_parsed_packet(struct capwap_parsed_packet* packet, struct capwap_array* returnedmessage);
void capwap_free_parsed_packet(struct capwap_parsed_packet* packet);
#endif /* __CAPWAP_ELEMENT_HEADER__ */

106
src/common/capwap_element_80211_antenna.c
View File

@ -17,98 +17,74 @@ Length: >= 5
********************************************************************/
struct capwap_80211_antenna_raw_element {
unsigned char radioid;
unsigned char diversity;
unsigned char combiner;
unsigned char antennacount;
unsigned char antennaselections[0];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_80211_antenna_element_create(void* data, unsigned long datalength) {
int i;
unsigned short antennalength;
struct capwap_message_element* element;
struct capwap_80211_antenna_raw_element* dataraw;
struct capwap_80211_antenna_element* dataelement = (struct capwap_80211_antenna_element*)data;
static void capwap_80211_antenna_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_80211_antenna_element* element = (struct capwap_80211_antenna_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_80211_antenna_element));
/* Alloc block of memory */
antennalength = dataelement->antennacount * sizeof(unsigned char);
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_antenna_raw_element) + antennalength);
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_antenna_raw_element) + antennalength);
element->type = htons(CAPWAP_ELEMENT_80211_ANTENNA);
element->length = htons(sizeof(struct capwap_80211_antenna_raw_element) + antennalength);
dataraw = (struct capwap_80211_antenna_raw_element*)element->data;
dataraw->radioid = dataelement->radioid;
dataraw->diversity = dataelement->diversity;
dataraw->combiner = dataelement->combiner;
dataraw->antennacount = dataelement->antennacount;
for (i = 0; i < dataelement->antennacount; i++) {
dataraw->antennaselections[i] = dataelement->antennaselections[i];
}
return element;
func->write_u8(handle, element->radioid);
func->write_u8(handle, element->diversity);
func->write_u8(handle, element->combiner);
func->write_u8(handle, element->antennacount);
func->write_block(handle, element->antennaselections, element->antennacount);
}
/* */
int capwap_80211_antenna_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_80211_antenna_element_parsing(struct capwap_message_element* element) {
int i;
unsigned short antennalength;
static void* capwap_80211_antenna_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_80211_antenna_element* data;
struct capwap_80211_antenna_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_80211_ANTENNA);
antennalength = ntohs(element->length);
if (antennalength < 5) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if (length < 5) {
capwap_logging_debug("Invalid IEEE 802.11 Antenna element");
return NULL;
}
antennalength -= sizeof(struct capwap_80211_antenna_raw_element);
if (antennalength > CAPWAP_ANTENNASELECTIONS_MAXLENGTH) {
length -= 4;
if (length > CAPWAP_ANTENNASELECTIONS_MAXLENGTH) {
capwap_logging_debug("Invalid IEEE 802.11 Antenna element");
return NULL;
}
dataraw = (struct capwap_80211_antenna_raw_element*)element->data;
/* */
data = (struct capwap_80211_antenna_element*)capwap_alloc(sizeof(struct capwap_80211_antenna_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->radioid = dataraw->radioid;
data->diversity = dataraw->diversity;
data->combiner = dataraw->combiner;
data->antennacount = dataraw->antennacount;
for (i = 0; i < dataraw->antennacount; i++) {
data->antennaselections[i] = dataraw->antennaselections[i];
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_80211_antenna_element));
func->read_u8(handle, &data->radioid);
func->read_u8(handle, &data->diversity);
func->read_u8(handle, &data->combiner);
func->read_u8(handle, &data->antennacount);
/* Check */
if (data->antennacount != length) {
capwap_logging_debug("Invalid IEEE 802.11 Antenna element");
capwap_free(data);
return NULL;
}
func->read_block(handle, data->antennaselections, length);
return data;
}
/* */
void capwap_80211_antenna_element_free(void* data) {
static void capwap_80211_antenna_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_80211_antenna_ops = {
.create_message_element = capwap_80211_antenna_element_create,
.parsing_message_element = capwap_80211_antenna_element_parsing,
.free_parsed_message_element = capwap_80211_antenna_element_free
};

31
src/common/capwap_element_80211_antenna.h
View File

@ -3,16 +3,6 @@
#define CAPWAP_ELEMENT_80211_ANTENNA 1025
#define CAPWAP_ANTENNASELECTIONS_MAXLENGTH 255
struct capwap_80211_antenna_element {
unsigned char radioid;
unsigned char diversity;
unsigned char combiner;
unsigned char antennacount;
unsigned char antennaselections[CAPWAP_ANTENNASELECTIONS_MAXLENGTH];
};
#define CAPWAP_ANTENNA_DIVERSITY_DISABLE 0
#define CAPWAP_ANTENNA_DIVERSITY_ENABLE 1
@ -24,15 +14,16 @@ struct capwap_80211_antenna_element {
#define CAPWAP_ANTENNA_INTERNAL 1
#define CAPWAP_ANTENNA_EXTERNAL 2
struct capwap_message_element* capwap_80211_antenna_element_create(void* data, unsigned long length);
int capwap_80211_antenna_element_validate(struct capwap_message_element* element);
void* capwap_80211_antenna_element_parsing(struct capwap_message_element* element);
void capwap_80211_antenna_element_free(void* data);
#define CAPWAP_ANTENNASELECTIONS_MAXLENGTH 255
struct capwap_80211_antenna_element {
uint8_t radioid;
uint8_t diversity;
uint8_t combiner;
uint8_t antennacount;
uint8_t antennaselections[CAPWAP_ANTENNASELECTIONS_MAXLENGTH];
};
extern struct capwap_message_elements_ops capwap_element_80211_antenna_ops;
/* Helper */
#define CAPWAP_CREATE_80211_ANTENNA_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_80211_ANTENNA); \
f->create(x, sizeof(struct capwap_80211_antenna_element)); \
})
#endif /* __CAPWAP_ELEMENT_80211_ANTENNA_HEADER__ */

78
src/common/capwap_element_80211_directsequencecontrol.c
View File

@ -17,79 +17,59 @@ Length: 8
********************************************************************/
struct capwap_80211_directsequencecontrol_raw_element {
unsigned char radioid;
unsigned char reserved;
unsigned char currentchannel;
unsigned char currentcca;
unsigned long enerydetectthreshold;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_80211_dscontrol_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_80211_directsequencecontrol_raw_element* dataraw;
struct capwap_80211_directsequencecontrol_element* dataelement = (struct capwap_80211_directsequencecontrol_element*)data;
static void capwap_80211_directsequencecontrol_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_80211_directsequencecontrol_element* element = (struct capwap_80211_directsequencecontrol_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_80211_directsequencecontrol_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_directsequencecontrol_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_directsequencecontrol_raw_element));
element->type = htons(CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL);
element->length = htons(sizeof(struct capwap_80211_directsequencecontrol_raw_element));
dataraw = (struct capwap_80211_directsequencecontrol_raw_element*)element->data;
dataraw->radioid = dataelement->radioid;
dataraw->currentchannel = dataelement->currentchannel;
dataraw->currentcca = dataelement->currentcca;
dataraw->enerydetectthreshold = htonl(dataelement->enerydetectthreshold);
return element;
/* */
func->write_u8(handle, element->radioid);
func->write_u8(handle, 0);
func->write_u8(handle, element->currentchannel);
func->write_u8(handle, element->currentcca);
func->write_u32(handle, element->enerydetectthreshold);
}
/* */
int capwap_80211_dscontrol_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_80211_dscontrol_element_parsing(struct capwap_message_element* element) {
static void* capwap_80211_directsequencecontrol_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_80211_directsequencecontrol_element* data;
struct capwap_80211_directsequencecontrol_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL);
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (ntohs(element->length) != 8) {
if (func->read_ready(handle) != 8) {
capwap_logging_debug("Invalid IEEE 802.11 Direct Sequence Control element");
return NULL;
}
dataraw = (struct capwap_80211_directsequencecontrol_raw_element*)element->data;
/* */
data = (struct capwap_80211_directsequencecontrol_element*)capwap_alloc(sizeof(struct capwap_80211_directsequencecontrol_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->radioid = dataraw->radioid;
data->currentchannel = dataraw->currentchannel;
data->currentcca = dataraw->currentcca;
data->enerydetectthreshold = ntohl(dataraw->enerydetectthreshold);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_80211_directsequencecontrol_element));
func->read_u8(handle, &data->radioid);
func->read_u8(handle, NULL);
func->read_u8(handle, &data->currentchannel);
func->read_u8(handle, &data->currentcca);
func->read_u32(handle, &data->enerydetectthreshold);
return data;
}
/* */
void capwap_80211_dscontrol_element_free(void* data) {
static void capwap_80211_directsequencecontrol_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_80211_directsequencecontrol_ops = {
.create_message_element = capwap_80211_directsequencecontrol_element_create,
.parsing_message_element = capwap_80211_directsequencecontrol_element_parsing,
.free_parsed_message_element = capwap_80211_directsequencecontrol_element_free
};

25
src/common/capwap_element_80211_directsequencecontrol.h
View File

@ -3,28 +3,19 @@
#define CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL 1028
struct capwap_80211_directsequencecontrol_element {
unsigned char radioid;
unsigned char currentchannel;
unsigned char currentcca;
unsigned long enerydetectthreshold;
};
#define CAPWAP_DSCONTROL_CCA_EDONLY 1
#define CAPWAP_DSCONTROL_CCA_CSONLY 2
#define CAPWAP_DSCONTROL_CCA_EDANDCS 4
#define CAPWAP_DSCONTROL_CCA_CSWITHTIME 8
#define CAPWAP_DSCONTROL_CCA_HRCSANDED 16
struct capwap_message_element* capwap_80211_dscontrol_element_create(void* data, unsigned long length);
int capwap_80211_dscontrol_element_validate(struct capwap_message_element* element);
void* capwap_80211_dscontrol_element_parsing(struct capwap_message_element* element);
void capwap_80211_dscontrol_element_free(void* data);
struct capwap_80211_directsequencecontrol_element {
uint8_t radioid;
uint8_t currentchannel;
uint8_t currentcca;
uint32_t enerydetectthreshold;
};
extern struct capwap_message_elements_ops capwap_element_80211_directsequencecontrol_ops;
/* Helper */
#define CAPWAP_CREATE_80211_DIRECTSEQUENCECONTROL_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL); \
f->create(x, sizeof(struct capwap_80211_directsequencecontrol_element)); \
})
#endif /* __CAPWAP_ELEMENT_80211_DIRECTSEQUENCECONTROL_HEADER__ */

97
src/common/capwap_element_80211_macoperation.c
View File

@ -21,88 +21,65 @@ Length: 16
********************************************************************/
struct capwap_80211_macoperation_raw_element {
unsigned char radioid;
unsigned char reserved;
unsigned short rtsthreshold;
unsigned char shortretry;
unsigned char longretry;
unsigned short fragthreshold;
unsigned long txmsdulifetime;
unsigned long rxmsdulifetime;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_80211_macoperation_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_80211_macoperation_raw_element* dataraw;
struct capwap_80211_macoperation_element* dataelement = (struct capwap_80211_macoperation_element*)data;
static void capwap_80211_macoperation_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_80211_macoperation_element* element = (struct capwap_80211_macoperation_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_80211_macoperation_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_macoperation_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_macoperation_raw_element));
element->type = htons(CAPWAP_ELEMENT_80211_MACOPERATION);
element->length = htons(sizeof(struct capwap_80211_macoperation_raw_element));
dataraw = (struct capwap_80211_macoperation_raw_element*)element->data;
dataraw->radioid = dataelement->radioid;
dataraw->rtsthreshold = htons(dataelement->rtsthreshold);
dataraw->shortretry = dataelement->shortretry;
dataraw->longretry = dataelement->longretry;
dataraw->fragthreshold = htons(dataelement->fragthreshold);
dataraw->txmsdulifetime = htonl(dataelement->txmsdulifetime);
dataraw->rxmsdulifetime = htonl(dataelement->rxmsdulifetime);
return element;
/* */
func->write_u8(handle, element->radioid);
func->write_u8(handle, 0);
func->write_u16(handle, element->rtsthreshold);
func->write_u8(handle, element->shortretry);
func->write_u8(handle, element->longretry);
func->write_u16(handle, element->fragthreshold);
func->write_u32(handle, element->txmsdulifetime);
func->write_u32(handle, element->rxmsdulifetime);
}
/* */
int capwap_80211_macoperation_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_80211_macoperation_element_parsing(struct capwap_message_element* element) {
static void* capwap_80211_macoperation_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_80211_macoperation_element* data;
struct capwap_80211_macoperation_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_80211_MACOPERATION);
if (ntohs(element->length) != 16) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 16) {
capwap_logging_debug("Invalid IEEE 802.11 MAC Operation element");
return NULL;
}
dataraw = (struct capwap_80211_macoperation_raw_element*)element->data;
/* */
data = (struct capwap_80211_macoperation_element*)capwap_alloc(sizeof(struct capwap_80211_macoperation_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->radioid = dataraw->radioid;
data->rtsthreshold = ntohs(dataraw->rtsthreshold);
data->shortretry = dataraw->shortretry;
data->longretry = dataraw->longretry;
data->fragthreshold = ntohs(dataraw->fragthreshold);
data->txmsdulifetime = ntohl(dataraw->txmsdulifetime);
data->rxmsdulifetime = ntohl(dataraw->rxmsdulifetime);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_80211_macoperation_element));
func->read_u8(handle, &data->radioid);
func->read_u8(handle, NULL);
func->read_u16(handle, &data->rtsthreshold);
func->read_u8(handle, &data->shortretry);
func->read_u8(handle, &data->longretry);
func->read_u16(handle, &data->fragthreshold);
func->read_u32(handle, &data->txmsdulifetime);
func->read_u32(handle, &data->rxmsdulifetime);
return data;
}
/* */
void capwap_80211_macoperation_element_free(void* data) {
static void capwap_80211_macoperation_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_80211_macoperation_ops = {
.create_message_element = capwap_80211_macoperation_element_create,
.parsing_message_element = capwap_80211_macoperation_element_parsing,
.free_parsed_message_element = capwap_80211_macoperation_element_free
};

25
src/common/capwap_element_80211_macoperation.h
View File

@ -4,24 +4,15 @@
#define CAPWAP_ELEMENT_80211_MACOPERATION 1030
struct capwap_80211_macoperation_element {
unsigned char radioid;
unsigned short rtsthreshold;
unsigned char shortretry;
unsigned char longretry;
unsigned short fragthreshold;
unsigned long txmsdulifetime;
unsigned long rxmsdulifetime;
uint8_t radioid;
uint16_t rtsthreshold;
uint8_t shortretry;
uint8_t longretry;
uint16_t fragthreshold;
uint32_t txmsdulifetime;
uint32_t rxmsdulifetime;
};
struct capwap_message_element* capwap_80211_macoperation_element_create(void* data, unsigned long length);
int capwap_80211_macoperation_element_validate(struct capwap_message_element* element);
void* capwap_80211_macoperation_element_parsing(struct capwap_message_element* element);
void capwap_80211_macoperation_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_80211_macoperation_ops;
/* Helper */
#define CAPWAP_CREATE_80211_MACOPERATION_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_80211_MACOPERATION); \
f->create(x, sizeof(struct capwap_80211_macoperation_element)); \
})
#endif /* __CAPWAP_ELEMENT_80211_MACOPERATION_HEADER__ */

78
src/common/capwap_element_80211_multidomaincapability.c
View File

@ -17,79 +17,59 @@ Length: 8
********************************************************************/
struct capwap_80211_multidomaincapability_raw_element {
unsigned char radioid;
unsigned char reserved;
unsigned short firstchannel;
unsigned short numberchannels;
unsigned short maxtxpowerlevel;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_80211_multidomaincapability_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_80211_multidomaincapability_raw_element* dataraw;
struct capwap_80211_multidomaincapability_element* dataelement = (struct capwap_80211_multidomaincapability_element*)data;
static void capwap_80211_multidomaincapability_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_80211_multidomaincapability_element* element = (struct capwap_80211_multidomaincapability_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_80211_multidomaincapability_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_multidomaincapability_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_multidomaincapability_raw_element));
element->type = htons(CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY);
element->length = htons(sizeof(struct capwap_80211_multidomaincapability_raw_element));
dataraw = (struct capwap_80211_multidomaincapability_raw_element*)element->data;
dataraw->radioid = dataelement->radioid;
dataraw->firstchannel = htons(dataelement->firstchannel);
dataraw->numberchannels = htons(dataelement->numberchannels);
dataraw->maxtxpowerlevel = htons(dataelement->maxtxpowerlevel);
return element;
/* */
func->write_u8(handle, element->radioid);
func->write_u8(handle, 0);
func->write_u16(handle, element->firstchannel);
func->write_u16(handle, element->numberchannels);
func->write_u16(handle, element->maxtxpowerlevel);
}
/* */
int capwap_80211_multidomaincapability_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_80211_multidomaincapability_element_parsing(struct capwap_message_element* element) {
static void* capwap_80211_multidomaincapability_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_80211_multidomaincapability_element* data;
struct capwap_80211_multidomaincapability_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY);
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (ntohs(element->length) != 8) {
if (func->read_ready(handle) != 8) {
capwap_logging_debug("Invalid IEEE 802.11 Multi-Domain Capability element");
return NULL;
}
dataraw = (struct capwap_80211_multidomaincapability_raw_element*)element->data;
/* */
data = (struct capwap_80211_multidomaincapability_element*)capwap_alloc(sizeof(struct capwap_80211_multidomaincapability_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->radioid = dataraw->radioid;
data->firstchannel = ntohs(dataraw->firstchannel);
data->numberchannels = htons(dataraw->numberchannels);
data->maxtxpowerlevel = htons(dataraw->maxtxpowerlevel);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_80211_multidomaincapability_element));
func->read_u8(handle, &data->radioid);
func->read_u8(handle, NULL);
func->read_u16(handle, &data->firstchannel);
func->read_u16(handle, &data->numberchannels);
func->read_u16(handle, &data->maxtxpowerlevel);
return data;
}
/* */
void capwap_80211_multidomaincapability_element_free(void* data) {
static void capwap_80211_multidomaincapability_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_80211_multidomaincapability_ops = {
.create_message_element = capwap_80211_multidomaincapability_element_create,
.parsing_message_element = capwap_80211_multidomaincapability_element_parsing,
.free_parsed_message_element = capwap_80211_multidomaincapability_element_free
};

19
src/common/capwap_element_80211_multidomaincapability.h
View File

@ -4,21 +4,12 @@
#define CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY 1032
struct capwap_80211_multidomaincapability_element {
unsigned char radioid;
unsigned short firstchannel;
unsigned short numberchannels;
unsigned short maxtxpowerlevel;
uint8_t radioid;
uint16_t firstchannel;
uint16_t numberchannels;
uint16_t maxtxpowerlevel;
};
struct capwap_message_element* capwap_80211_multidomaincapability_element_create(void* data, unsigned long length);
int capwap_80211_multidomaincapability_element_validate(struct capwap_message_element* element);
void* capwap_80211_multidomaincapability_element_parsing(struct capwap_message_element* element);
void capwap_80211_multidomaincapability_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_80211_multidomaincapability_ops;
/* Helper */
#define CAPWAP_CREATE_80211_MULTIDOMAINCAPABILITY_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY); \
f->create(x, sizeof(struct capwap_80211_multidomaincapability_element)); \
})
#endif /* __CAPWAP_ELEMENT_80211_MULTIDOMAINCAPABILITY_HEADER__ */

78
src/common/capwap_element_80211_ofdmcontrol.c
View File

@ -17,79 +17,59 @@ Length: 8
********************************************************************/
struct capwap_80211_ofdmcontrol_raw_element {
unsigned char radioid;
unsigned char reserved;
unsigned char currentchannel;
unsigned char bandsupport;
unsigned long tithreshold;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_80211_ofdmcontrol_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_80211_ofdmcontrol_raw_element* dataraw;
struct capwap_80211_ofdmcontrol_element* dataelement = (struct capwap_80211_ofdmcontrol_element*)data;
static void capwap_80211_ofdmcontrol_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_80211_ofdmcontrol_element* element = (struct capwap_80211_ofdmcontrol_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_80211_ofdmcontrol_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_ofdmcontrol_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_ofdmcontrol_raw_element));
element->type = htons(CAPWAP_ELEMENT_80211_OFDMCONTROL);
element->length = htons(sizeof(struct capwap_80211_ofdmcontrol_raw_element));
dataraw = (struct capwap_80211_ofdmcontrol_raw_element*)element->data;
dataraw->radioid = dataelement->radioid;
dataraw->currentchannel = dataelement->currentchannel;
dataraw->bandsupport = dataelement->bandsupport;
dataraw->tithreshold = htonl(dataelement->tithreshold);
return element;
/* */
func->write_u8(handle, element->radioid);
func->write_u8(handle, 0);
func->write_u8(handle, element->currentchannel);
func->write_u8(handle, element->bandsupport);
func->write_u32(handle, element->tithreshold);
}
/* */
int capwap_80211_ofdmcontrol_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_80211_ofdmcontrol_element_parsing(struct capwap_message_element* element) {
static void* capwap_80211_ofdmcontrol_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_80211_ofdmcontrol_element* data;
struct capwap_80211_ofdmcontrol_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_80211_OFDMCONTROL);
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (ntohs(element->length) != 8) {
if (func->read_ready(handle) != 8) {
capwap_logging_debug("Invalid IEEE 802.11 OFDM Control element");
return NULL;
}
dataraw = (struct capwap_80211_ofdmcontrol_raw_element*)element->data;
/* */
data = (struct capwap_80211_ofdmcontrol_element*)capwap_alloc(sizeof(struct capwap_80211_ofdmcontrol_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->radioid = dataraw->radioid;
data->currentchannel = ntohs(dataraw->currentchannel);
data->bandsupport = ntohs(dataraw->bandsupport);
data->tithreshold = ntohl(dataraw->tithreshold);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_80211_ofdmcontrol_element));
func->read_u8(handle, &data->radioid);
func->read_u8(handle, NULL);
func->read_u8(handle, &data->currentchannel);
func->read_u8(handle, &data->bandsupport);
func->read_u32(handle, &data->tithreshold);
return data;
}
/* */
void capwap_80211_ofdmcontrol_element_free(void* data) {
static void capwap_80211_ofdmcontrol_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_80211_ofdmcontrol_ops = {
.create_message_element = capwap_80211_ofdmcontrol_element_create,
.parsing_message_element = capwap_80211_ofdmcontrol_element_parsing,
.free_parsed_message_element = capwap_80211_ofdmcontrol_element_free
};

25
src/common/capwap_element_80211_ofdmcontrol.h
View File

@ -3,13 +3,6 @@
#define CAPWAP_ELEMENT_80211_OFDMCONTROL 1033
struct capwap_80211_ofdmcontrol_element {
unsigned char radioid;
unsigned char currentchannel;
unsigned char bandsupport;
unsigned long tithreshold;
};
#define CAPWAP_OFDMCONTROL_BAND_515_525 0x01
#define CAPWAP_OFDMCONTROL_BAND_525_535 0x02
#define CAPWAP_OFDMCONTROL_BAND_5725_5825 0x04
@ -18,15 +11,13 @@ struct capwap_80211_ofdmcontrol_element {
#define CAPWAP_OFDMCONTROL_BAND_503_5091 0x20
#define CAPWAP_OFDMCONTROL_BAND_494_499 0x40
struct capwap_message_element* capwap_80211_ofdmcontrol_element_create(void* data, unsigned long length);
int capwap_80211_ofdmcontrol_element_validate(struct capwap_message_element* element);
void* capwap_80211_ofdmcontrol_element_parsing(struct capwap_message_element* element);
void capwap_80211_ofdmcontrol_element_free(void* data);
struct capwap_80211_ofdmcontrol_element {
uint8_t radioid;
uint8_t currentchannel;
uint8_t bandsupport;
uint32_t tithreshold;
};
extern struct capwap_message_elements_ops capwap_element_80211_ofdmcontrol_ops;
/* Helper */
#define CAPWAP_CREATE_80211_OFDMCONTROL_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_80211_OFDMCONTROL); \
f->create(x, sizeof(struct capwap_80211_ofdmcontrol_element)); \
})
#endif /* __CAPWAP_ELEMENT_80211_OFDMCONTROL_HEADER__ */

87
src/common/capwap_element_80211_rateset.c
View File

@ -15,90 +15,61 @@ Length: >= 3
********************************************************************/
struct capwap_80211_rateset_raw_element {
unsigned char radioid;
unsigned char rateset[0];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_80211_rateset_element_create(void* data, unsigned long datalength) {
int i;
unsigned short ratesetlength;
struct capwap_message_element* element;
struct capwap_80211_rateset_raw_element* dataraw;
struct capwap_80211_rateset_element* dataelement = (struct capwap_80211_rateset_element*)data;
static void capwap_80211_rateset_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_80211_rateset_element* element = (struct capwap_80211_rateset_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_80211_rateset_element));
/* Alloc block of memory */
ratesetlength = dataelement->ratesetcount * sizeof(unsigned char);
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_rateset_raw_element) + ratesetlength);
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_rateset_raw_element) + ratesetlength);
element->type = htons(CAPWAP_ELEMENT_80211_RATESET);
element->length = htons(sizeof(struct capwap_80211_rateset_raw_element) + ratesetlength);
dataraw = (struct capwap_80211_rateset_raw_element*)element->data;
dataraw->radioid = dataelement->radioid;
for (i = 0; i < dataelement->ratesetcount; i++) {
dataraw->rateset[i] = dataelement->rateset[i];
}
return element;
func->write_u8(handle, element->radioid);
func->write_block(handle, element->rateset, element->ratesetcount);
}
/* */
int capwap_80211_rateset_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_80211_rateset_element_parsing(struct capwap_message_element* element) {
int i;
unsigned short ratesetlength;
static void* capwap_80211_rateset_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_80211_rateset_element* data;
struct capwap_80211_rateset_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_80211_RATESET);
ratesetlength = ntohs(element->length);
if (ratesetlength < 3) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if (length < 3) {
capwap_logging_debug("Invalid IEEE 802.11 Rate Set element");
return NULL;
}
ratesetlength -= sizeof(struct capwap_80211_rateset_raw_element);
if (ratesetlength > CAPWAP_SUPPORTEDRATES_MAXLENGTH) {
length -= 1;
if (length > CAPWAP_RATESET_MAXLENGTH) {
capwap_logging_debug("Invalid IEEE 802.11 Rate Set element");
return NULL;
}
dataraw = (struct capwap_80211_rateset_raw_element*)element->data;
/* */
data = (struct capwap_80211_rateset_element*)capwap_alloc(sizeof(struct capwap_80211_rateset_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->radioid = dataraw->radioid;
data->ratesetcount = ratesetlength;
for (i = 0; i < ratesetlength; i++) {
data->rateset[i] = dataraw->rateset[i];
}
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_80211_rateset_element));
func->read_u8(handle, &data->radioid);
data->ratesetcount = length;
func->read_block(handle, data->rateset, length);
return data;
}
/* */
void capwap_80211_rateset_element_free(void* data) {
static void capwap_80211_rateset_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_80211_rateset_ops = {
.create_message_element = capwap_80211_rateset_element_create,
.parsing_message_element = capwap_80211_rateset_element_parsing,
.free_parsed_message_element = capwap_80211_rateset_element_free
};

17
src/common/capwap_element_80211_rateset.h
View File

@ -7,20 +7,11 @@
#define CAPWAP_RATESET_MAXLENGTH 8
struct capwap_80211_rateset_element {
unsigned char radioid;
unsigned char ratesetcount;
unsigned char rateset[CAPWAP_RATESET_MAXLENGTH];
uint8_t radioid;
uint8_t ratesetcount;
uint8_t rateset[CAPWAP_RATESET_MAXLENGTH];
};
struct capwap_message_element* capwap_80211_rateset_element_create(void* data, unsigned long length);
int capwap_80211_rateset_element_validate(struct capwap_message_element* element);
void* capwap_80211_rateset_element_parsing(struct capwap_message_element* element);
void capwap_80211_rateset_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_80211_rateset_ops;
/* Helper */
#define CAPWAP_CREATE_80211_RATESET_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_80211_RATESET); \
f->create(x, sizeof(struct capwap_80211_rateset_element)); \
})
#endif /* __CAPWAP_ELEMENT_80211_RATESET_HEADER__ */

87
src/common/capwap_element_80211_supportedrates.c
View File

@ -15,90 +15,61 @@ Length: >= 3
********************************************************************/
struct capwap_80211_supportedrates_raw_element {
unsigned char radioid;
unsigned char supportedrates[0];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_80211_supportedrates_element_create(void* data, unsigned long datalength) {
int i;
unsigned short supportedrateslength;
struct capwap_message_element* element;
struct capwap_80211_supportedrates_raw_element* dataraw;
struct capwap_80211_supportedrates_element* dataelement = (struct capwap_80211_supportedrates_element*)data;
static void capwap_80211_supportedrates_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_80211_supportedrates_element* element = (struct capwap_80211_supportedrates_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_80211_supportedrates_element));
/* Alloc block of memory */
supportedrateslength = dataelement->supportedratescount * sizeof(unsigned char);
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_supportedrates_raw_element) + supportedrateslength);
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_supportedrates_raw_element) + supportedrateslength);
element->type = htons(CAPWAP_ELEMENT_80211_SUPPORTEDRATES);
element->length = htons(sizeof(struct capwap_80211_supportedrates_raw_element) + supportedrateslength);
dataraw = (struct capwap_80211_supportedrates_raw_element*)element->data;
dataraw->radioid = dataelement->radioid;
for (i = 0; i < dataelement->supportedratescount; i++) {
dataraw->supportedrates[i] = dataelement->supportedrates[i];
}
return element;
func->write_u8(handle, element->radioid);
func->write_block(handle, element->supportedrates, element->supportedratescount);
}
/* */
int capwap_80211_supportedrates_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_80211_supportedrates_element_parsing(struct capwap_message_element* element) {
int i;
unsigned short supportedrateslength;
static void* capwap_80211_supportedrates_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_80211_supportedrates_element* data;
struct capwap_80211_supportedrates_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_80211_SUPPORTEDRATES);
supportedrateslength = ntohs(element->length);
if (supportedrateslength < 3) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if (length < 3) {
capwap_logging_debug("Invalid IEEE 802.11 Supported Rates element");
return NULL;
}
supportedrateslength -= sizeof(struct capwap_80211_supportedrates_raw_element);
if (supportedrateslength > CAPWAP_SUPPORTEDRATES_MAXLENGTH) {
length -= 1;
if (length > CAPWAP_RATESET_MAXLENGTH) {
capwap_logging_debug("Invalid IEEE 802.11 Supported Rates element");
return NULL;
}
dataraw = (struct capwap_80211_supportedrates_raw_element*)element->data;
/* */
data = (struct capwap_80211_supportedrates_element*)capwap_alloc(sizeof(struct capwap_80211_supportedrates_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->radioid = dataraw->radioid;
data->supportedratescount = supportedrateslength;
for (i = 0; i < supportedrateslength; i++) {
data->supportedrates[i] = dataraw->supportedrates[i];
}
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_80211_supportedrates_element));
func->read_u8(handle, &data->radioid);
data->supportedratescount = length;
func->read_block(handle, data->supportedrates, length);
return data;
}
/* */
void capwap_80211_supportedrates_element_free(void* data) {
static void capwap_80211_supportedrates_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_80211_supportedrates_ops = {
.create_message_element = capwap_80211_supportedrates_element_create,
.parsing_message_element = capwap_80211_supportedrates_element_parsing,
.free_parsed_message_element = capwap_80211_supportedrates_element_free
};

17
src/common/capwap_element_80211_supportedrates.h
View File

@ -7,20 +7,11 @@
#define CAPWAP_SUPPORTEDRATES_MAXLENGTH 8
struct capwap_80211_supportedrates_element {
unsigned char radioid;
unsigned char supportedratescount;
unsigned char supportedrates[CAPWAP_SUPPORTEDRATES_MAXLENGTH];
uint8_t radioid;
uint8_t supportedratescount;
uint8_t supportedrates[CAPWAP_SUPPORTEDRATES_MAXLENGTH];
};
struct capwap_message_element* capwap_80211_supportedrates_element_create(void* data, unsigned long length);
int capwap_80211_supportedrates_element_validate(struct capwap_message_element* element);
void* capwap_80211_supportedrates_element_parsing(struct capwap_message_element* element);
void capwap_80211_supportedrates_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_80211_supportedrates_ops;
/* Helper */
#define CAPWAP_CREATE_80211_SUPPORTEDRATES_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_80211_SUPPORTEDRATES); \
f->create(x, sizeof(struct capwap_80211_supportedrates_element)); \
})
#endif /* __CAPWAP_ELEMENT_80211_SUPPORTEDRATES_HEADER__ */

73
src/common/capwap_element_80211_txpower.c
View File

@ -15,72 +15,55 @@ Length: 4
********************************************************************/
struct capwap_80211_txpower_raw_element {
unsigned char radioid;
unsigned short currenttxpower;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_80211_txpower_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_80211_txpower_raw_element* dataraw;
struct capwap_80211_txpower_element* dataelement = (struct capwap_80211_txpower_element*)data;
static void capwap_80211_txpower_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_80211_txpower_element* element = (struct capwap_80211_txpower_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_80211_txpower_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_txpower_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_txpower_raw_element));
element->type = htons(CAPWAP_ELEMENT_80211_TXPOWER);
element->length = htons(sizeof(struct capwap_80211_txpower_raw_element));
dataraw = (struct capwap_80211_txpower_raw_element*)element->data;
dataraw->radioid = dataelement->radioid;
dataraw->currenttxpower = htons(dataelement->currenttxpower);
return element;
/* */
func->write_u8(handle, element->radioid);
func->write_u8(handle, 0);
func->write_u16(handle, element->currenttxpower);
}
/* */
int capwap_80211_txpower_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_80211_txpower_element_parsing(struct capwap_message_element* element) {
static void* capwap_80211_txpower_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_80211_txpower_element* data;
struct capwap_80211_txpower_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_80211_TXPOWER);
if (ntohs(element->length) != 4) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 4) {
capwap_logging_debug("Invalid IEEE 802.11 Tx Power element");
return NULL;
}
dataraw = (struct capwap_80211_txpower_raw_element*)element->data;
/* */
data = (struct capwap_80211_txpower_element*)capwap_alloc(sizeof(struct capwap_80211_txpower_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->radioid = dataraw->radioid;
data->currenttxpower = ntohs(dataraw->currenttxpower);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_80211_txpower_element));
func->read_u8(handle, &data->radioid);
func->read_u8(handle, NULL);
func->read_u16(handle, &data->currenttxpower);
return data;
}
/* */
void capwap_80211_txpower_element_free(void* data) {
static void capwap_80211_txpower_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_80211_txpower_ops = {
.create_message_element = capwap_80211_txpower_element_create,
.parsing_message_element = capwap_80211_txpower_element_parsing,
.free_parsed_message_element = capwap_80211_txpower_element_free
};

15
src/common/capwap_element_80211_txpower.h
View File

@ -4,19 +4,10 @@
#define CAPWAP_ELEMENT_80211_TXPOWER 1041
struct capwap_80211_txpower_element {
unsigned char radioid;
unsigned short currenttxpower;
uint8_t radioid;
uint16_t currenttxpower;
};
struct capwap_message_element* capwap_80211_txpower_element_create(void* data, unsigned long length);
int capwap_80211_txpower_element_validate(struct capwap_message_element* element);
void* capwap_80211_txpower_element_parsing(struct capwap_message_element* element);
void capwap_80211_txpower_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_80211_txpower_ops;
/* Helper */
#define CAPWAP_CREATE_80211_TXPOWER_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_80211_TXPOWER); \
f->create(x, sizeof(struct capwap_80211_txpower_element)); \
})
#endif /* __CAPWAP_ELEMENT_80211_TXPOWER_HEADER__ */

99
src/common/capwap_element_80211_txpowerlevel.c
View File

@ -15,73 +15,38 @@ Length: >= 4
********************************************************************/
struct capwap_80211_txpowerlevel_raw_element {
unsigned char radioid;
unsigned char numlevels;
unsigned short powerlevel[0];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_80211_txpowerlevel_element_create(void* data, unsigned long datalength) {
static void capwap_80211_txpowerlevel_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
int i;
unsigned short txpowerlength;
struct capwap_message_element* element;
struct capwap_80211_txpowerlevel_raw_element* dataraw;
struct capwap_80211_txpowerlevel_element* dataelement = (struct capwap_80211_txpowerlevel_element*)data;
struct capwap_80211_txpowerlevel_element* element = (struct capwap_80211_txpowerlevel_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_80211_txpowerlevel_element));
/* Alloc block of memory */
txpowerlength = dataelement->numlevels * sizeof(unsigned char);
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_txpowerlevel_raw_element) + txpowerlength);
if (!element) {
capwap_outofmemory();
func->write_u8(handle, element->radioid);
func->write_u8(handle, element->numlevels);
for (i = 0; i < element->numlevels; i++) {
func->write_u16(handle, element->powerlevel[i]);
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_txpowerlevel_raw_element) + txpowerlength);
element->type = htons(CAPWAP_ELEMENT_80211_TXPOWERLEVEL);
element->length = htons(sizeof(struct capwap_80211_txpowerlevel_raw_element) + txpowerlength);
dataraw = (struct capwap_80211_txpowerlevel_raw_element*)element->data;
dataraw->radioid = dataelement->radioid;
dataraw->numlevels = dataelement->numlevels;
for (i = 0; i < dataelement->numlevels; i++) {
dataraw->powerlevel[i] = htons(dataelement->powerlevel[i]);
}
return element;
}
/* */
int capwap_80211_txpowerlevel_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_80211_txpowerlevel_element_parsing(struct capwap_message_element* element) {
static void* capwap_80211_txpowerlevel_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
int i;
unsigned short txpowerlength;
unsigned short length;
struct capwap_80211_txpowerlevel_element* data;
struct capwap_80211_txpowerlevel_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_80211_TXPOWERLEVEL);
txpowerlength = ntohs(element->length);
if (txpowerlength < 4) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if (length < 4) {
capwap_logging_debug("Invalid IEEE 802.11 Tx Power Level element");
return NULL;
}
txpowerlength -= sizeof(struct capwap_80211_txpowerlevel_raw_element);
if (txpowerlength > (CAPWAP_TXPOWERLEVEL_MAXLENGTH * sizeof(unsigned short))) {
return NULL;
}
dataraw = (struct capwap_80211_txpowerlevel_raw_element*)element->data;
if ((dataraw->numlevels < 1) || (dataraw->numlevels > CAPWAP_TXPOWERLEVEL_MAXLENGTH)) {
length -= 2;
if ((length % sizeof(uint16_t)) || ((length / sizeof(uint16_t)) > CAPWAP_TXPOWERLEVEL_MAXLENGTH)) {
capwap_logging_debug("Invalid IEEE 802.11 Tx Power Level element");
return NULL;
}
@ -91,19 +56,35 @@ void* capwap_80211_txpowerlevel_element_parsing(struct capwap_message_element* e
capwap_outofmemory();
}
/* */
data->radioid = dataraw->radioid;
data->numlevels = dataraw->numlevels;
for (i = 0; i < dataraw->numlevels; i++) {
data->powerlevel[i] = dataraw->powerlevel[i];
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_80211_txpowerlevel_element));
func->read_u8(handle, &data->radioid);
func->read_u8(handle, &data->numlevels);
/* Check */
if ((data->numlevels * sizeof(uint16_t)) != length) {
capwap_logging_debug("Invalid IEEE 802.11 Tx Power Level element");
capwap_free(data);
return NULL;
}
for (i = 0; i < data->numlevels; i++) {
func->read_u16(handle, &data->powerlevel[i]);
}
return data;
}
/* */
void capwap_80211_txpowerlevel_element_free(void* data) {
static void capwap_80211_txpowerlevel_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_80211_txpowerlevel_ops = {
.create_message_element = capwap_80211_txpowerlevel_element_create,
.parsing_message_element = capwap_80211_txpowerlevel_element_parsing,
.free_parsed_message_element = capwap_80211_txpowerlevel_element_free
};

17
src/common/capwap_element_80211_txpowerlevel.h
View File

@ -6,20 +6,11 @@
#define CAPWAP_TXPOWERLEVEL_MAXLENGTH 8
struct capwap_80211_txpowerlevel_element {
unsigned char radioid;
unsigned char numlevels;
unsigned short powerlevel[CAPWAP_TXPOWERLEVEL_MAXLENGTH];
uint8_t radioid;
uint8_t numlevels;
uint16_t powerlevel[CAPWAP_TXPOWERLEVEL_MAXLENGTH];
};
struct capwap_message_element* capwap_80211_txpowerlevel_element_create(void* data, unsigned long length);
int capwap_80211_txpowerlevel_element_validate(struct capwap_message_element* element);
void* capwap_80211_txpowerlevel_element_parsing(struct capwap_message_element* element);
void capwap_80211_txpowerlevel_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_80211_txpowerlevel_ops;
/* Helper */
#define CAPWAP_CREATE_80211_TXPOWERLEVEL_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_80211_TXPOWERLEVEL); \
f->create(x, sizeof(struct capwap_80211_txpowerlevel_element)); \
})
#endif /* __CAPWAP_ELEMENT_80211_TXPOWERLEVEL_HEADER__ */

71
src/common/capwap_element_80211_wtpradioinformation.c
View File

@ -17,72 +17,53 @@ Length: 5
********************************************************************/
struct capwap_80211_wtpradioinformation_raw_element {
unsigned char radioid;
unsigned long radiotype;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_80211_wtpradioinformation_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_80211_wtpradioinformation_raw_element* dataraw;
struct capwap_80211_wtpradioinformation_element* dataelement = (struct capwap_80211_wtpradioinformation_element*)data;
static void capwap_80211_wtpradioinformation_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_80211_wtpradioinformation_element* element = (struct capwap_80211_wtpradioinformation_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_80211_wtpradioinformation_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_wtpradioinformation_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_80211_wtpradioinformation_raw_element));
element->type = htons(CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION);
element->length = htons(sizeof(struct capwap_80211_wtpradioinformation_raw_element));
dataraw = (struct capwap_80211_wtpradioinformation_raw_element*)element->data;
dataraw->radioid = dataelement->radioid;
dataraw->radiotype = htonl(dataelement->radiotype);
return element;
/* */
func->write_u8(handle, element->radioid);
func->write_u32(handle, element->radiotype);
}
/* */
int capwap_80211_wtpradioinformation_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_80211_wtpradioinformation_element_parsing(struct capwap_message_element* element) {
static void* capwap_80211_wtpradioinformation_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_80211_wtpradioinformation_element* data;
struct capwap_80211_wtpradioinformation_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION);
if (ntohs(element->length) != 5) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 5) {
capwap_logging_debug("Invalid IEEE 802.11 WTP Radio Information element");
return NULL;
}
dataraw = (struct capwap_80211_wtpradioinformation_raw_element*)element->data;
/* */
data = (struct capwap_80211_wtpradioinformation_element*)capwap_alloc(sizeof(struct capwap_80211_wtpradioinformation_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->radioid = dataraw->radioid;
data->radiotype = ntohl(dataraw->radiotype);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_80211_wtpradioinformation_element));
func->read_u8(handle, &data->radioid);
func->read_u32(handle, &data->radiotype);
return data;
}
/* */
void capwap_80211_wtpradioinformation_element_free(void* data) {
static void capwap_80211_wtpradioinformation_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_80211_wtpradioinformation_ops = {
.create_message_element = capwap_80211_wtpradioinformation_element_create,
.parsing_message_element = capwap_80211_wtpradioinformation_element_parsing,
.free_parsed_message_element = capwap_80211_wtpradioinformation_element_free
};

25
src/common/capwap_element_80211_wtpradioinformation.h
View File

@ -3,25 +3,16 @@
#define CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION 1048
#define CAPWAP_RADIO_TYPE_80211B 0x01
#define CAPWAP_RADIO_TYPE_80211A 0x02
#define CAPWAP_RADIO_TYPE_80211G 0x04
#define CAPWAP_RADIO_TYPE_80211N 0x08
struct capwap_80211_wtpradioinformation_element {
unsigned char radioid;
unsigned long radiotype;
uint8_t radioid;
uint32_t radiotype;
};
#define CAPWAP_RADIO_TYPE_80211N 0x08
#define CAPWAP_RADIO_TYPE_80211G 0x04
#define CAPWAP_RADIO_TYPE_80211A 0x02
#define CAPWAP_RADIO_TYPE_80211B 0x01
extern struct capwap_message_elements_ops capwap_element_80211_wtpradioinformation_ops;
struct capwap_message_element* capwap_80211_wtpradioinformation_element_create(void* data, unsigned long length);
int capwap_80211_wtpradioinformation_element_validate(struct capwap_message_element* element);
void* capwap_80211_wtpradioinformation_element_parsing(struct capwap_message_element* element);
void capwap_80211_wtpradioinformation_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_80211_WTPRADIOINFORMATION_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION); \
f->create(x, sizeof(struct capwap_80211_wtpradioinformation_element)); \
})
#endif /* __CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION_HEADER__ */

224
src/common/capwap_element_acdescriptor.c
View File

@ -15,7 +15,7 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| AC Information Sub-Element...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
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
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@ -31,109 +31,53 @@ Length: >= 12
********************************************************************/
struct capwap_acdescriptor_raw_element {
unsigned short stations;
unsigned short limit;
unsigned short activewtp;
unsigned short maxwtp;
unsigned char security;
unsigned char rmacfield;
unsigned char reserved;
unsigned char dtlspolicy;
char data[0];
} __attribute__((__packed__));
struct capwap_acdescriptor_raw_desc_subelement {
unsigned long vendor;
unsigned short type;
unsigned short length;
char data[0];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_acdescriptor_element_create(void* data, unsigned long datalength) {
char* pos;
unsigned long i;
unsigned short length;
struct capwap_message_element* element;
struct capwap_acdescriptor_raw_element* dataraw;
struct capwap_acdescriptor_element* dataelement = (struct capwap_acdescriptor_element*)data;
static void capwap_acdescriptor_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
int i;
struct capwap_acdescriptor_element* element = (struct capwap_acdescriptor_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_acdescriptor_element));
ASSERT(dataelement->descsubelement != NULL);
/* Calc length packet */
length = sizeof(struct capwap_acdescriptor_raw_element);
for (i = 0; i < dataelement->descsubelement->count; i++) {
struct capwap_acdescriptor_desc_subelement* desc = (struct capwap_acdescriptor_desc_subelement*)capwap_array_get_item_pointer(dataelement->descsubelement, i);
length += sizeof(struct capwap_acdescriptor_raw_desc_subelement) + desc->length;
}
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + length);
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + length);
element->type = htons(CAPWAP_ELEMENT_ACDESCRIPTION);
element->length = htons(length);
/* Descriptor */
dataraw = (struct capwap_acdescriptor_raw_element*)element->data;
dataraw->stations = htons(dataelement->station);
dataraw->limit = htons(dataelement->stationlimit);
dataraw->activewtp = htons(dataelement->wtp);
dataraw->maxwtp = htons(dataelement->wtplimit);
dataraw->security = dataelement->security;
dataraw->rmacfield = dataelement->rmacfield;
dataraw->dtlspolicy = dataelement->dtlspolicy;
/* Descriptor Sub-Element */
pos = dataraw->data;
for (i = 0; i < dataelement->descsubelement->count; i++) {
struct capwap_acdescriptor_raw_desc_subelement* descraw = (struct capwap_acdescriptor_raw_desc_subelement*)pos;
struct capwap_acdescriptor_desc_subelement* desc = (struct capwap_acdescriptor_desc_subelement*)capwap_array_get_item_pointer(dataelement->descsubelement, i);
descraw->vendor = htonl(desc->vendor);
descraw->type = htons(desc->type);
descraw->length = htons(desc->length);
memcpy(descraw->data, desc->data, desc->length);
pos += sizeof(struct capwap_acdescriptor_raw_desc_subelement) + desc->length;
}
return element;
}
/* */
int capwap_acdescriptor_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_acdescriptor_element_parsing(struct capwap_message_element* element) {
unsigned char i;
long length;
char* pos;
struct capwap_acdescriptor_element* data;
struct capwap_acdescriptor_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_ACDESCRIPTION);
length = (long)ntohs(element->length);
if (length < 12) {
capwap_logging_debug("Invalid AC Descriptor element");
return NULL;
}
/* */
dataraw = (struct capwap_acdescriptor_raw_element*)element->data;
if ((dataraw->stations > dataraw->limit) || (dataraw->activewtp > dataraw->maxwtp)) {
func->write_u16(handle, element->stations);
func->write_u16(handle, element->stationlimit);
func->write_u16(handle, element->activewtp);
func->write_u16(handle, element->maxwtp);
func->write_u8(handle, element->security);
func->write_u8(handle, element->rmacfield);
func->write_u8(handle, 0);
func->write_u8(handle, element->dtlspolicy);
/* */
for (i = 0; i < element->descsubelement->count; i++) {
struct capwap_acdescriptor_desc_subelement* desc = (struct capwap_acdescriptor_desc_subelement*)capwap_array_get_item_pointer(element->descsubelement, i);
func->write_u32(handle, desc->vendor);
func->write_u16(handle, desc->type);
func->write_u16(handle, desc->length);
func->write_block(handle, desc->data, desc->length);
}
}
/* */
static void capwap_acdescriptor_element_free(void* data) {
struct capwap_acdescriptor_element* dataelement = (struct capwap_acdescriptor_element*)data;
ASSERT(dataelement != NULL);
ASSERT(dataelement->descsubelement != NULL);
capwap_array_free(dataelement->descsubelement);
capwap_free(dataelement);
}
/* */
static void* capwap_acdescriptor_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_acdescriptor_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) < 12) {
capwap_logging_debug("Invalid AC Descriptor element");
return NULL;
}
@ -144,56 +88,56 @@ void* capwap_acdescriptor_element_parsing(struct capwap_message_element* element
capwap_outofmemory();
}
memset(data, 0, sizeof(struct capwap_acdescriptor_element));
data->descsubelement = capwap_array_create(sizeof(struct capwap_acdescriptor_desc_subelement), 0);
data->descsubelement->zeroed = 1;
/* Retrieve data */
func->read_u16(handle, &data->stations);
func->read_u16(handle, &data->stationlimit);
func->read_u16(handle, &data->activewtp);
func->read_u16(handle, &data->maxwtp);
/* Check */
if ((data->stations > data->stationlimit) || (data->activewtp > data->maxwtp)) {
capwap_logging_debug("Invalid AC Descriptor element");
capwap_acdescriptor_element_free(data);
return NULL;
}
/* */
data->station = htons(dataraw->stations);
data->stationlimit = htons(dataraw->limit);
data->wtp = htons(dataraw->activewtp);
data->wtplimit = htons(dataraw->maxwtp);
data->security = dataraw->security;
data->rmacfield = dataraw->rmacfield;
data->dtlspolicy = dataraw->dtlspolicy;
pos = dataraw->data;
length -= sizeof(struct capwap_acdescriptor_raw_element);
func->read_u8(handle, &data->security);
func->read_u8(handle, &data->rmacfield);
func->read_u8(handle, NULL);
func->read_u8(handle, &data->dtlspolicy);
/* Description Subelement */
i = 0;
while (length > 0) {
struct capwap_acdescriptor_desc_subelement* desc = (struct capwap_acdescriptor_desc_subelement*)capwap_array_get_item_pointer(data->descsubelement, i);
struct capwap_acdescriptor_raw_desc_subelement* descraw = (struct capwap_acdescriptor_raw_desc_subelement*)pos;
unsigned short desclength = ntohs(descraw->length);
unsigned short descrawlength = sizeof(struct capwap_acdescriptor_raw_desc_subelement) + desclength;
if ((desclength > CAPWAP_ACDESC_SUBELEMENT_MAXDATA) || (length < descrawlength)) {
while (func->read_ready(handle) > 0) {
unsigned short length;
struct capwap_acdescriptor_desc_subelement* desc = (struct capwap_acdescriptor_desc_subelement*)capwap_array_get_item_pointer(data->descsubelement, data->descsubelement->count);
/* */
func->read_u32(handle, &desc->vendor);
func->read_u16(handle, &desc->type);
func->read_u16(handle, &desc->length);
/* Check buffer size */
length = func->read_ready(handle);
if ((length > CAPWAP_ACDESC_SUBELEMENT_MAXDATA) || (length < desc->length)) {
capwap_logging_debug("Invalid AC Descriptor element");
capwap_acdescriptor_element_free(data);
return NULL;
}
/* */
desc->vendor = ntohl(descraw->vendor);
desc->type = ntohs(descraw->type);
desc->length = desclength;
memcpy(desc->data, descraw->data, desclength);
/* */
i++;
pos += descrawlength;
length -= descrawlength;
func->read_block(handle, desc->data, desc->length);
}
return data;
}
/* */
void capwap_acdescriptor_element_free(void* data) {
struct capwap_acdescriptor_element* dataelement = (struct capwap_acdescriptor_element*)data;
ASSERT(dataelement != NULL);
ASSERT(dataelement->descsubelement != NULL);
capwap_array_free(dataelement->descsubelement);
capwap_free(dataelement);
}
struct capwap_message_elements_ops capwap_element_acdescriptor_ops = {
.create_message_element = capwap_acdescriptor_element_create,
.parsing_message_element = capwap_acdescriptor_element_parsing,
.free_parsed_message_element = capwap_acdescriptor_element_free
};

33
src/common/capwap_element_acdescriptor.h
View File

@ -13,13 +13,13 @@
#define CAPWAP_ACDESC_CLEAR_DATA_CHANNEL_ENABLED 0x02
struct capwap_acdescriptor_element {
unsigned short station;
unsigned short stationlimit;
unsigned short wtp;
unsigned short wtplimit;
unsigned char security;
unsigned char rmacfield;
unsigned char dtlspolicy;
uint16_t stations;
uint16_t stationlimit;
uint16_t activewtp;
uint16_t maxwtp;
uint8_t security;
uint8_t rmacfield;
uint8_t dtlspolicy;
struct capwap_array* descsubelement;
};
@ -28,21 +28,12 @@ struct capwap_acdescriptor_element {
#define CAPWAP_ACDESC_SUBELEMENT_MAXDATA 1024
struct capwap_acdescriptor_desc_subelement {
unsigned long vendor;
unsigned short type;
unsigned short length;
char data[CAPWAP_ACDESC_SUBELEMENT_MAXDATA];
uint32_t vendor;
uint16_t type;
uint16_t length;
uint8_t data[CAPWAP_ACDESC_SUBELEMENT_MAXDATA];
};
struct capwap_message_element* capwap_acdescriptor_element_create(void* data, unsigned long length);
int capwap_acdescriptor_element_validate(struct capwap_message_element* element);
void* capwap_acdescriptor_element_parsing(struct capwap_message_element* element);
void capwap_acdescriptor_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_ACDESCRIPTOR_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_ACDESCRIPTION); \
f->create(x, sizeof(struct capwap_acdescriptor_element)); \
})
extern struct capwap_message_elements_ops capwap_element_acdescriptor_ops;
#endif /* __CAPWAP_ELEMENT_ACDESCRIPTOR_HEADER__ */

106
src/common/capwap_element_acipv4list.c
View File

@ -10,94 +10,68 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 2 for AC IPv4 List
Length: >= 4
********************************************************************/
struct capwap_acipv4list_raw_element {
unsigned long address;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_acipv4list_element_create(void* data, unsigned long datalength) {
int i;
int items;
unsigned short sizeitems;
struct capwap_message_element* element;
capwap_acipv4list_element_array* dataarray = (capwap_acipv4list_element_array*)data;
struct capwap_acipv4list_raw_element* dataraw;
static void capwap_acipv4list_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
unsigned long i;
struct capwap_acipv4list_element* element = (struct capwap_acipv4list_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(capwap_acipv4list_element_array));
items = min(dataarray->count, CAPWAP_ACIPV4LIST_MAX_ELEMENTS);
/* Alloc block of memory */
sizeitems = sizeof(struct capwap_acipv4list_raw_element) * items;
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeitems);
if (!element) {
capwap_outofmemory();
/* */
for (i = 0; i < element->addresses->count; i++) {
func->write_block(handle, (uint8_t*)capwap_array_get_item_pointer(element->addresses, i), sizeof(struct in_addr));
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeitems);
element->type = htons(CAPWAP_ELEMENT_ACIPV4LIST);
element->length = htons(sizeitems);
dataraw = (struct capwap_acipv4list_raw_element*)element->data;
for (i = 0; i < items; i++) {
struct capwap_acipv4list_element* dataelement = (struct capwap_acipv4list_element*)capwap_array_get_item_pointer(dataarray, i);
dataraw->address = dataelement->address.s_addr;
/* Next raw item */
dataraw++;
}
return element;
}
/* */
int capwap_acipv4list_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
static void* capwap_acipv4list_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
uint16_t length;
struct capwap_acipv4list_element* data;
/* */
void* capwap_acipv4list_element_parsing(struct capwap_message_element* element) {
int i;
int items;
unsigned short length;
capwap_acipv4list_element_array* data;
struct capwap_acipv4list_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_ACIPV4LIST);
length = ntohs(element->length);
if ((length > 0) && ((length % sizeof(struct capwap_acipv4list_raw_element)) != 0)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if ((length >= 4) && (length <= CAPWAP_ACIPV4LIST_MAX_ELEMENTS * 4) && (length % 4)) {
capwap_logging_debug("Invalid AC IPv4 List element");
return NULL;
}
/* */
items = length / sizeof(struct capwap_acipv4list_raw_element);
data = (capwap_acipv4list_element_array*)capwap_array_create(sizeof(struct capwap_acipv4list_element), items);
data = (struct capwap_acipv4list_element*)capwap_alloc(sizeof(struct capwap_acipv4list_element));
if (!data) {
capwap_outofmemory();
}
/* */
dataraw = (struct capwap_acipv4list_raw_element*)element->data;
for (i = 0; i < items; i++) {
struct capwap_acipv4list_element* dataelement = (struct capwap_acipv4list_element*)capwap_array_get_item_pointer(data, i);
dataelement->address.s_addr = dataraw->address;
/* Next raw item */
dataraw++;
/* Retrieve data */
data->addresses = capwap_array_create(sizeof(struct in_addr), 0);
while (length > 0) {
struct in_addr* address = (struct in_addr*)capwap_array_get_item_pointer(data->addresses, data->addresses->count);
func->read_block(handle, (uint8_t*)address, sizeof(struct in_addr));
length -= 4;
}
return data;
}
/* */
void capwap_acipv4list_element_free(void* data) {
static void capwap_acipv4list_element_free(void* data) {
struct capwap_acipv4list_element* element = (struct capwap_acipv4list_element*)data;
ASSERT(data != NULL);
capwap_array_free((capwap_acipv4list_element_array*)data);
capwap_array_free(element->addresses);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_acipv4list_ops = {
.create_message_element = capwap_acipv4list_element_create,
.parsing_message_element = capwap_acipv4list_element_parsing,
.free_parsed_message_element = capwap_acipv4list_element_free
};

15
src/common/capwap_element_acipv4list.h
View File

@ -5,21 +5,10 @@
#define CAPWAP_ACIPV4LIST_MAX_ELEMENTS 1024
typedef struct capwap_array capwap_acipv4list_element_array;
struct capwap_acipv4list_element {
struct in_addr address;
struct capwap_array* addresses;
};
struct capwap_message_element* capwap_acipv4list_element_create(void* data, unsigned long datalength);
int capwap_acipv4list_element_validate(struct capwap_message_element* element);
void* capwap_acipv4list_element_parsing(struct capwap_message_element* element);
void capwap_acipv4list_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_ACIPV4LIST_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_ACIPV4LIST); \
f->create(x, sizeof(capwap_acipv4list_element_array)); \
})
extern struct capwap_message_elements_ops capwap_element_acipv4list_ops;
#endif /* __CAPWAP_ELEMENT_ACIPV4LIST_HEADER__ */

106
src/common/capwap_element_acipv6list.c
View File

@ -16,94 +16,68 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 3 for AC IPV6 List
Length: >= 16
********************************************************************/
struct capwap_acipv6list_raw_element {
unsigned long address[4];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_acipv6list_element_create(void* data, unsigned long datalength) {
int i;
int items;
unsigned short sizeitems;
struct capwap_message_element* element;
capwap_acipv6list_element_array* dataarray = (capwap_acipv6list_element_array*)data;
struct capwap_acipv6list_raw_element* dataraw;
static void capwap_acipv6list_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
unsigned long i;
struct capwap_acipv6list_element* element = (struct capwap_acipv6list_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(capwap_acipv6list_element_array));
items = min(dataarray->count, CAPWAP_ACIPV6LIST_MAX_ELEMENTS);
/* Alloc block of memory */
sizeitems = sizeof(struct capwap_acipv6list_raw_element) * items;
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeitems);
if (!element) {
capwap_outofmemory();
/* */
for (i = 0; i < element->addresses->count; i++) {
func->write_block(handle, (uint8_t*)capwap_array_get_item_pointer(element->addresses, i), sizeof(struct in6_addr));
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeitems);
element->type = htons(CAPWAP_ELEMENT_ACIPV6LIST);
element->length = htons(sizeitems);
dataraw = (struct capwap_acipv6list_raw_element*)element->data;
for (i = 0; i < items; i++) {
struct capwap_acipv6list_element* dataelement = (struct capwap_acipv6list_element*)capwap_array_get_item_pointer(dataarray, i);
memcpy(dataraw->address, dataelement->address.s6_addr32, sizeof(unsigned long) * 4);
/* Next raw item */
dataraw++;
}
return element;
}
/* */
int capwap_acipv6list_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
static void* capwap_acipv6list_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
uint16_t length;
struct capwap_acipv6list_element* data;
/* */
void* capwap_acipv6list_element_parsing(struct capwap_message_element* element) {
int i;
int items;
unsigned short length;
capwap_acipv6list_element_array* data;
struct capwap_acipv6list_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_ACIPV6LIST);
length = ntohs(element->length);
if ((length > 0) && ((length % sizeof(struct capwap_acipv6list_raw_element)) != 0)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if ((length >= 16) && (length <= CAPWAP_ACIPV4LIST_MAX_ELEMENTS * 16) && (length % 16)) {
capwap_logging_debug("Invalid AC IPv6 List element");
return NULL;
}
/* */
items = length / sizeof(struct capwap_acipv6list_raw_element);
data = (capwap_acipv6list_element_array*)capwap_array_create(sizeof(struct capwap_acipv6list_element), items);
data = (struct capwap_acipv6list_element*)capwap_alloc(sizeof(struct capwap_acipv6list_element));
if (!data) {
capwap_outofmemory();
}
/* */
dataraw = (struct capwap_acipv6list_raw_element*)element->data;
for (i = 0; i < items; i++) {
struct capwap_acipv6list_element* dataelement = (struct capwap_acipv6list_element*)capwap_array_get_item_pointer(data, i);
memcpy(dataelement->address.s6_addr32, dataraw->address, sizeof(unsigned long) * 4);
/* Next raw item */
dataraw++;
/* Retrieve data */
data->addresses = capwap_array_create(sizeof(struct in6_addr), 0);
while (length > 0) {
struct in6_addr* address = (struct in6_addr*)capwap_array_get_item_pointer(data->addresses, data->addresses->count);
func->read_block(handle, (uint8_t*)address, sizeof(struct in6_addr));
length -= 16;
}
return data;
}
/* */
void capwap_acipv6list_element_free(void* data) {
static void capwap_acipv6list_element_free(void* data) {
struct capwap_acipv6list_element* element = (struct capwap_acipv6list_element*)data;
ASSERT(data != NULL);
capwap_array_free((capwap_acipv6list_element_array*)data);
capwap_array_free(element->addresses);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_acipv6list_ops = {
.create_message_element = capwap_acipv6list_element_create,
.parsing_message_element = capwap_acipv6list_element_parsing,
.free_parsed_message_element = capwap_acipv6list_element_free
};

15
src/common/capwap_element_acipv6list.h
View File

@ -5,21 +5,10 @@
#define CAPWAP_ACIPV6LIST_MAX_ELEMENTS 1024
typedef struct capwap_array capwap_acipv6list_element_array;
struct capwap_acipv6list_element {
struct in6_addr address;
struct capwap_array* addresses;
};
struct capwap_message_element* capwap_acipv6list_element_create(void* data, unsigned long datalength);
int capwap_acipv6list_element_validate(struct capwap_message_element* element);
void* capwap_acipv6list_element_parsing(struct capwap_message_element* element);
void capwap_acipv6list_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_ACIPV6LIST_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_ACIPV6LIST); \
f->create(x, sizeof(capwap_acipv6list_element_array)); \
})
extern struct capwap_message_elements_ops capwap_element_acipv6list_ops;
#endif /* __CAPWAP_ELEMENT_ACIPV6LIST_HEADER__ */

70
src/common/capwap_element_acname.c
View File

@ -10,77 +10,57 @@
+-+-+-+-+-+-+-+-+
Type: 4 for AC Name
Length: >= 1
********************************************************************/
struct capwap_acname_raw_element {
char name[0];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_acname_element_create(void* data, unsigned long datalength) {
unsigned short namelength;
struct capwap_message_element* element;
struct capwap_acname_raw_element* dataraw;
struct capwap_acname_element* dataelement = (struct capwap_acname_element*)data;
static void capwap_acname_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_acname_element* element = (struct capwap_acname_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_acname_element));
/* Alloc block of memory */
namelength = strlen(dataelement->name);
element = capwap_alloc(sizeof(struct capwap_message_element) + namelength);
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + namelength);
element->type = htons(CAPWAP_ELEMENT_ACNAME);
element->length = htons(namelength);
dataraw = (struct capwap_acname_raw_element*)element->data;
memcpy(&dataraw->name[0], &dataelement->name[0], namelength);
return element;
func->write_block(handle, element->name, strlen((char*)element->name));
}
/* */
int capwap_acname_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_acname_element_parsing(struct capwap_message_element* element) {
unsigned short namelength;
static void* capwap_acname_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_acname_element* data;
struct capwap_acname_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_ACNAME);
namelength = ntohs(element->length);
if (!namelength || (namelength > CAPWAP_ACNAME_MAXLENGTH)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if ((length < 1) || (length > CAPWAP_ACNAME_MAXLENGTH)) {
capwap_logging_debug("Invalid AC Name element");
return NULL;
}
/* */
dataraw = (struct capwap_acname_raw_element*)element->data;
data = (struct capwap_acname_element*)capwap_alloc(sizeof(struct capwap_acname_element));
if (!data) {
capwap_outofmemory();
}
/* */
memcpy(&data->name[0], &dataraw->name[0], namelength);
data->name[namelength] = 0;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_acname_element));
func->read_block(handle, data->name, length);
return data;
}
/* */
void capwap_acname_element_free(void* data) {
static void capwap_acname_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_acname_ops = {
.create_message_element = capwap_acname_element_create,
.parsing_message_element = capwap_acname_element_parsing,
.free_parsed_message_element = capwap_acname_element_free
};

14
src/common/capwap_element_acname.h
View File

@ -6,19 +6,9 @@
#define CAPWAP_ACNAME_MAXLENGTH 512
struct capwap_acname_element {
char name[CAPWAP_ACNAME_MAXLENGTH + 1];
uint8_t name[CAPWAP_ACNAME_MAXLENGTH + 1];
};
struct capwap_message_element* capwap_acname_element_create(void* data, unsigned long datalength);
int capwap_acname_element_validate(struct capwap_message_element* element);
void* capwap_acname_element_parsing(struct capwap_message_element* element);
void capwap_acname_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_ACNAME_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_ACNAME); \
f->create(x, sizeof(struct capwap_acname_element)); \
})
extern struct capwap_message_elements_ops capwap_element_acname_ops;
#endif /* __CAPWAP_ELEMENT_ACNAME_HEADER__ */

77
src/common/capwap_element_acnamepriority.c
View File

@ -10,82 +10,59 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 5 for AC Name with Priority
Length: >= 2
********************************************************************/
struct capwap_acnamepriority_raw_element {
unsigned char priority;
char name[0];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_acnamepriority_element_create(void* data, unsigned long datalength) {
unsigned short namelength;
struct capwap_message_element* element;
struct capwap_acnamepriority_raw_element* dataraw;
struct capwap_acnamepriority_element* dataelement = (struct capwap_acnamepriority_element*)data;
static void capwap_acnamepriority_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_acnamepriority_element* element = (struct capwap_acnamepriority_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_acnamepriority_element));
/* Alloc block of memory */
namelength = strlen(dataelement->name);
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_acnamepriority_raw_element) + namelength);
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_acnamepriority_raw_element) + namelength);
element->type = htons(CAPWAP_ELEMENT_ACNAMEPRIORITY);
element->length = htons(sizeof(struct capwap_acnamepriority_raw_element) + namelength);
dataraw = (struct capwap_acnamepriority_raw_element*)element->data;
dataraw->priority = dataelement->priority;
memcpy(&dataraw->name[0], &dataelement->name[0], namelength);
return element;
func->write_u8(handle, element->priority);
func->write_block(handle, element->name, strlen((char*)element->name));
}
/* */
int capwap_acnamepriority_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_acnamepriority_element_parsing(struct capwap_message_element* element) {
unsigned short namelength;
static void* capwap_acnamepriority_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_acnamepriority_element* data;
struct capwap_acnamepriority_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_ACNAMEPRIORITY);
namelength = ntohs(element->length) - sizeof(struct capwap_acnamepriority_raw_element);
if (!namelength || (namelength > CAPWAP_ACNAMEPRIORITY_MAXLENGTH)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle) - 1;
if ((length < 1) || (length > CAPWAP_ACNAMEPRIORITY_MAXLENGTH)) {
capwap_logging_debug("Invalid AC Name Priority element");
return NULL;
}
/* */
dataraw = (struct capwap_acnamepriority_raw_element*)element->data;
data = (struct capwap_acnamepriority_element*)capwap_alloc(sizeof(struct capwap_acnamepriority_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->priority = dataraw->priority;
memcpy(&data->name[0], &dataraw->name[0], namelength);
data->name[namelength] = 0;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_acnamepriority_element));
func->read_u8(handle, &data->priority);
func->read_block(handle, data->name, length);
return data;
}
/* */
void capwap_acnamepriority_element_free(void* data) {
static void capwap_acnamepriority_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_acnamepriority_ops = {
.create_message_element = capwap_acnamepriority_element_create,
.parsing_message_element = capwap_acnamepriority_element_parsing,
.free_parsed_message_element = capwap_acnamepriority_element_free
};

16
src/common/capwap_element_acnamepriority.h
View File

@ -6,20 +6,10 @@
#define CAPWAP_ACNAMEPRIORITY_MAXLENGTH 512
struct capwap_acnamepriority_element {
unsigned char priority;
char name[CAPWAP_ACNAMEPRIORITY_MAXLENGTH + 1];
uint8_t priority;
uint8_t name[CAPWAP_ACNAMEPRIORITY_MAXLENGTH + 1];
};
struct capwap_message_element* capwap_acnamepriority_element_create(void* data, unsigned long datalength);
int capwap_acnamepriority_element_validate(struct capwap_message_element* element);
void* capwap_acnamepriority_element_parsing(struct capwap_message_element* element);
void capwap_acnamepriority_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_ACNAMEPRIORITY_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_ACNAMEPRIORITY); \
f->create(x, sizeof(struct capwap_acnamepriority_element)); \
})
extern struct capwap_message_elements_ops capwap_element_acnamepriority_ops;
#endif /* __CAPWAP_ELEMENT_ACNAMEPRIORITY_HEADER__ */

73
src/common/capwap_element_controlipv4.c
View File

@ -12,57 +12,31 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 10 for CAPWAP Control IPv4 Address
Length: 6
********************************************************************/
struct capwap_controlipv4_raw_element {
unsigned long address;
unsigned short wtpcount;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_controlipv4_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_controlipv4_element* dataelement = (struct capwap_controlipv4_element*)data;
struct capwap_controlipv4_raw_element* dataraw;
static void capwap_controlipv4_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_controlipv4_element* element = (struct capwap_controlipv4_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_controlipv4_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_controlipv4_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_controlipv4_raw_element));
element->type = htons(CAPWAP_ELEMENT_CONTROLIPV4);
element->length = htons(sizeof(struct capwap_controlipv4_raw_element));
dataraw = (struct capwap_controlipv4_raw_element*)element->data;
dataraw->address = dataelement->address.s_addr;
dataraw->wtpcount = htons(dataelement->wtpcount);
return element;
/* */
func->write_block(handle, (uint8_t*)&element->address, sizeof(struct in_addr));
func->write_u16(handle, element->wtpcount);
}
/* */
int capwap_controlipv4_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_controlipv4_element_parsing(struct capwap_message_element* element) {
static void* capwap_controlipv4_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_controlipv4_element* data;
struct capwap_controlipv4_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_CONTROLIPV4);
if (ntohs(element->length) != sizeof(struct capwap_controlipv4_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 6) {
capwap_logging_debug("Invalid Control IPv4 Address element");
return NULL;
}
@ -72,17 +46,24 @@ void* capwap_controlipv4_element_parsing(struct capwap_message_element* element)
capwap_outofmemory();
}
/* */
dataraw = (struct capwap_controlipv4_raw_element*)element->data;
data->address.s_addr = dataraw->address;
data->wtpcount = ntohs(dataraw->wtpcount);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_controlipv4_element));
func->read_block(handle, (uint8_t*)&data->address, sizeof(struct in_addr));
func->read_u16(handle, &data->wtpcount);
return data;
}
/* */
void capwap_controlipv4_element_free(void* data) {
static void capwap_controlipv4_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_controlipv4_ops = {
.create_message_element = capwap_controlipv4_element_create,
.parsing_message_element = capwap_controlipv4_element_parsing,
.free_parsed_message_element = capwap_controlipv4_element_free
};

14
src/common/capwap_element_controlipv4.h
View File

@ -5,19 +5,9 @@
struct capwap_controlipv4_element {
struct in_addr address;
unsigned short wtpcount;
uint16_t wtpcount;
};
struct capwap_message_element* capwap_controlipv4_element_create(void* data, unsigned long datalength);
int capwap_controlipv4_element_validate(struct capwap_message_element* element);
void* capwap_controlipv4_element_parsing(struct capwap_message_element* element);
void capwap_controlipv4_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_CONTROLIPV4_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_CONTROLIPV4); \
f->create(x, sizeof(struct capwap_controlipv4_element)); \
})
extern struct capwap_message_elements_ops capwap_element_controlipv4_ops;
#endif /* __CAPWAP_ELEMENT_CONTROLIPV4_HEADER__ */

73
src/common/capwap_element_controlipv6.c
View File

@ -18,57 +18,31 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 11 for CAPWAP Control IPv6 Address
Length: 18
********************************************************************/
struct capwap_controlipv6_raw_element {
unsigned long address[4];
unsigned short wtpcount;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_controlipv6_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_controlipv6_element* dataelement = (struct capwap_controlipv6_element*)data;
struct capwap_controlipv6_raw_element* dataraw;
static void capwap_controlipv6_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_controlipv6_element* element = (struct capwap_controlipv6_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_controlipv6_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_controlipv6_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_controlipv6_raw_element));
element->type = htons(CAPWAP_ELEMENT_CONTROLIPV6);
element->length = htons(sizeof(struct capwap_controlipv6_raw_element));
dataraw = (struct capwap_controlipv6_raw_element*)element->data;
memcpy(dataraw->address, dataelement->address.s6_addr32, sizeof(unsigned long) * 4);
dataraw->wtpcount = htons(dataelement->wtpcount);
return element;
/* */
func->write_block(handle, (uint8_t*)&element->address, sizeof(struct in6_addr));
func->write_u16(handle, element->wtpcount);
}
/* */
int capwap_controlipv6_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_controlipv6_element_parsing(struct capwap_message_element* element) {
static void* capwap_controlipv6_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_controlipv6_element* data;
struct capwap_controlipv6_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_CONTROLIPV6);
if (ntohs(element->length) != sizeof(struct capwap_controlipv6_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 18) {
capwap_logging_debug("Invalid Control IPv6 Address element");
return NULL;
}
@ -78,17 +52,24 @@ void* capwap_controlipv6_element_parsing(struct capwap_message_element* element)
capwap_outofmemory();
}
/* */
dataraw = (struct capwap_controlipv6_raw_element*)element->data;
memcpy(data->address.s6_addr32, dataraw->address, sizeof(unsigned long) * 4);
data->wtpcount = ntohs(dataraw->wtpcount);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_controlipv6_element));
func->read_block(handle, (uint8_t*)&data->address, sizeof(struct in6_addr));
func->read_u16(handle, &data->wtpcount);
return data;
}
/* */
void capwap_controlipv6_element_free(void* data) {
static void capwap_controlipv6_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_controlipv6_ops = {
.create_message_element = capwap_controlipv6_element_create,
.parsing_message_element = capwap_controlipv6_element_parsing,
.free_parsed_message_element = capwap_controlipv6_element_free
};

12
src/common/capwap_element_controlipv6.h
View File

@ -8,16 +8,6 @@ struct capwap_controlipv6_element {
unsigned short wtpcount;
};
struct capwap_message_element* capwap_controlipv6_element_create(void* data, unsigned long datalength);
int capwap_controlipv6_element_validate(struct capwap_message_element* element);
void* capwap_controlipv6_element_parsing(struct capwap_message_element* element);
void capwap_controlipv6_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_CONTROLIPV6_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_CONTROLIPV6); \
f->create(x, sizeof(struct capwap_controlipv6_element)); \
})
extern struct capwap_message_elements_ops capwap_element_controlipv6_ops;
#endif /* __CAPWAP_ELEMENT_CONTROLIPV4_HEADER__ */

73
src/common/capwap_element_decrypterrorreportperiod.c
View File

@ -10,57 +10,31 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 16 for Decryption Error Report Period
Length: 3
********************************************************************/
struct capwap_decrypterrorreportperiod_raw_element {
unsigned char radioid;
unsigned short interval;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_decrypterrorreportperiod_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_decrypterrorreportperiod_element* dataelement = (struct capwap_decrypterrorreportperiod_element*)data;
struct capwap_decrypterrorreportperiod_raw_element* dataraw;
static void capwap_decrypterrorreportperiod_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_decrypterrorreportperiod_element* element = (struct capwap_decrypterrorreportperiod_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_decrypterrorreportperiod_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_decrypterrorreportperiod_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_decrypterrorreportperiod_raw_element));
element->type = htons(CAPWAP_ELEMENT_DECRYPTERRORREPORTPERIOD);
element->length = htons(sizeof(struct capwap_decrypterrorreportperiod_raw_element));
dataraw = (struct capwap_decrypterrorreportperiod_raw_element*)element->data;
dataraw->radioid = dataelement->radioid;
dataraw->interval = htons(dataelement->interval);
return element;
/* */
func->write_u8(handle, element->radioid);
func->write_u16(handle, element->interval);
}
/* */
int capwap_decrypterrorreportperiod_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_decrypterrorreportperiod_element_parsing(struct capwap_message_element* element) {
static void* capwap_decrypterrorreportperiod_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_decrypterrorreportperiod_element* data;
struct capwap_decrypterrorreportperiod_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_DECRYPTERRORREPORTPERIOD);
if (ntohs(element->length) != sizeof(struct capwap_decrypterrorreportperiod_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 3) {
capwap_logging_debug("Invalid Decryption Error Report Period element");
return NULL;
}
@ -70,17 +44,24 @@ void* capwap_decrypterrorreportperiod_element_parsing(struct capwap_message_elem
capwap_outofmemory();
}
/* */
dataraw = (struct capwap_decrypterrorreportperiod_raw_element*)element->data;
data->radioid = dataraw->radioid;
data->interval = ntohs(dataraw->interval);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_decrypterrorreportperiod_element));
func->read_u8(handle, &data->radioid);
func->read_u16(handle, &data->interval);
return data;
}
/* */
void capwap_decrypterrorreportperiod_element_free(void* data) {
static void capwap_decrypterrorreportperiod_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_decrypterrorreportperiod_ops = {
.create_message_element = capwap_decrypterrorreportperiod_element_create,
.parsing_message_element = capwap_decrypterrorreportperiod_element_parsing,
.free_parsed_message_element = capwap_decrypterrorreportperiod_element_free
};

15
src/common/capwap_element_decrypterrorreportperiod.h
View File

@ -4,19 +4,10 @@
#define CAPWAP_ELEMENT_DECRYPTERRORREPORTPERIOD 16
struct capwap_decrypterrorreportperiod_element {
unsigned char radioid;
unsigned short interval;
uint8_t radioid;
uint16_t interval;
};
struct capwap_message_element* capwap_decrypterrorreportperiod_element_create(void* data, unsigned long length);
int capwap_decrypterrorreportperiod_element_validate(struct capwap_message_element* element);
void* capwap_decrypterrorreportperiod_element_parsing(struct capwap_message_element* element);
void capwap_decrypterrorreportperiod_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_decrypterrorreportperiod_ops;
/* Helper */
#define CAPWAP_CREATE_DECRYPTERRORREPORTPERIOD_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_DECRYPTERRORREPORTPERIOD); \
f->create(x, sizeof(struct capwap_decrypterrorreportperiod_element)); \
})
#endif /* __CAPWAP_ELEMENT_DECRYPTERRORREPORTPERIOD_HEADER__ */

60
src/common/capwap_element_discoverytype.c
View File

@ -10,49 +10,30 @@
+-+-+-+-+-+-+-+-+
Type: 20 for Discovery Type
Length: 1
********************************************************************/
struct capwap_discoverytype_raw_element {
unsigned char type;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_discoverytype_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
static void capwap_discoverytype_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_discoverytype_element* element = (struct capwap_discoverytype_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_discoverytype_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_discoverytype_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_discoverytype_raw_element));
element->type = htons(CAPWAP_ELEMENT_DISCOVERYTYPE);
element->length = htons(sizeof(struct capwap_discoverytype_raw_element));
((struct capwap_discoverytype_raw_element*)element->data)->type = ((struct capwap_discoverytype_element*)data)->type;
return element;
/* */
func->write_u8(handle, element->type);
}
/* */
int capwap_discoverytype_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_discoverytype_element_parsing(struct capwap_message_element* element) {
static void* capwap_discoverytype_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_discoverytype_element* data;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_DISCOVERYTYPE);
if (ntohs(element->length) != sizeof(struct capwap_discoverytype_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 1) {
capwap_logging_debug("Invalid Discovery Type element");
return NULL;
}
@ -62,14 +43,23 @@ void* capwap_discoverytype_element_parsing(struct capwap_message_element* elemen
capwap_outofmemory();
}
/* */
data->type = ((struct capwap_discoverytype_raw_element*)element->data)->type;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_discoverytype_element));
func->read_u8(handle, &data->type);
return data;
}
/* */
void capwap_discoverytype_element_free(void* data) {
static void capwap_discoverytype_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_discoverytype_ops = {
.create_message_element = capwap_discoverytype_element_create,
.parsing_message_element = capwap_discoverytype_element_parsing,
.free_parsed_message_element = capwap_discoverytype_element_free
};

14
src/common/capwap_element_discoverytype.h
View File

@ -10,19 +10,9 @@
#define CAPWAP_ELEMENT_DISCOVERYTYPE_TYPE_ACREFERRAL 4
struct capwap_discoverytype_element {
unsigned char type;
uint8_t type;
};
struct capwap_message_element* capwap_discoverytype_element_create(void* data, unsigned long datalength);
int capwap_discoverytype_element_validate(struct capwap_message_element* element);
void* capwap_discoverytype_element_parsing(struct capwap_message_element* element);
void capwap_discoverytype_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_DISCOVERYTYPE_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_DISCOVERYTYPE); \
f->create(x, sizeof(struct capwap_discoverytype_element)); \
})
extern struct capwap_message_elements_ops capwap_element_discoverytype_ops;
#endif /* __CAPWAP_ELEMENT_DISCOVERYTYPE_HEADER__ */

62
src/common/capwap_element_ecnsupport.c
View File

@ -10,51 +10,30 @@
+-+-+-+-+-+-+-+-+
Type: 53 for ECN Support
Length: 1
********************************************************************/
struct capwap_ecnsupport_raw_element {
char flag;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_ecnsupport_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
static void capwap_ecnsupport_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_ecnsupport_element* element = (struct capwap_ecnsupport_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_ecnsupport_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_ecnsupport_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_ecnsupport_raw_element));
element->type = htons(CAPWAP_ELEMENT_ECNSUPPORT);
element->length = htons(sizeof(struct capwap_ecnsupport_raw_element));
((struct capwap_ecnsupport_raw_element*)element->data)->flag = ((struct capwap_ecnsupport_element*)data)->flag;
return element;
/* */
func->write_u8(handle, element->flag);
}
/* */
int capwap_ecnsupport_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_ecnsupport_element_parsing(struct capwap_message_element* element) {
static void* capwap_ecnsupport_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_ecnsupport_element* data;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_ECNSUPPORT);
if (ntohs(element->length) != sizeof(struct capwap_ecnsupport_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 1) {
capwap_logging_debug("Invalid ECN Support element");
return NULL;
}
@ -64,14 +43,23 @@ void* capwap_ecnsupport_element_parsing(struct capwap_message_element* element)
capwap_outofmemory();
}
/* */
data->flag = ((struct capwap_ecnsupport_raw_element*)element->data)->flag;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_ecnsupport_element));
func->read_u8(handle, &data->flag);
return data;
}
/* */
void capwap_ecnsupport_element_free(void* data) {
static void capwap_ecnsupport_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_ecnsupport_ops = {
.create_message_element = capwap_ecnsupport_element_create,
.parsing_message_element = capwap_ecnsupport_element_parsing,
.free_parsed_message_element = capwap_ecnsupport_element_free
};

19
src/common/capwap_element_ecnsupport.h
View File

@ -3,22 +3,13 @@
#define CAPWAP_ELEMENT_ECNSUPPORT 53
struct capwap_ecnsupport_element {
char flag;
};
#define CAPWAP_LIMITED_ECN_SUPPORT 0
#define CAPWAP_FULL_ECN_SUPPORT 1
struct capwap_message_element* capwap_ecnsupport_element_create(void* data, unsigned long length);
int capwap_ecnsupport_element_validate(struct capwap_message_element* element);
void* capwap_ecnsupport_element_parsing(struct capwap_message_element* element);
void capwap_ecnsupport_element_free(void* data);
struct capwap_ecnsupport_element {
uint8_t flag;
};
extern struct capwap_message_elements_ops capwap_element_ecnsupport_ops;
/* Helper */
#define CAPWAP_CREATE_ECNSUPPORT_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_ECNSUPPORT); \
f->create(x, sizeof(struct capwap_ecnsupport_element)); \
})
#endif /* __CAPWAP_ELEMENT_ECNSUPPORT_HEADER__ */

61
src/common/capwap_element_idletimeout.c
View File

@ -14,47 +14,25 @@ Length: 4
********************************************************************/
struct capwap_idletimeout_raw_element {
unsigned long timeout;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_idletimeout_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
static void capwap_idletimeout_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_idletimeout_element* element = (struct capwap_idletimeout_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_idletimeout_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_idletimeout_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_idletimeout_raw_element));
element->type = htons(CAPWAP_ELEMENT_IDLETIMEOUT);
element->length = htons(sizeof(struct capwap_idletimeout_raw_element));
((struct capwap_idletimeout_raw_element*)element->data)->timeout = htonl(((struct capwap_idletimeout_element*)data)->timeout);
return element;
/* */
func->write_u32(handle, element->timeout);
}
/* */
int capwap_idletimeout_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_idletimeout_element_parsing(struct capwap_message_element* element) {
static void* capwap_idletimeout_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_idletimeout_element* data;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_IDLETIMEOUT);
if (ntohs(element->length) != sizeof(struct capwap_idletimeout_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 4) {
capwap_logging_debug("Invalid Idle Timeout element");
return NULL;
}
@ -64,14 +42,23 @@ void* capwap_idletimeout_element_parsing(struct capwap_message_element* element)
capwap_outofmemory();
}
/* */
data->timeout = ntohl(((struct capwap_idletimeout_raw_element*)element->data)->timeout);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_idletimeout_element));
func->read_u32(handle, &data->timeout);
return data;
}
/* */
void capwap_idletimeout_element_free(void* data) {
static void capwap_idletimeout_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_idletimeout_ops = {
.create_message_element = capwap_idletimeout_element_create,
.parsing_message_element = capwap_idletimeout_element_parsing,
.free_parsed_message_element = capwap_idletimeout_element_free
};

13
src/common/capwap_element_idletimeout.h
View File

@ -4,18 +4,9 @@
#define CAPWAP_ELEMENT_IDLETIMEOUT 23
struct capwap_idletimeout_element {
unsigned long timeout;
uint32_t timeout;
};
struct capwap_message_element* capwap_idletimeout_element_create(void* data, unsigned long length);
int capwap_idletimeout_element_validate(struct capwap_message_element* element);
void* capwap_idletimeout_element_parsing(struct capwap_message_element* element);
void capwap_idletimeout_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_idletimeout_ops;
/* Helper */
#define CAPWAP_CREATE_IDLETIMEOUT_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_IDLETIMEOUT); \
f->create(x, sizeof(struct capwap_idletimeout_element)); \
})
#endif /* __CAPWAP_ELEMENT_IDLETIMEOUT_HEADER__ */

91
src/common/capwap_element_imageidentifier.c
View File

@ -12,82 +12,65 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 25 for Image Identifier
Length: >= 5
********************************************************************/
struct capwap_imageidentifier_raw_element {
unsigned long vendor;
char name[0];
} __attribute__((__packed__));
/* */
static void capwap_imageidentifier_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_imageidentifier_element* element = (struct capwap_imageidentifier_element*)data;
ASSERT(data != NULL);
func->write_u32(handle, element->vendor);
func->write_block(handle, element->name, strlen((char*)element->name));
}
/* */
struct capwap_message_element* capwap_imageidentifier_element_create(void* data, unsigned long datalength) {
unsigned short namelength;
struct capwap_message_element* element;
struct capwap_imageidentifier_raw_element* dataraw;
struct capwap_imageidentifier_element* dataelement = (struct capwap_imageidentifier_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_imageidentifier_element));
/* Alloc block of memory */
namelength = strlen(dataelement->name);
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_imageidentifier_raw_element) + namelength);
if (!element) {
capwap_outofmemory();
static void* capwap_imageidentifier_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_imageidentifier_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if (length < 5) {
capwap_logging_debug("Invalid Image Indentifier element");
return NULL;
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_imageidentifier_raw_element) + namelength);
element->type = htons(CAPWAP_ELEMENT_IMAGEIDENTIFIER);
element->length = htons(sizeof(struct capwap_imageidentifier_raw_element) + namelength);
dataraw = (struct capwap_imageidentifier_raw_element*)element->data;
dataraw->vendor = htonl(dataelement->vendor);
memcpy(&dataraw->name[0], &dataelement->name[0], namelength);
return element;
}
/* */
int capwap_imageidentifier_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_imageidentifier_element_parsing(struct capwap_message_element* element) {
unsigned short namelength;
struct capwap_imageidentifier_element* data;
struct capwap_imageidentifier_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_IMAGEIDENTIFIER);
namelength = ntohs(element->length) - sizeof(struct capwap_imageidentifier_raw_element);
if (!namelength || (namelength > CAPWAP_IMAGEIDENTIFIER_MAXLENGTH)) {
length -= 4;
if (length > CAPWAP_IMAGEIDENTIFIER_MAXLENGTH) {
capwap_logging_debug("Invalid AC Name element");
return NULL;
}
/* */
dataraw = (struct capwap_imageidentifier_raw_element*)element->data;
data = (struct capwap_imageidentifier_element*)capwap_alloc(sizeof(struct capwap_imageidentifier_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->vendor = ntohl(dataraw->vendor);
memcpy(&data->name[0], &dataraw->name[0], namelength);
data->name[namelength] = 0;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_imageidentifier_element));
func->read_u32(handle, &data->vendor);
func->read_block(handle, data->name, length);
return data;
}
/* */
void capwap_imageidentifier_element_free(void* data) {
static void capwap_imageidentifier_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_imageidentifier_ops = {
.create_message_element = capwap_imageidentifier_element_create,
.parsing_message_element = capwap_imageidentifier_element_parsing,
.free_parsed_message_element = capwap_imageidentifier_element_free
};

16
src/common/capwap_element_imageidentifier.h
View File

@ -6,20 +6,10 @@
#define CAPWAP_IMAGEIDENTIFIER_MAXLENGTH 1024
struct capwap_imageidentifier_element {
unsigned long vendor;
char name[CAPWAP_IMAGEIDENTIFIER_MAXLENGTH + 1];
uint32_t vendor;
uint8_t name[CAPWAP_IMAGEIDENTIFIER_MAXLENGTH + 1];
};
struct capwap_message_element* capwap_imageidentifier_element_create(void* data, unsigned long datalength);
int capwap_imageidentifier_element_validate(struct capwap_message_element* element);
void* capwap_imageidentifier_element_parsing(struct capwap_message_element* element);
void capwap_imageidentifier_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_IMAGEIDENTIFIER_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_IMAGEIDENTIFIER); \
f->create(x, sizeof(struct capwap_imageidentifier_element)); \
})
extern struct capwap_message_elements_ops capwap_element_imageidentifier_ops;
#endif /* __CAPWAP_ELEMENT_IMAGEIDENTIFIER_HEADER__ */

68
src/common/capwap_element_localipv4.c
View File

@ -10,55 +10,30 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 30 for CAPWAP Local IPv4 Address
Length: 4
********************************************************************/
struct capwap_localipv4_raw_element {
unsigned long address;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_localipv4_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_localipv4_element* dataelement = (struct capwap_localipv4_element*)data;
struct capwap_localipv4_raw_element* dataraw;
static void capwap_localipv4_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_localipv4_element* element = (struct capwap_localipv4_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_localipv4_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_localipv4_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_localipv4_raw_element));
element->type = htons(CAPWAP_ELEMENT_LOCALIPV4);
element->length = htons(sizeof(struct capwap_localipv4_raw_element));
dataraw = (struct capwap_localipv4_raw_element*)element->data;
dataraw->address = dataelement->address.s_addr;
return element;
/* */
func->write_block(handle, (uint8_t*)&element->address, sizeof(struct in_addr));
}
/* */
int capwap_localipv4_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_localipv4_element_parsing(struct capwap_message_element* element) {
static void* capwap_localipv4_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_localipv4_element* data;
struct capwap_localipv4_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_LOCALIPV4);
if (ntohs(element->length) != sizeof(struct capwap_localipv4_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 4) {
capwap_logging_debug("Invalid Local IPv4 Address element");
return NULL;
}
@ -68,16 +43,23 @@ void* capwap_localipv4_element_parsing(struct capwap_message_element* element) {
capwap_outofmemory();
}
/* */
dataraw = (struct capwap_localipv4_raw_element*)element->data;
data->address.s_addr = dataraw->address;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_localipv4_element));
func->read_block(handle, (uint8_t*)&data->address, sizeof(struct in_addr));
return data;
}
/* */
void capwap_localipv4_element_free(void* data) {
static void capwap_localipv4_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_localipv4_ops = {
.create_message_element = capwap_localipv4_element_create,
.parsing_message_element = capwap_localipv4_element_parsing,
.free_parsed_message_element = capwap_localipv4_element_free
};

12
src/common/capwap_element_localipv4.h
View File

@ -7,16 +7,6 @@ struct capwap_localipv4_element {
struct in_addr address;
};
struct capwap_message_element* capwap_localipv4_element_create(void* data, unsigned long datalength);
int capwap_localipv4_element_validate(struct capwap_message_element* element);
void* capwap_localipv4_element_parsing(struct capwap_message_element* element);
void capwap_localipv4_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_LOCALIPV4_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_LOCALIPV4); \
f->create(x, sizeof(struct capwap_localipv4_element)); \
})
extern struct capwap_message_elements_ops capwap_element_localipv4_ops;
#endif /* __CAPWAP_ELEMENT_LOCALIPV4_HEADER__ */

67
src/common/capwap_element_localipv6.c
View File

@ -20,51 +20,25 @@ Length: 16
********************************************************************/
struct capwap_localipv6_raw_element {
unsigned long address[4];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_localipv6_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_localipv6_element* dataelement = (struct capwap_localipv6_element*)data;
struct capwap_localipv6_raw_element* dataraw;
static void capwap_localipv6_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_localipv6_element* element = (struct capwap_localipv6_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_localipv6_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_localipv6_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_localipv6_raw_element));
element->type = htons(CAPWAP_ELEMENT_LOCALIPV6);
element->length = htons(sizeof(struct capwap_localipv6_raw_element));
dataraw = (struct capwap_localipv6_raw_element*)element->data;
memcpy(dataraw->address, dataelement->address.s6_addr32, sizeof(unsigned long) * 4);
return element;
/* */
func->write_block(handle, (uint8_t*)&element->address, sizeof(struct in6_addr));
}
/* */
int capwap_localipv6_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_localipv6_element_parsing(struct capwap_message_element* element) {
static void* capwap_localipv6_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_localipv6_element* data;
struct capwap_localipv6_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_LOCALIPV6);
if (ntohs(element->length) != sizeof(struct capwap_localipv6_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 16) {
capwap_logging_debug("Invalid Local IPv6 Address element");
return NULL;
}
@ -74,16 +48,23 @@ void* capwap_localipv6_element_parsing(struct capwap_message_element* element) {
capwap_outofmemory();
}
/* */
dataraw = (struct capwap_localipv6_raw_element*)element->data;
memcpy(data->address.s6_addr32, dataraw->address, sizeof(unsigned long) * 4);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_localipv6_element));
func->read_block(handle, (uint8_t*)&data->address, sizeof(struct in6_addr));
return data;
}
/* */
void capwap_localipv6_element_free(void* data) {
static void capwap_localipv6_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_localipv6_ops = {
.create_message_element = capwap_localipv6_element_create,
.parsing_message_element = capwap_localipv6_element_parsing,
.free_parsed_message_element = capwap_localipv6_element_free
};

12
src/common/capwap_element_localipv6.h
View File

@ -7,16 +7,6 @@ struct capwap_localipv6_element {
struct in6_addr address;
};
struct capwap_message_element* capwap_localipv6_element_create(void* data, unsigned long datalength);
int capwap_localipv6_element_validate(struct capwap_message_element* element);
void* capwap_localipv6_element_parsing(struct capwap_message_element* element);
void capwap_localipv6_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_LOCALIPV6_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_LOCALIPV6); \
f->create(x, sizeof(struct capwap_localipv6_element)); \
})
extern struct capwap_message_elements_ops capwap_element_localipv6_ops;
#endif /* __CAPWAP_ELEMENT_CONTROLIPV4_HEADER__ */

70
src/common/capwap_element_location.c
View File

@ -10,77 +10,57 @@
+-+-+-+-+-+-+-+-+
Type: 28 for Location Data
Length: >= 1
********************************************************************/
struct capwap_location_raw_element {
char value[0];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_location_element_create(void* data, unsigned long datalength) {
unsigned short namelength;
struct capwap_message_element* element;
struct capwap_location_raw_element* dataraw;
struct capwap_location_element* dataelement = (struct capwap_location_element*)data;
static void capwap_location_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_location_element* element = (struct capwap_location_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_location_element));
/* Alloc block of memory */
namelength = strlen(dataelement->value);
element = capwap_alloc(sizeof(struct capwap_message_element) + namelength);
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + namelength);
element->type = htons(CAPWAP_ELEMENT_LOCATION);
element->length = htons(namelength);
dataraw = (struct capwap_location_raw_element*)element->data;
memcpy(&dataraw->value[0], &dataelement->value[0], namelength);
return element;
func->write_block(handle, element->value, strlen((char*)element->value));
}
/* */
int capwap_location_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_location_element_parsing(struct capwap_message_element* element) {
unsigned short namelength;
static void* capwap_location_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_location_element* data;
struct capwap_location_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_LOCATION);
namelength = ntohs(element->length);
if (!namelength || (namelength > CAPWAP_LOCATION_MAXLENGTH)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if ((length < 1) || (length > CAPWAP_ACNAME_MAXLENGTH)) {
capwap_logging_debug("Invalid AC Name element");
return NULL;
}
/* */
dataraw = (struct capwap_location_raw_element*)element->data;
data = (struct capwap_location_element*)capwap_alloc(sizeof(struct capwap_location_element));
if (!data) {
capwap_outofmemory();
}
/* */
memcpy(&data->value[0], &dataraw->value[0], namelength);
data->value[namelength] = 0;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_location_element));
func->read_block(handle, data->value, length);
return data;
}
/* */
void capwap_location_element_free(void* data) {
static void capwap_location_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_location_ops = {
.create_message_element = capwap_location_element_create,
.parsing_message_element = capwap_location_element_parsing,
.free_parsed_message_element = capwap_location_element_free
};

14
src/common/capwap_element_location.h
View File

@ -6,19 +6,9 @@
#define CAPWAP_LOCATION_MAXLENGTH 1024
struct capwap_location_element {
char value[CAPWAP_LOCATION_MAXLENGTH + 1];
uint8_t value[CAPWAP_LOCATION_MAXLENGTH + 1];
};
struct capwap_message_element* capwap_location_element_create(void* data, unsigned long datalength);
int capwap_location_element_validate(struct capwap_message_element* element);
void* capwap_location_element_parsing(struct capwap_message_element* element);
void capwap_location_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_LOCATION_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_LOCATION); \
f->create(x, sizeof(struct capwap_location_element)); \
})
extern struct capwap_message_elements_ops capwap_element_location_ops;
#endif /* __CAPWAP_ELEMENT_LOCATION_HEADER__ */

62
src/common/capwap_element_maximumlength.c
View File

@ -10,51 +10,30 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 29 for Maximum Message Length
Length: 2
********************************************************************/
struct capwap_maximumlength_raw_element {
unsigned short length;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_maximumlength_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
static void capwap_maximumlength_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_maximumlength_element* element = (struct capwap_maximumlength_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_maximumlength_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_maximumlength_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_maximumlength_raw_element));
element->type = htons(CAPWAP_ELEMENT_MAXIMUMLENGTH);
element->length = htons(sizeof(struct capwap_maximumlength_raw_element));
((struct capwap_maximumlength_raw_element*)element->data)->length = htons(((struct capwap_maximumlength_element*)data)->length);
return element;
/* */
func->write_u16(handle, element->length);
}
/* */
int capwap_maximumlength_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_maximumlength_element_parsing(struct capwap_message_element* element) {
static void* capwap_maximumlength_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_maximumlength_element* data;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_MAXIMUMLENGTH);
if (ntohs(element->length) != sizeof(struct capwap_maximumlength_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 2) {
capwap_logging_debug("Invalid Maxium Message Length element");
return NULL;
}
@ -64,14 +43,23 @@ void* capwap_maximumlength_element_parsing(struct capwap_message_element* elemen
capwap_outofmemory();
}
/* */
data->length = ntohs(((struct capwap_maximumlength_raw_element*)element->data)->length);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_maximumlength_element));
func->read_u16(handle, &data->length);
return data;
}
/* */
void capwap_maximumlength_element_free(void* data) {
static void capwap_maximumlength_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_maximumlength_ops = {
.create_message_element = capwap_maximumlength_element_create,
.parsing_message_element = capwap_maximumlength_element_parsing,
.free_parsed_message_element = capwap_maximumlength_element_free
};

13
src/common/capwap_element_maximumlength.h
View File

@ -4,18 +4,9 @@
#define CAPWAP_ELEMENT_MAXIMUMLENGTH 29
struct capwap_maximumlength_element {
unsigned short length;
uint16_t length;
};
struct capwap_message_element* capwap_maximumlength_element_create(void* data, unsigned long length);
int capwap_maximumlength_element_validate(struct capwap_message_element* element);
void* capwap_maximumlength_element_parsing(struct capwap_message_element* element);
void capwap_maximumlength_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_maximumlength_ops;
/* Helper */
#define CAPWAP_CREATE_MAXIMUMLENGTH_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_MAXIMUMLENGTH); \
f->create(x, sizeof(struct capwap_maximumlength_element)); \
})
#endif /* __CAPWAP_ELEMENT_MAXIMUMLENGTH_HEADER__ */

71
src/common/capwap_element_mtudiscovery.c
View File

@ -10,63 +10,66 @@
+-+-+-+-+-+-+-+-
Type: 52 for MTU Discovery Padding
Length: variable
********************************************************************/
/* */
struct capwap_message_element* capwap_mtudiscovery_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_mtudiscovery_element* dataelement = (struct capwap_mtudiscovery_element*)data;
static void capwap_mtudiscovery_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
uint16_t length;
struct capwap_mtudiscovery_element* element = (struct capwap_mtudiscovery_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_mtudiscovery_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + dataelement->length);
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element));
element->type = htons(CAPWAP_ELEMENT_MTUDISCOVERY);
element->length = htons(dataelement->length);
if (dataelement->length > 0) {
memset(element->data, 0xff, dataelement->length);
/* */
length = element->length;
while (length > 0) {
func->write_u8(handle, 0xff);
length--;
}
return element;
}
/* */
int capwap_mtudiscovery_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_mtudiscovery_element_parsing(struct capwap_message_element* element) {
static void* capwap_mtudiscovery_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
uint16_t length;
struct capwap_mtudiscovery_element* data;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_MTUDISCOVERY);
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if (length > 0) {
capwap_logging_debug("Invalid MTU Discovery Padding element");
return NULL;
}
/* */
data = (struct capwap_mtudiscovery_element*)capwap_alloc(sizeof(struct capwap_mtudiscovery_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->length = ntohs(element->length);
/* Retrieve data */
data->length = length;
while (length > 0) {
func->read_u8(handle, NULL);
length--;
}
return data;
}
/* */
void capwap_mtudiscovery_element_free(void* data) {
static void capwap_mtudiscovery_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_mtudiscovery_ops = {
.create_message_element = capwap_mtudiscovery_element_create,
.parsing_message_element = capwap_mtudiscovery_element_parsing,
.free_parsed_message_element = capwap_mtudiscovery_element_free
};

13
src/common/capwap_element_mtudiscovery.h
View File

@ -4,18 +4,9 @@
#define CAPWAP_ELEMENT_MTUDISCOVERY 52
struct capwap_mtudiscovery_element {
unsigned short length;
uint16_t length;
};
struct capwap_message_element* capwap_mtudiscovery_element_create(void* data, unsigned long length);
int capwap_mtudiscovery_element_validate(struct capwap_message_element* element);
void* capwap_mtudiscovery_element_parsing(struct capwap_message_element* element);
void capwap_mtudiscovery_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_mtudiscovery_ops;
/* Helper */
#define CAPWAP_CREATE_MTUDISCOVERY_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_MTUDISCOVERY); \
f->create(x, sizeof(struct capwap_mtudiscovery_element)); \
})
#endif /* __CAPWAP_ELEMENT_MTUDISCOVERY_HEADER__ */

73
src/common/capwap_element_radioadmstate.c
View File

@ -10,57 +10,31 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 31 for Radio Administrative State
Length: 2
********************************************************************/
struct capwap_radioadmstate_raw_element {
unsigned char radioid;
unsigned char state;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_radioadmstate_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_radioadmstate_element* dataelement = (struct capwap_radioadmstate_element*)data;
struct capwap_radioadmstate_raw_element* dataraw;
static void capwap_radioadmstate_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_radioadmstate_element* element = (struct capwap_radioadmstate_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_radioadmstate_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_radioadmstate_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_radioadmstate_raw_element));
element->type = htons(CAPWAP_ELEMENT_RADIOADMSTATE);
element->length = htons(sizeof(struct capwap_radioadmstate_raw_element));
dataraw = (struct capwap_radioadmstate_raw_element*)element->data;
dataraw->radioid = dataelement->radioid;
dataraw->state = dataelement->state;
return element;
/* */
func->write_u8(handle, element->radioid);
func->write_u8(handle, element->state);
}
/* */
int capwap_radioadmstate_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_radioadmstate_element_parsing(struct capwap_message_element* element) {
static void* capwap_radioadmstate_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_radioadmstate_element* data;
struct capwap_radioadmstate_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_RADIOADMSTATE);
if (ntohs(element->length) != sizeof(struct capwap_radioadmstate_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 2) {
capwap_logging_debug("Invalid Radio Administrative State element");
return NULL;
}
@ -70,17 +44,24 @@ void* capwap_radioadmstate_element_parsing(struct capwap_message_element* elemen
capwap_outofmemory();
}
/* */
dataraw = (struct capwap_radioadmstate_raw_element*)element->data;
data->radioid = dataraw->radioid;
data->state = dataraw->state;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_radioadmstate_element));
func->read_u8(handle, &data->radioid);
func->read_u8(handle, &data->state);
return data;
}
/* */
void capwap_radioadmstate_element_free(void* data) {
static void capwap_radioadmstate_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_radioadmstate_ops = {
.create_message_element = capwap_radioadmstate_element_create,
.parsing_message_element = capwap_radioadmstate_element_parsing,
.free_parsed_message_element = capwap_radioadmstate_element_free
};

21
src/common/capwap_element_radioadmstate.h
View File

@ -3,23 +3,14 @@
#define CAPWAP_ELEMENT_RADIOADMSTATE 31
struct capwap_radioadmstate_element {
unsigned char radioid;
unsigned char state;
};
#define CAPWAP_RADIO_ADMIN_STATE_ENABLED 1
#define CAPWAP_RADIO_ADMIN_STATE_DISABLED 2
struct capwap_message_element* capwap_radioadmstate_element_create(void* data, unsigned long length);
int capwap_radioadmstate_element_validate(struct capwap_message_element* element);
void* capwap_radioadmstate_element_parsing(struct capwap_message_element* element);
void capwap_radioadmstate_element_free(void* data);
struct capwap_radioadmstate_element {
uint8_t radioid;
uint8_t state;
};
extern struct capwap_message_elements_ops capwap_element_radioadmstate_ops;
/* Helper */
#define CAPWAP_CREATE_RADIOADMSTATE_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_RADIOADMSTATE); \
f->create(x, sizeof(struct capwap_radioadmstate_element)); \
})
#endif /* __CAPWAP_ELEMENT_RADIOADMSTATE_HEADER__ */

78
src/common/capwap_element_radiooprstate.c
View File

@ -10,59 +10,32 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 32 for Radio Operational State
Length: 3
********************************************************************/
struct capwap_radiooprstate_raw_element {
unsigned char radioid;
unsigned char state;
unsigned char cause;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_radiooprstate_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_radiooprstate_element* dataelement = (struct capwap_radiooprstate_element*)data;
struct capwap_radiooprstate_raw_element* dataraw;
static void capwap_radiooprstate_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_radiooprstate_element* element = (struct capwap_radiooprstate_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_radiooprstate_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_radiooprstate_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_radiooprstate_raw_element));
element->type = htons(CAPWAP_ELEMENT_RADIOOPRSTATE);
element->length = htons(sizeof(struct capwap_radiooprstate_raw_element));
dataraw = (struct capwap_radiooprstate_raw_element*)element->data;
dataraw->radioid = dataelement->radioid;
dataraw->state = dataelement->state;
dataraw->cause = dataelement->cause;
return element;
/* */
func->write_u8(handle, element->radioid);
func->write_u8(handle, element->state);
func->write_u8(handle, element->cause);
}
/* */
int capwap_radiooprstate_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_radiooprstate_element_parsing(struct capwap_message_element* element) {
static void* capwap_radiooprstate_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_radiooprstate_element* data;
struct capwap_radiooprstate_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_RADIOOPRSTATE);
if (ntohs(element->length) != sizeof(struct capwap_radiooprstate_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 3) {
capwap_logging_debug("Invalid Radio Operational State element");
return NULL;
}
@ -72,18 +45,25 @@ void* capwap_radiooprstate_element_parsing(struct capwap_message_element* elemen
capwap_outofmemory();
}
/* */
dataraw = (struct capwap_radiooprstate_raw_element*)element->data;
data->radioid = dataraw->radioid;
data->state = dataraw->state;
data->cause = dataraw->cause;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_radiooprstate_element));
func->read_u8(handle, &data->radioid);
func->read_u8(handle, &data->state);
func->read_u8(handle, &data->cause);
return data;
}
/* */
void capwap_radiooprstate_element_free(void* data) {
static void capwap_radiooprstate_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_radiooprstate_ops = {
.create_message_element = capwap_radiooprstate_element_create,
.parsing_message_element = capwap_radiooprstate_element_parsing,
.free_parsed_message_element = capwap_radiooprstate_element_free
};

23
src/common/capwap_element_radiooprstate.h
View File

@ -3,12 +3,6 @@
#define CAPWAP_ELEMENT_RADIOOPRSTATE 32
struct capwap_radiooprstate_element {
unsigned char radioid;
unsigned char state;
unsigned char cause;
};
#define CAPWAP_RADIO_OPERATIONAL_STATE_ENABLED 1
#define CAPWAP_RADIO_OPERATIONAL_STATE_DISABLED 2
@ -17,15 +11,12 @@ struct capwap_radiooprstate_element {
#define CAPWAP_RADIO_OPERATIONAL_CAUSE_SOFTWAREFAILURE 2
#define CAPWAP_RADIO_OPERATIONAL_CAUSE_ADMINSET 3
struct capwap_message_element* capwap_radiooprstate_element_create(void* data, unsigned long length);
int capwap_radiooprstate_element_validate(struct capwap_message_element* element);
void* capwap_radiooprstate_element_parsing(struct capwap_message_element* element);
void capwap_radiooprstate_element_free(void* data);
struct capwap_radiooprstate_element {
unsigned char radioid;
unsigned char state;
unsigned char cause;
};
extern struct capwap_message_elements_ops capwap_element_radiooprstate_ops;
/* Helper */
#define CAPWAP_CREATE_RADIOOPRSTATE_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_RADIOOPRSTATE); \
f->create(x, sizeof(struct capwap_radiooprstate_element)); \
})
#endif /* __CAPWAP_ELEMENT_RADIOOPRSTATE_HEADER__ */

62
src/common/capwap_element_resultcode.c
View File

@ -10,51 +10,30 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 33 for Result Code
Length: 4
********************************************************************/
struct capwap_resultcode_raw_element {
unsigned long code;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_resultcode_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
static void capwap_resultcode_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_resultcode_element* element = (struct capwap_resultcode_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_resultcode_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_resultcode_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_resultcode_raw_element));
element->type = htons(CAPWAP_ELEMENT_RESULTCODE);
element->length = htons(sizeof(struct capwap_resultcode_raw_element));
((struct capwap_resultcode_raw_element*)element->data)->code = htonl(((struct capwap_resultcode_element*)data)->code);
return element;
/* */
func->write_u32(handle, element->code);
}
/* */
int capwap_resultcode_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_resultcode_element_parsing(struct capwap_message_element* element) {
static void* capwap_resultcode_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_resultcode_element* data;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_RESULTCODE);
if (ntohs(element->length) != sizeof(struct capwap_resultcode_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 4) {
capwap_logging_debug("Invalid Result Code element");
return NULL;
}
@ -64,14 +43,23 @@ void* capwap_resultcode_element_parsing(struct capwap_message_element* element)
capwap_outofmemory();
}
/* */
data->code = ntohl(((struct capwap_resultcode_raw_element*)element->data)->code);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_resultcode_element));
func->read_u32(handle, &data->code);
return data;
}
/* */
void capwap_resultcode_element_free(void* data) {
static void capwap_resultcode_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_resultcode_ops = {
.create_message_element = capwap_resultcode_element_create,
.parsing_message_element = capwap_resultcode_element_parsing,
.free_parsed_message_element = capwap_resultcode_element_free
};

13
src/common/capwap_element_resultcode.h
View File

@ -28,18 +28,9 @@
#define CAPWAP_RESULTCODE_DATA_TRANSFER_ERROR 22
struct capwap_resultcode_element {
unsigned long code;
uint32_t code;
};
struct capwap_message_element* capwap_resultcode_element_create(void* data, unsigned long length);
int capwap_resultcode_element_validate(struct capwap_message_element* element);
void* capwap_resultcode_element_parsing(struct capwap_message_element* element);
void capwap_resultcode_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_resultcode_ops;
/* Helper */
#define CAPWAP_CREATE_RESULTCODE_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_RESULTCODE); \
f->create(x, sizeof(struct capwap_resultcode_element)); \
})
#endif /* __CAPWAP_ELEMENT_RESULTCODE_HEADER__ */

87
src/common/capwap_element_returnedmessage.c
View File

@ -10,84 +10,67 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 34 for Returned Message Element
Length: >= 6
********************************************************************/
struct capwap_returnedmessage_raw_element {
unsigned char reason;
unsigned char length;
char message[0];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_returnedmessage_element_create(void* data, unsigned long datalength) {
unsigned short length;
struct capwap_message_element* element;
struct capwap_returnedmessage_raw_element* dataraw;
struct capwap_returnedmessage_element* dataelement = (struct capwap_returnedmessage_element*)data;
static void capwap_returnedmessage_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_returnedmessage_element* element = (struct capwap_returnedmessage_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_returnedmessage_element));
/* Alloc block of memory */
length = sizeof(struct capwap_returnedmessage_raw_element) + dataelement->length;
element = capwap_alloc(sizeof(struct capwap_message_element) + length);
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element));
element->type = htons(CAPWAP_ELEMENT_RETURNEDMESSAGE);
element->length = htons(length);
dataraw = (struct capwap_returnedmessage_raw_element*)element->data;
dataraw->reason = dataelement->reason;
dataraw->length = dataelement->length;
memcpy(&dataraw->message[0], &dataelement->message[0], dataelement->length);
return element;
func->write_u8(handle, element->reason);
func->write_u8(handle, element->length);
func->write_block(handle, element->message, element->length);
}
/* */
int capwap_returnedmessage_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_returnedmessage_element_parsing(struct capwap_message_element* element) {
static void* capwap_returnedmessage_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_returnedmessage_element* data;
struct capwap_returnedmessage_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_RETURNEDMESSAGE);
length = ntohs(element->length) - sizeof(struct capwap_returnedmessage_raw_element);
if (length > CAPWAP_RETURNED_MESSAGE_MAX_LENGTH) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if (length < 6) {
capwap_logging_debug("Invalid Returned Message element");
return NULL;
}
length -= 2;
if (length > CAPWAP_RETURNED_MESSAGE_MAX_LENGTH) {
capwap_logging_debug("Invalid Returned Message element");
return NULL;
}
/* */
dataraw = (struct capwap_returnedmessage_raw_element*)element->data;
data = (struct capwap_returnedmessage_element*)capwap_alloc(sizeof(struct capwap_returnedmessage_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->reason = dataraw->reason;
data->length = dataraw->length;
memcpy(&data->message[0], &dataraw->message[0], dataraw->length);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_returnedmessage_element));
func->read_u8(handle, &data->reason);
func->read_u8(handle, &data->length);
func->read_block(handle, data->message, data->length);
return data;
}
/* */
void capwap_returnedmessage_element_free(void* data) {
static void capwap_returnedmessage_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_returnedmessage_ops = {
.create_message_element = capwap_returnedmessage_element_create,
.parsing_message_element = capwap_returnedmessage_element_parsing,
.free_parsed_message_element = capwap_returnedmessage_element_free
};

17
src/common/capwap_element_returnedmessage.h
View File

@ -11,20 +11,11 @@
#define CAPWAP_RETURNED_MESSAGE_MAX_LENGTH 255
struct capwap_returnedmessage_element {
unsigned char reason;
unsigned char length;
char message[CAPWAP_RETURNED_MESSAGE_MAX_LENGTH];
uint8_t reason;
uint8_t length;
uint8_t message[CAPWAP_RETURNED_MESSAGE_MAX_LENGTH];
};
struct capwap_message_element* capwap_returnedmessage_element_create(void* data, unsigned long length);
int capwap_returnedmessage_element_validate(struct capwap_message_element* element);
void* capwap_returnedmessage_element_parsing(struct capwap_message_element* element);
void capwap_returnedmessage_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_returnedmessage_ops;
/* Helper */
#define CAPWAP_CREATE_RETURNEDMESSAGE_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_RETURNEDMESSAGE); \
f->create(x, sizeof(struct capwap_returnedmessage_element)); \
})
#endif /* __CAPWAP_ELEMENT_RETURNEDMESSAGE_HEADER__ */

114
src/common/capwap_element_sessionid.c
View File

@ -21,72 +21,6 @@ Length: 16
********************************************************************/
struct capwap_sessionid_raw_element {
unsigned char id[16];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_sessionid_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_sessionid_raw_element* dataraw;
struct capwap_sessionid_element* dataelement = (struct capwap_sessionid_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_sessionid_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_sessionid_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_sessionid_element));
element->type = htons(CAPWAP_ELEMENT_SESSIONID);
element->length = htons(sizeof(struct capwap_sessionid_element));
dataraw = (struct capwap_sessionid_raw_element*)element->data;
memcpy(&dataraw->id[0], &dataelement->id[0], sizeof(unsigned char) * 16);
return element;
}
/* */
int capwap_sessionid_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_sessionid_element_parsing(struct capwap_message_element* element) {
struct capwap_sessionid_element* data;
struct capwap_sessionid_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_SESSIONID);
if (ntohs(element->length) != sizeof(struct capwap_sessionid_raw_element)) {
return NULL;
}
/* */
dataraw = (struct capwap_sessionid_raw_element*)element->data;
data = (struct capwap_sessionid_element*)capwap_alloc(sizeof(struct capwap_sessionid_element));
if (!data) {
capwap_outofmemory();
}
/* */
memcpy(&data->id[0], &dataraw->id[0], sizeof(unsigned char) * 16);
return data;
}
/* */
void capwap_sessionid_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
void capwap_sessionid_generate(struct capwap_sessionid_element* session) {
int i;
@ -113,3 +47,51 @@ void capwap_sessionid_printf(struct capwap_sessionid_element* session, char* str
*pos = 0;
}
/* */
static void capwap_sessionid_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_sessionid_element* element = (struct capwap_sessionid_element*)data;
ASSERT(data != NULL);
func->write_block(handle, element->id, 16);
}
/* */
static void* capwap_sessionid_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_sessionid_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 16) {
capwap_logging_debug("Invalid Session ID element");
return NULL;
}
/* */
data = (struct capwap_sessionid_element*)capwap_alloc(sizeof(struct capwap_sessionid_element));
if (!data) {
capwap_outofmemory();
}
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_sessionid_element));
func->read_block(handle, data->id, 16);
return data;
}
/* */
static void capwap_sessionid_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_sessionid_ops = {
.create_message_element = capwap_sessionid_element_create,
.parsing_message_element = capwap_sessionid_element_parsing,
.free_parsed_message_element = capwap_sessionid_element_free
};

14
src/common/capwap_element_sessionid.h
View File

@ -4,21 +4,13 @@
#define CAPWAP_ELEMENT_SESSIONID 35
struct capwap_sessionid_element {
unsigned char id[16];
uint8_t id[16];
};
struct capwap_message_element* capwap_sessionid_element_create(void* data, unsigned long datalength);
int capwap_sessionid_element_validate(struct capwap_message_element* element);
void* capwap_sessionid_element_parsing(struct capwap_message_element* element);
void capwap_sessionid_element_free(void* data);
/* */
void capwap_sessionid_generate(struct capwap_sessionid_element* session);
void capwap_sessionid_printf(struct capwap_sessionid_element* session, char* string);
/* Helper */
#define CAPWAP_CREATE_SESSIONID_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_SESSIONID); \
f->create(x, sizeof(struct capwap_sessionid_element)); \
})
extern struct capwap_message_elements_ops capwap_element_sessionid_ops;
#endif /* __CAPWAP_ELEMENT_SESSIONID_HEADER__ */

62
src/common/capwap_element_statisticstimer.c
View File

@ -10,51 +10,30 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 36 for Statistics Timer
Length: 2
********************************************************************/
struct capwap_statisticstimer_raw_element {
unsigned short timer;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_statisticstimer_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
static void capwap_statisticstimer_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_statisticstimer_element* element = (struct capwap_statisticstimer_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_statisticstimer_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_statisticstimer_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_statisticstimer_raw_element));
element->type = htons(CAPWAP_ELEMENT_STATISTICSTIMER);
element->length = htons(sizeof(struct capwap_statisticstimer_raw_element));
((struct capwap_statisticstimer_raw_element*)element->data)->timer = htons(((struct capwap_statisticstimer_element*)data)->timer);
return element;
/* */
func->write_u16(handle, element->timer);
}
/* */
int capwap_statisticstimer_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_statisticstimer_element_parsing(struct capwap_message_element* element) {
static void* capwap_statisticstimer_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_statisticstimer_element* data;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_STATISTICSTIMER);
if (ntohs(element->length) != sizeof(struct capwap_statisticstimer_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 2) {
capwap_logging_debug("Invalid Statistics Timer element");
return NULL;
}
@ -64,14 +43,23 @@ void* capwap_statisticstimer_element_parsing(struct capwap_message_element* elem
capwap_outofmemory();
}
/* */
data->timer = ntohs(((struct capwap_statisticstimer_raw_element*)element->data)->timer);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_statisticstimer_element));
func->read_u16(handle, &data->timer);
return data;
}
/* */
void capwap_statisticstimer_element_free(void* data) {
static void capwap_statisticstimer_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_statisticstimer_ops = {
.create_message_element = capwap_statisticstimer_element_create,
.parsing_message_element = capwap_statisticstimer_element_parsing,
.free_parsed_message_element = capwap_statisticstimer_element_free
};

13
src/common/capwap_element_statisticstimer.h
View File

@ -4,18 +4,9 @@
#define CAPWAP_ELEMENT_STATISTICSTIMER 36
struct capwap_statisticstimer_element {
unsigned short timer;
uint16_t timer;
};
struct capwap_message_element* capwap_statisticstimer_element_create(void* data, unsigned long length);
int capwap_statisticstimer_element_validate(struct capwap_message_element* element);
void* capwap_statisticstimer_element_parsing(struct capwap_message_element* element);
void capwap_statisticstimer_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_statisticstimer_ops;
/* Helper */
#define CAPWAP_CREATE_STATISTICSTIMER_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_STATISTICSTIMER); \
f->create(x, sizeof(struct capwap_statisticstimer_element)); \
})
#endif /* __CAPWAP_ELEMENT_STATISTICSTIMER_HEADER__ */

73
src/common/capwap_element_timers.c
View File

@ -10,57 +10,31 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 12 for CAPWAP Timers
Length: 2
********************************************************************/
struct capwap_timers_raw_element {
unsigned char discovery;
unsigned char echorequest;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_timers_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_timers_element* dataelement = (struct capwap_timers_element*)data;
struct capwap_timers_raw_element* dataraw;
static void capwap_timers_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_timers_element* element = (struct capwap_timers_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_timers_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_timers_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_timers_raw_element));
element->type = htons(CAPWAP_ELEMENT_TIMERS);
element->length = htons(sizeof(struct capwap_timers_raw_element));
dataraw = (struct capwap_timers_raw_element*)element->data;
dataraw->discovery = dataelement->discovery;
dataraw->echorequest = dataelement->echorequest;
return element;
/* */
func->write_u8(handle, element->discovery);
func->write_u8(handle, element->echorequest);
}
/* */
int capwap_timers_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_timers_element_parsing(struct capwap_message_element* element) {
static void* capwap_timers_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_timers_element* data;
struct capwap_timers_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_TIMERS);
if (ntohs(element->length) != sizeof(struct capwap_timers_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 2) {
capwap_logging_debug("Invalid Timers element");
return NULL;
}
@ -70,17 +44,24 @@ void* capwap_timers_element_parsing(struct capwap_message_element* element) {
capwap_outofmemory();
}
/* */
dataraw = (struct capwap_timers_raw_element*)element->data;
data->discovery = dataraw->discovery;
data->echorequest = dataraw->echorequest;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_timers_element));
func->read_u8(handle, &data->discovery);
func->read_u8(handle, &data->echorequest);
return data;
}
/* */
void capwap_timers_element_free(void* data) {
static void capwap_timers_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_timers_ops = {
.create_message_element = capwap_timers_element_create,
.parsing_message_element = capwap_timers_element_parsing,
.free_parsed_message_element = capwap_timers_element_free
};

15
src/common/capwap_element_timers.h
View File

@ -4,19 +4,10 @@
#define CAPWAP_ELEMENT_TIMERS 12
struct capwap_timers_element {
unsigned char discovery;
unsigned char echorequest;
uint8_t discovery;
uint8_t echorequest;
};
struct capwap_message_element* capwap_timers_element_create(void* data, unsigned long length);
int capwap_timers_element_validate(struct capwap_message_element* element);
void* capwap_timers_element_parsing(struct capwap_message_element* element);
void capwap_timers_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_timers_ops;
/* Helper */
#define CAPWAP_CREATE_TIMERS_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_TIMERS); \
f->create(x, sizeof(struct capwap_timers_element)); \
})
#endif /* __CAPWAP_ELEMENT_TIMERS_HEADER__ */

62
src/common/capwap_element_transport.c
View File

@ -10,51 +10,30 @@
+-+-+-+-+-+-+-+-+
Type: 51 for CAPWAP Transport Protocol
Length: 1
********************************************************************/
struct capwap_transport_raw_element {
char type;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_transport_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
static void capwap_transport_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_transport_element* element = (struct capwap_transport_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_transport_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_transport_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_transport_raw_element));
element->type = htons(CAPWAP_ELEMENT_TRANSPORT);
element->length = htons(sizeof(struct capwap_transport_raw_element));
((struct capwap_transport_raw_element*)element->data)->type = ((struct capwap_transport_element*)data)->type;
return element;
/* */
func->write_u8(handle, element->type);
}
/* */
int capwap_transport_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_transport_element_parsing(struct capwap_message_element* element) {
static void* capwap_transport_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_transport_element* data;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_TRANSPORT);
if (ntohs(element->length) != sizeof(struct capwap_transport_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 1) {
capwap_logging_debug("Invalid Transport Protocol element");
return NULL;
}
@ -64,14 +43,23 @@ void* capwap_transport_element_parsing(struct capwap_message_element* element) {
capwap_outofmemory();
}
/* */
data->type = ((struct capwap_transport_raw_element*)element->data)->type;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_transport_element));
func->read_u8(handle, &data->type);
return data;
}
/* */
void capwap_transport_element_free(void* data) {
static void capwap_transport_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_transport_ops = {
.create_message_element = capwap_transport_element_create,
.parsing_message_element = capwap_transport_element_parsing,
.free_parsed_message_element = capwap_transport_element_free
};

19
src/common/capwap_element_transport.h
View File

@ -3,22 +3,13 @@
#define CAPWAP_ELEMENT_TRANSPORT 51
struct capwap_transport_element {
char type;
};
#define CAPWAP_UDPLITE_TRANSPORT 1
#define CAPWAP_UDP_TRANSPORT 2
struct capwap_message_element* capwap_transport_element_create(void* data, unsigned long length);
int capwap_transport_element_validate(struct capwap_message_element* element);
void* capwap_transport_element_parsing(struct capwap_message_element* element);
void capwap_transport_element_free(void* data);
struct capwap_transport_element {
uint8_t type;
};
extern struct capwap_message_elements_ops capwap_element_transport_ops;
/* Helper */
#define CAPWAP_CREATE_TRANSPORT_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_TRANSPORT); \
f->create(x, sizeof(struct capwap_transport_element)); \
})
#endif /* __CAPWAP_ELEMENT_TRANSPORT_HEADER__ */

91
src/common/capwap_element_vendorpayload.c
View File

@ -12,88 +12,67 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 37 for Vendor Specific Payload
Length: >= 7
********************************************************************/
struct capwap_vendorpayload_raw_element {
unsigned long vendorid;
unsigned short elementid;
char data[0];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_vendorpayload_element_create(void* data, unsigned long datalength) {
unsigned short elementlength;
struct capwap_message_element* element;
struct capwap_vendorpayload_raw_element* dataraw;
struct capwap_vendorpayload_element* dataelement = (struct capwap_vendorpayload_element*)data;
static void capwap_vendorpayload_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_vendorpayload_element* element = (struct capwap_vendorpayload_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_vendorpayload_element));
/* */
if (!dataelement->datalength || (dataelement->datalength > CAPWAP_VENDORPAYLOAD_MAXLENGTH)) {
return NULL;
}
/* Alloc block of memory */
elementlength = sizeof(struct capwap_vendorpayload_raw_element) + dataelement->datalength;
element = capwap_alloc(sizeof(struct capwap_message_element) + elementlength);
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + elementlength);
element->type = htons(CAPWAP_ELEMENT_VENDORPAYLOAD);
element->length = htons(elementlength);
dataraw = (struct capwap_vendorpayload_raw_element*)element->data;
dataraw->vendorid = htonl(dataelement->vendorid);
dataraw->elementid = htons(dataelement->elementid);
memcpy(&dataraw->data[0], &dataelement->data[0], dataelement->datalength);
return element;
func->write_u32(handle, element->vendorid);
func->write_u16(handle, element->elementid);
func->write_block(handle, element->data, element->datalength);
}
/* */
int capwap_vendorpayload_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_vendorpayload_element_parsing(struct capwap_message_element* element) {
unsigned short elementlength;
static void* capwap_vendorpayload_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_vendorpayload_element* data;
struct capwap_vendorpayload_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_VENDORPAYLOAD);
elementlength = ntohs(element->length);
if (elementlength > sizeof(struct capwap_vendorpayload_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if (length < 7) {
capwap_logging_debug("Invalid Vendor Specific Payload element");
return NULL;
}
length -= 6;
if (length > CAPWAP_VENDORPAYLOAD_MAXLENGTH) {
capwap_logging_debug("Invalid Vendor Specific Payload element");
return NULL;
}
/* */
dataraw = (struct capwap_vendorpayload_raw_element*)element->data;
data = (struct capwap_vendorpayload_element*)capwap_alloc(sizeof(struct capwap_vendorpayload_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->vendorid = ntohl(dataraw->vendorid);
data->elementid = ntohs(dataraw->elementid);
data->datalength = elementlength - sizeof(struct capwap_vendorpayload_element);
memcpy(&data->data[0], &dataraw->data[0], data->datalength);
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_vendorpayload_element));
func->read_u32(handle, &data->vendorid);
func->read_u16(handle, &data->elementid);
func->read_block(handle, data->data, length);
return data;
}
/* */
void capwap_vendorpayload_element_free(void* data) {
static void capwap_vendorpayload_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_vendorpayload_ops = {
.create_message_element = capwap_vendorpayload_element_create,
.parsing_message_element = capwap_vendorpayload_element_parsing,
.free_parsed_message_element = capwap_vendorpayload_element_free
};

20
src/common/capwap_element_vendorpayload.h
View File

@ -6,22 +6,12 @@
#define CAPWAP_VENDORPAYLOAD_MAXLENGTH 2048
struct capwap_vendorpayload_element {
unsigned long vendorid;
unsigned short elementid;
unsigned short datalength;
char data[CAPWAP_VENDORPAYLOAD_MAXLENGTH];
uint32_t vendorid;
uint16_t elementid;
uint16_t datalength;
uint8_t data[CAPWAP_VENDORPAYLOAD_MAXLENGTH];
};
struct capwap_message_element* capwap_vendorpayload_element_create(void* data, unsigned long datalength);
int capwap_vendorpayload_element_validate(struct capwap_message_element* element);
void* capwap_vendorpayload_element_parsing(struct capwap_message_element* element);
void capwap_vendorpayload_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_VENDORPAYLOAD_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_VENDORPAYLOAD_MAXLENGTH); \
f->create(x, sizeof(struct capwap_vendorpayload_element)); \
})
extern struct capwap_message_elements_ops capwap_element_vendorpayload_ops;
#endif /* __CAPWAP_ELEMENT_VENDORPAYLOAD_HEADER__ */

162
src/common/capwap_element_wtpboarddata.c
View File

@ -21,141 +21,93 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 38 for WTP Board Data
Length: >=14
********************************************************************/
struct capwap_wtpboarddata_raw_element {
unsigned long vendor;
char data[0];
} __attribute__((__packed__));
struct capwap_wtpboarddata_raw_board_subelement {
unsigned short type;
unsigned short length;
char data[0];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_wtpboarddata_element_create(void* data, unsigned long datalength) {
char* pos;
unsigned long i;
unsigned short length;
struct capwap_message_element* element;
struct capwap_wtpboarddata_raw_element* dataraw;
struct capwap_wtpboarddata_element* dataelement = (struct capwap_wtpboarddata_element*)data;
static void capwap_wtpboarddata_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
int i;
struct capwap_wtpboarddata_element* element = (struct capwap_wtpboarddata_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_wtpboarddata_element));
ASSERT(dataelement->boardsubelement != NULL);
/* Calc length packet */
length = sizeof(struct capwap_wtpboarddata_raw_element);
for (i = 0; i < dataelement->boardsubelement->count; i++) {
struct capwap_wtpboarddata_board_subelement* board = (struct capwap_wtpboarddata_board_subelement*)capwap_array_get_item_pointer(dataelement->boardsubelement, i);
length += sizeof(struct capwap_wtpboarddata_raw_board_subelement) + board->length;
}
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + length);
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + length);
element->type = htons(CAPWAP_ELEMENT_WTPBOARDDATA);
element->length = htons(length);
/* */
dataraw = (struct capwap_wtpboarddata_raw_element*)element->data;
dataraw->vendor = htonl(dataelement->vendor);
pos = dataraw->data;
/* Board Sub-Element */
for (i = 0; i < dataelement->boardsubelement->count; i++) {
struct capwap_wtpboarddata_raw_board_subelement* boardraw = (struct capwap_wtpboarddata_raw_board_subelement*)pos;
struct capwap_wtpboarddata_board_subelement* board = (struct capwap_wtpboarddata_board_subelement*)capwap_array_get_item_pointer(dataelement->boardsubelement, i);
boardraw->type = htons(board->type);
boardraw->length = htons(board->length);
memcpy(boardraw->data, board->data, board->length);
pos += sizeof(struct capwap_wtpboarddata_raw_board_subelement) + board->length;
func->write_u32(handle, element->vendor);
/* */
for (i = 0; i < element->boardsubelement->count; i++) {
struct capwap_wtpboarddata_board_subelement* desc = (struct capwap_wtpboarddata_board_subelement*)capwap_array_get_item_pointer(element->boardsubelement, i);
func->write_u16(handle, desc->type);
func->write_u16(handle, desc->length);
func->write_block(handle, desc->data, desc->length);
}
return element;
}
/* */
int capwap_wtpboarddata_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
static void capwap_wtpboarddata_element_free(void* data) {
struct capwap_wtpboarddata_element* dataelement = (struct capwap_wtpboarddata_element*)data;
ASSERT(dataelement != NULL);
ASSERT(dataelement->boardsubelement != NULL);
capwap_array_free(dataelement->boardsubelement);
capwap_free(dataelement);
}
/* */
void* capwap_wtpboarddata_element_parsing(struct capwap_message_element* element) {
long i;
char* pos;
long length;
static void* capwap_wtpboarddata_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_wtpboarddata_element* data;
struct capwap_wtpboarddata_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_WTPBOARDDATA);
length = (long)ntohs(element->length);
if (length < 14) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) < 14) {
capwap_logging_debug("Invalid WTP Board Data element");
return NULL;
}
/* */
dataraw = (struct capwap_wtpboarddata_raw_element*)element->data;
data = (struct capwap_wtpboarddata_element*)capwap_alloc(sizeof(struct capwap_wtpboarddata_element));
data->boardsubelement = capwap_array_create(sizeof(struct capwap_wtpboarddata_board_subelement), 0);
/* */
data->vendor = ntohl(dataraw->vendor);
pos = dataraw->data;
length -= sizeof(struct capwap_wtpboarddata_raw_element);
if (!data) {
capwap_outofmemory();
}
/* Board Subelement */
i = 0;
while (length > 0) {
struct capwap_wtpboarddata_board_subelement* board = (struct capwap_wtpboarddata_board_subelement*)capwap_array_get_item_pointer(data->boardsubelement, i);
struct capwap_wtpboarddata_raw_board_subelement* boardraw = (struct capwap_wtpboarddata_raw_board_subelement*)pos;
unsigned short boardlength = ntohs(boardraw->length);
unsigned short boardrawlength = sizeof(struct capwap_wtpboarddata_raw_board_subelement) + boardlength;
if ((boardlength > CAPWAP_BOARD_SUBELEMENT_MAXDATA) || (length < boardrawlength)) {
memset(data, 0, sizeof(struct capwap_wtpboarddata_element));
data->boardsubelement = capwap_array_create(sizeof(struct capwap_wtpboarddata_board_subelement), 0);
data->boardsubelement->zeroed = 1;
/* Retrieve data */
func->read_u32(handle, &data->vendor);
/* WTP Board Data Subelement */
while (func->read_ready(handle) > 0) {
unsigned short length;
struct capwap_wtpboarddata_board_subelement* desc = (struct capwap_wtpboarddata_board_subelement*)capwap_array_get_item_pointer(data->boardsubelement, data->boardsubelement->count);
/* */
func->read_u16(handle, &desc->type);
func->read_u16(handle, &desc->length);
/* Check buffer size */
length = func->read_ready(handle);
if ((length > CAPWAP_BOARD_SUBELEMENT_MAXDATA) || (length < desc->length)) {
capwap_logging_debug("Invalid WTP Board Data element");
capwap_wtpboarddata_element_free(data);
return NULL;
}
/* */
board->type = ntohs(boardraw->type);
board->length = boardlength;
memcpy(board->data, boardraw->data, boardlength);
/* */
i++;
pos += boardrawlength;
length -= boardrawlength;
func->read_block(handle, desc->data, desc->length);
}
return data;
}
/* */
void capwap_wtpboarddata_element_free(void* data) {
struct capwap_wtpboarddata_element* dataelement = (struct capwap_wtpboarddata_element*)data;
ASSERT(dataelement != NULL);
ASSERT(dataelement->boardsubelement != NULL);
capwap_array_free(dataelement->boardsubelement);
capwap_free(dataelement);
}
struct capwap_message_elements_ops capwap_element_wtpboarddata_ops = {
.create_message_element = capwap_wtpboarddata_element_create,
.parsing_message_element = capwap_wtpboarddata_element_parsing,
.free_parsed_message_element = capwap_wtpboarddata_element_free
};

19
src/common/capwap_element_wtpboarddata.h
View File

@ -4,7 +4,7 @@
#define CAPWAP_ELEMENT_WTPBOARDDATA 38
struct capwap_wtpboarddata_element {
unsigned long vendor;
uint32_t vendor;
struct capwap_array* boardsubelement;
};
@ -16,20 +16,11 @@ struct capwap_wtpboarddata_element {
#define CAPWAP_BOARD_SUBELEMENT_MAXDATA 1024
struct capwap_wtpboarddata_board_subelement {
unsigned short type;
unsigned short length;
char data[CAPWAP_BOARD_SUBELEMENT_MAXDATA];
uint16_t type;
uint16_t length;
uint8_t data[CAPWAP_BOARD_SUBELEMENT_MAXDATA];
};
struct capwap_message_element* capwap_wtpboarddata_element_create(void* data, unsigned long datalength);
int capwap_wtpboarddata_element_validate(struct capwap_message_element* element);
void* capwap_wtpboarddata_element_parsing(struct capwap_message_element* element);
void capwap_wtpboarddata_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_wtpboarddata_ops;
/* Helper */
#define CAPWAP_CREATE_WTPBOARDDATA_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_WTPBOARDDATA); \
f->create(x, sizeof(struct capwap_wtpboarddata_element)); \
})
#endif /* __CAPWAP_ELEMENT_WTPBOARDDATA_HEADER__ */

268
src/common/capwap_element_wtpdescriptor.c
View File

@ -29,128 +29,65 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 39 for WTP Descriptor
Length: >= 33
********************************************************************/
struct capwap_wtpdescriptor_raw_element {
unsigned char maxradios;
unsigned char radiosinuse;
unsigned char encryptcount;
char data[0];
} __attribute__((__packed__));
struct capwap_wtpdescriptor_raw_encrypt_subelement {
#ifdef CAPWAP_BIG_ENDIAN
unsigned char reserved : 3;
unsigned char wbid : 5;
#else
unsigned char wbid : 5;
unsigned char reserved : 3;
#endif
unsigned short capabilities;
} __attribute__((__packed__));
struct capwap_wtpdescriptor_raw_desc_subelement {
unsigned long vendor;
unsigned short type;
unsigned short length;
char data[0];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_wtpdescriptor_element_create(void* data, unsigned long datalength) {
char* pos;
unsigned long i;
unsigned short length;
struct capwap_message_element* element;
struct capwap_wtpdescriptor_raw_element* dataraw;
struct capwap_wtpdescriptor_element* dataelement = (struct capwap_wtpdescriptor_element*)data;
static void capwap_wtpdescriptor_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
int i;
struct capwap_wtpdescriptor_element* element = (struct capwap_wtpdescriptor_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_wtpdescriptor_element));
ASSERT(dataelement->encryptsubelement != NULL);
ASSERT(dataelement->descsubelement != NULL);
/* Calc length packet */
length = sizeof(struct capwap_wtpdescriptor_raw_element);
length += dataelement->encryptsubelement->count * sizeof(struct capwap_wtpdescriptor_raw_encrypt_subelement);
for (i = 0; i < dataelement->descsubelement->count; i++) {
struct capwap_wtpdescriptor_desc_subelement* desc = (struct capwap_wtpdescriptor_desc_subelement*)capwap_array_get_item_pointer(dataelement->descsubelement, i);
length += sizeof(struct capwap_wtpdescriptor_raw_desc_subelement) + desc->length;
}
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + length);
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + length);
element->type = htons(CAPWAP_ELEMENT_WTPDESCRIPTOR);
element->length = htons(length);
/* */
func->write_u8(handle, element->maxradios);
func->write_u8(handle, element->radiosinuse);
func->write_u8(handle, element->encryptsubelement->count);
/* Descriptor */
dataraw = (struct capwap_wtpdescriptor_raw_element*)element->data;
dataraw->maxradios = dataelement->maxradios;
dataraw->radiosinuse = dataelement->radiosinuse;
dataraw->encryptcount = (unsigned char)dataelement->encryptsubelement->count;
pos = dataraw->data;
/* */
for (i = 0; i < element->encryptsubelement->count; i++) {
struct capwap_wtpdescriptor_encrypt_subelement* desc = (struct capwap_wtpdescriptor_encrypt_subelement*)capwap_array_get_item_pointer(element->encryptsubelement, i);
/* Encryption Sub-Element */
for (i = 0; i < dataelement->encryptsubelement->count; i++) {
struct capwap_wtpdescriptor_raw_encrypt_subelement* encryptraw = (struct capwap_wtpdescriptor_raw_encrypt_subelement*)pos;
struct capwap_wtpdescriptor_encrypt_subelement* encrypt = (struct capwap_wtpdescriptor_encrypt_subelement*)capwap_array_get_item_pointer(dataelement->encryptsubelement, i);
encryptraw->wbid = encrypt->wbid;
encryptraw->capabilities = htons(encrypt->capabilities);
pos += sizeof(struct capwap_wtpdescriptor_raw_encrypt_subelement);
}
/* Descriptor Sub-Element */
for (i = 0; i < dataelement->descsubelement->count; i++) {
struct capwap_wtpdescriptor_raw_desc_subelement* descraw = (struct capwap_wtpdescriptor_raw_desc_subelement*)pos;
struct capwap_wtpdescriptor_desc_subelement* desc = (struct capwap_wtpdescriptor_desc_subelement*)capwap_array_get_item_pointer(dataelement->descsubelement, i);
descraw->vendor = htonl(desc->vendor);
descraw->type = htons(desc->type);
descraw->length = htons(desc->length);
memcpy(descraw->data, desc->data, desc->length);
pos += sizeof(struct capwap_wtpdescriptor_raw_desc_subelement) + desc->length;
}
return element;
}
/* */
int capwap_wtpdescriptor_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_wtpdescriptor_element_parsing(struct capwap_message_element* element) {
unsigned char i;
long length;
char* pos;
struct capwap_wtpdescriptor_element* data;
struct capwap_wtpdescriptor_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_WTPDESCRIPTOR);
length = (long)ntohs(element->length);
if (length < 33) {
capwap_logging_debug("Invalid WTP Descriptor element");
return NULL;
func->write_u8(handle, desc->wbid & 0x1f);
func->write_u16(handle, desc->capabilities);
}
/* */
dataraw = (struct capwap_wtpdescriptor_raw_element*)element->data;
if ((dataraw->radiosinuse > dataraw->maxradios) || (dataraw->encryptcount == 0)) {
for (i = 0; i < element->descsubelement->count; i++) {
struct capwap_wtpdescriptor_desc_subelement* desc = (struct capwap_wtpdescriptor_desc_subelement*)capwap_array_get_item_pointer(element->descsubelement, i);
func->write_u32(handle, desc->vendor);
func->write_u16(handle, desc->type);
func->write_u16(handle, desc->length);
func->write_block(handle, desc->data, desc->length);
}
}
/* */
static void capwap_wtpdescriptor_element_free(void* data) {
struct capwap_wtpdescriptor_element* dataelement = (struct capwap_wtpdescriptor_element*)data;
ASSERT(dataelement != NULL);
ASSERT(dataelement->encryptsubelement != NULL);
ASSERT(dataelement->descsubelement != NULL);
capwap_array_free(dataelement->encryptsubelement);
capwap_array_free(dataelement->descsubelement);
capwap_free(dataelement);
}
/* */
static void* capwap_wtpdescriptor_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
uint8_t i;
uint8_t encryptlength;
struct capwap_wtpdescriptor_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) < 33) {
capwap_logging_debug("Invalid WTP Descriptor element");
return NULL;
}
@ -161,81 +98,76 @@ void* capwap_wtpdescriptor_element_parsing(struct capwap_message_element* elemen
capwap_outofmemory();
}
memset(data, 0, sizeof(struct capwap_wtpdescriptor_element));
data->encryptsubelement = capwap_array_create(sizeof(struct capwap_wtpdescriptor_encrypt_subelement), 0);
data->encryptsubelement->zeroed = 1;
data->descsubelement = capwap_array_create(sizeof(struct capwap_wtpdescriptor_desc_subelement), 0);
/* */
data->maxradios = dataraw->maxradios;
data->radiosinuse = dataraw->radiosinuse;
capwap_array_resize(data->encryptsubelement, dataraw->encryptcount);
pos = dataraw->data;
length -= sizeof(struct capwap_wtpdescriptor_raw_element);
/* Encrypt Subelement */
for (i = 0; i < dataraw->encryptcount; i++) {
struct capwap_wtpdescriptor_encrypt_subelement* encrypt = (struct capwap_wtpdescriptor_encrypt_subelement*)capwap_array_get_item_pointer(data->encryptsubelement, i);
struct capwap_wtpdescriptor_raw_encrypt_subelement* encryptraw = (struct capwap_wtpdescriptor_raw_encrypt_subelement*)pos;
if (length < sizeof(struct capwap_wtpdescriptor_raw_element)) {
capwap_logging_debug("Invalid WTP Descriptor element");
capwap_wtpdescriptor_element_free(data);
return NULL;
}
data->descsubelement->zeroed = 1;
/* */
encrypt->wbid = encryptraw->wbid;
encrypt->capabilities = ntohs(encryptraw->capabilities);
/* Retrieve data */
func->read_u8(handle, &data->maxradios);
func->read_u8(handle, &data->radiosinuse);
func->read_u8(handle, &encryptlength);
/* */
pos += sizeof(struct capwap_wtpdescriptor_raw_encrypt_subelement);
length -= sizeof(struct capwap_wtpdescriptor_raw_element);
}
if (length < 0) {
/* Check */
if (!encryptlength) {
capwap_logging_debug("Invalid WTP Descriptor element");
capwap_wtpdescriptor_element_free(data);
return NULL;
}
/* Description Subelement */
i = 0;
while (length > 0) {
struct capwap_wtpdescriptor_desc_subelement* desc = (struct capwap_wtpdescriptor_desc_subelement*)capwap_array_get_item_pointer(data->descsubelement, i);
struct capwap_wtpdescriptor_raw_desc_subelement* descraw = (struct capwap_wtpdescriptor_raw_desc_subelement*)pos;
unsigned short desclength = ntohs(descraw->length);
unsigned short descrawlength = sizeof(struct capwap_wtpdescriptor_raw_desc_subelement) + desclength;
if ((desclength > CAPWAP_WTPDESC_SUBELEMENT_MAXDATA) || (length < descrawlength)) {
/* Encryption Subelement */
for (i = 0; i < encryptlength; i++) {
struct capwap_wtpdescriptor_encrypt_subelement* desc;
/* Check */
if (func->read_ready(handle) < 3) {
capwap_logging_debug("Invalid WTP Descriptor element");
capwap_wtpdescriptor_element_free(data);
return NULL;
}
/* */
desc->vendor = ntohl(descraw->vendor);
desc->type = ntohs(descraw->type);
desc->length = desclength;
memcpy(desc->data, descraw->data, desclength);
/* */
i++;
pos += descrawlength;
length -= descrawlength;
desc = (struct capwap_wtpdescriptor_encrypt_subelement*)capwap_array_get_item_pointer(data->encryptsubelement, data->encryptsubelement->count);
func->read_u8(handle, &desc->wbid);
func->read_u16(handle, &desc->capabilities);
}
/* WTP Description Subelement */
while (func->read_ready(handle) > 0) {
unsigned short length;
struct capwap_wtpdescriptor_desc_subelement* desc;
/* Check */
if (func->read_ready(handle) < 8) {
capwap_logging_debug("Invalid WTP Descriptor element");
capwap_wtpdescriptor_element_free(data);
return NULL;
}
/* */
desc = (struct capwap_wtpdescriptor_desc_subelement*)capwap_array_get_item_pointer(data->descsubelement, data->descsubelement->count);
func->read_u32(handle, &desc->vendor);
func->read_u16(handle, &desc->type);
func->read_u16(handle, &desc->length);
/* Check buffer size */
length = func->read_ready(handle);
if ((length > CAPWAP_WTPDESC_SUBELEMENT_MAXDATA) || (length < desc->length)) {
capwap_logging_debug("Invalid WTP Descriptor element");
capwap_wtpdescriptor_element_free(data);
return NULL;
}
func->read_block(handle, desc->data, desc->length);
}
return data;
}
/* */
void capwap_wtpdescriptor_element_free(void* data) {
struct capwap_wtpdescriptor_element* dataelement = (struct capwap_wtpdescriptor_element*)data;
ASSERT(dataelement != NULL);
ASSERT(dataelement->encryptsubelement != NULL);
ASSERT(dataelement->descsubelement != NULL);
capwap_array_free(dataelement->encryptsubelement);
capwap_array_free(dataelement->descsubelement);
capwap_free(dataelement);
}
struct capwap_message_elements_ops capwap_element_wtpdescriptor_ops = {
.create_message_element = capwap_wtpdescriptor_element_create,
.parsing_message_element = capwap_wtpdescriptor_element_parsing,
.free_parsed_message_element = capwap_wtpdescriptor_element_free
};

27
src/common/capwap_element_wtpdescriptor.h
View File

@ -4,15 +4,15 @@
#define CAPWAP_ELEMENT_WTPDESCRIPTOR 39
struct capwap_wtpdescriptor_element {
unsigned char maxradios;
unsigned char radiosinuse;
uint8_t maxradios;
uint8_t radiosinuse;
struct capwap_array* encryptsubelement;
struct capwap_array* descsubelement;
};
struct capwap_wtpdescriptor_encrypt_subelement {
unsigned char wbid;
unsigned short capabilities;
uint8_t wbid;
uint16_t capabilities;
};
#define CAPWAP_WTPDESC_SUBELEMENT_HARDWAREVERSION 0
@ -22,21 +22,12 @@ struct capwap_wtpdescriptor_encrypt_subelement {
#define CAPWAP_WTPDESC_SUBELEMENT_MAXDATA 1024
struct capwap_wtpdescriptor_desc_subelement {
unsigned long vendor;
unsigned short type;
unsigned short length;
char data[CAPWAP_WTPDESC_SUBELEMENT_MAXDATA];
uint32_t vendor;
uint16_t type;
uint16_t length;
uint8_t data[CAPWAP_WTPDESC_SUBELEMENT_MAXDATA];
};
struct capwap_message_element* capwap_wtpdescriptor_element_create(void* data, unsigned long datalength);
int capwap_wtpdescriptor_element_validate(struct capwap_message_element* element);
void* capwap_wtpdescriptor_element_parsing(struct capwap_message_element* element);
void capwap_wtpdescriptor_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_wtpdescriptor_ops;
/* Helper */
#define CAPWAP_CREATE_WTPDESCRIPTOR_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_WTPDESCRIPTOR); \
f->create(x, sizeof(struct capwap_wtpdescriptor_element)); \
})
#endif /* __CAPWAP_ELEMENT_WTPDESCRIPTOR_HEADER__ */

62
src/common/capwap_element_wtpfallback.c
View File

@ -10,51 +10,30 @@
+-+-+-+-+-+-+-+-+
Type: 40 for WTP Fallback
Length: 1
********************************************************************/
struct capwap_wtpfallback_raw_element {
char mode;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_wtpfallback_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
static void capwap_wtpfallback_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_wtpfallback_element* element = (struct capwap_wtpfallback_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_wtpfallback_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_wtpfallback_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_wtpfallback_raw_element));
element->type = htons(CAPWAP_ELEMENT_WTPFALLBACK);
element->length = htons(sizeof(struct capwap_wtpfallback_raw_element));
((struct capwap_wtpfallback_raw_element*)element->data)->mode = ((struct capwap_wtpfallback_element*)data)->mode;
return element;
/* */
func->write_u8(handle, element->mode);
}
/* */
int capwap_wtpfallback_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_wtpfallback_element_parsing(struct capwap_message_element* element) {
static void* capwap_wtpfallback_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_wtpfallback_element* data;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_WTPFALLBACK);
if (ntohs(element->length) != sizeof(struct capwap_wtpfallback_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 1) {
capwap_logging_debug("Invalid WTP Fallback element");
return NULL;
}
@ -64,14 +43,23 @@ void* capwap_wtpfallback_element_parsing(struct capwap_message_element* element)
capwap_outofmemory();
}
/* */
data->mode = ((struct capwap_wtpfallback_raw_element*)element->data)->mode;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_wtpfallback_element));
func->read_u8(handle, &data->mode);
return data;
}
/* */
void capwap_wtpfallback_element_free(void* data) {
static void capwap_wtpfallback_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_wtpfallback_ops = {
.create_message_element = capwap_wtpfallback_element_create,
.parsing_message_element = capwap_wtpfallback_element_parsing,
.free_parsed_message_element = capwap_wtpfallback_element_free
};

19
src/common/capwap_element_wtpfallback.h
View File

@ -3,22 +3,13 @@
#define CAPWAP_ELEMENT_WTPFALLBACK 40
struct capwap_wtpfallback_element {
char mode;
};
#define CAPWAP_WTP_FALLBACK_ENABLED 1
#define CAPWAP_WTP_FALLBACK_DISABLED 2
struct capwap_message_element* capwap_wtpfallback_element_create(void* data, unsigned long length);
int capwap_wtpfallback_element_validate(struct capwap_message_element* element);
void* capwap_wtpfallback_element_parsing(struct capwap_message_element* element);
void capwap_wtpfallback_element_free(void* data);
struct capwap_wtpfallback_element {
uint8_t mode;
};
extern struct capwap_message_elements_ops capwap_element_wtpfallback_ops;
/* Helper */
#define CAPWAP_CREATE_WTPFALLBACK_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_WTPFALLBACK); \
f->create(x, sizeof(struct capwap_ecnsupport_element)); \
})
#endif /* __CAPWAP_ELEMENT_WTPFALLBACK_HEADER__ */

66
src/common/capwap_element_wtpframetunnelmode.c
View File

@ -10,72 +10,56 @@
+-+-+-+-+-+-+-+-+
Type: 41 for WTP Frame Tunnel Mode
Length: 1
********************************************************************/
struct capwap_wtpframetunnelmode_raw_element {
unsigned char mode;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_wtpframetunnelmode_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_wtpframetunnelmode_raw_element* dataraw;
struct capwap_wtpframetunnelmode_element* dataelement = (struct capwap_wtpframetunnelmode_element*)data;
static void capwap_wtpframetunnelmode_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_wtpframetunnelmode_element* element = (struct capwap_wtpframetunnelmode_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_wtpframetunnelmode_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_wtpframetunnelmode_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_wtpframetunnelmode_raw_element));
element->type = htons(CAPWAP_ELEMENT_WTPFRAMETUNNELMODE);
element->length = htons(sizeof(struct capwap_wtpframetunnelmode_raw_element));
dataraw = (struct capwap_wtpframetunnelmode_raw_element*)element->data;
dataraw->mode = dataelement->mode & CAPWAP_WTP_FRAME_TUNNEL_MODE_MASK;
return element;
/* */
func->write_u8(handle, element->mode & CAPWAP_WTP_FRAME_TUNNEL_MODE_MASK);
}
/* */
int capwap_wtpframetunnelmode_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_wtpframetunnelmode_element_parsing(struct capwap_message_element* element) {
static void* capwap_wtpframetunnelmode_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_wtpframetunnelmode_element* data;
struct capwap_wtpframetunnelmode_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_WTPFRAMETUNNELMODE);
if (ntohs(element->length) != 1) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 1) {
capwap_logging_debug("Invalid WTP Frame Tunnel Mode element");
return NULL;
}
/* */
dataraw = (struct capwap_wtpframetunnelmode_raw_element*)element->data;
data = (struct capwap_wtpframetunnelmode_element*)capwap_alloc(sizeof(struct capwap_wtpframetunnelmode_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->mode = dataraw->mode & CAPWAP_WTP_FRAME_TUNNEL_MODE_MASK;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_wtpframetunnelmode_element));
func->read_u8(handle, &data->mode);
return data;
}
/* */
void capwap_wtpframetunnelmode_element_free(void* data) {
static void capwap_wtpframetunnelmode_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_wtpframetunnelmode_ops = {
.create_message_element = capwap_wtpframetunnelmode_element_create,
.parsing_message_element = capwap_wtpframetunnelmode_element_parsing,
.free_parsed_message_element = capwap_wtpframetunnelmode_element_free
};

17
src/common/capwap_element_wtpframetunnelmode.h
View File

@ -3,24 +3,15 @@
#define CAPWAP_ELEMENT_WTPFRAMETUNNELMODE 41
struct capwap_wtpframetunnelmode_element {
unsigned char mode;
};
#define CAPWAP_WTP_FRAME_TUNNEL_MODE_MASK 0x0e
#define CAPWAP_WTP_NATIVE_FRAME_TUNNEL 0x08
#define CAPWAP_WTP_8023_FRAME_TUNNEL 0x04
#define CAPWAP_WTP_LOCAL_BRIDGING 0x02
struct capwap_message_element* capwap_wtpframetunnelmode_element_create(void* data, unsigned long datalength);
int capwap_wtpframetunnelmode_element_validate(struct capwap_message_element* element);
void* capwap_wtpframetunnelmode_element_parsing(struct capwap_message_element* element);
void capwap_wtpframetunnelmode_element_free(void* data);
struct capwap_wtpframetunnelmode_element {
uint8_t mode;
};
/* Helper */
#define CAPWAP_CREATE_WTPFRAMETUNNELMODE_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_WTPFRAMETUNNELMODE); \
f->create(x, sizeof(struct capwap_wtpframetunnelmode_element)); \
})
extern struct capwap_message_elements_ops capwap_element_wtpframetunnelmode_ops;
#endif /* __CAPWAP_ELEMENT_WTPFRAMETUNNELMODE_HEADER__ */

62
src/common/capwap_element_wtpmactype.c
View File

@ -10,51 +10,30 @@
+-+-+-+-+-+-+-+-+
Type: 44 for WTP MAC Type
Length: 1
********************************************************************/
struct capwap_wtpmactype_raw_element {
char type;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_wtpmactype_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
static void capwap_wtpmactype_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_wtpmactype_element* element = (struct capwap_wtpmactype_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_wtpmactype_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_wtpmactype_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_wtpmactype_raw_element));
element->type = htons(CAPWAP_ELEMENT_WTPMACTYPE);
element->length = htons(sizeof(struct capwap_wtpmactype_raw_element));
((struct capwap_wtpmactype_raw_element*)element->data)->type = ((struct capwap_wtpmactype_element*)data)->type;
return element;
/* */
func->write_u8(handle, element->type);
}
/* */
int capwap_wtpmactype_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_wtpmactype_element_parsing(struct capwap_message_element* element) {
static void* capwap_wtpmactype_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_wtpmactype_element* data;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_WTPMACTYPE);
if (ntohs(element->length) != sizeof(struct capwap_wtpmactype_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 1) {
capwap_logging_debug("Invalid ECN Support element");
return NULL;
}
@ -64,14 +43,23 @@ void* capwap_wtpmactype_element_parsing(struct capwap_message_element* element)
capwap_outofmemory();
}
/* */
data->type = ((struct capwap_wtpmactype_raw_element*)element->data)->type;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_wtpmactype_element));
func->read_u8(handle, &data->type);
return data;
}
/* */
void capwap_wtpmactype_element_free(void* data) {
static void capwap_wtpmactype_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_wtpmactype_ops = {
.create_message_element = capwap_wtpmactype_element_create,
.parsing_message_element = capwap_wtpmactype_element_parsing,
.free_parsed_message_element = capwap_wtpmactype_element_free
};

19
src/common/capwap_element_wtpmactype.h
View File

@ -3,22 +3,13 @@
#define CAPWAP_ELEMENT_WTPMACTYPE 44
struct capwap_wtpmactype_element {
char type;
};
#define CAPWAP_LOCALMAC 0
#define CAPWAP_SPLITMAC 1
struct capwap_message_element* capwap_wtpmactype_element_create(void* data, unsigned long length);
int capwap_wtpmactype_element_validate(struct capwap_message_element* element);
void* capwap_wtpmactype_element_parsing(struct capwap_message_element* element);
void capwap_wtpmactype_element_free(void* data);
struct capwap_wtpmactype_element {
uint8_t type;
};
extern struct capwap_message_elements_ops capwap_element_wtpmactype_ops;
/* Helper */
#define CAPWAP_CREATE_WTPMACTYPE_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_WTPMACTYPE); \
f->create(x, sizeof(struct capwap_wtpmactype_element)); \
})
#endif /* __CAPWAP_ELEMENT_WTPMACTYPE_HEADER__ */

70
src/common/capwap_element_wtpname.c
View File

@ -10,77 +10,57 @@
+-+-+-+-+-+-+-+-+
Type: 45 for WTP Name
Length: >= 1
********************************************************************/
struct capwap_wtpname_raw_element {
char name[0];
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_wtpname_element_create(void* data, unsigned long datalength) {
unsigned short namelength;
struct capwap_message_element* element;
struct capwap_wtpname_raw_element* dataraw;
struct capwap_wtpname_element* dataelement = (struct capwap_wtpname_element*)data;
static void capwap_wtpname_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_wtpname_element* element = (struct capwap_wtpname_element*)data;
ASSERT(data != NULL);
ASSERT(datalength >= sizeof(struct capwap_wtpname_element));
/* Alloc block of memory */
namelength = strlen(dataelement->name);
element = capwap_alloc(sizeof(struct capwap_message_element) + namelength);
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + namelength);
element->type = htons(CAPWAP_ELEMENT_WTPNAME);
element->length = htons(namelength);
dataraw = (struct capwap_wtpname_raw_element*)element->data;
memcpy(&dataraw->name[0], &dataelement->name[0], namelength);
return element;
func->write_block(handle, element->name, strlen((char*)element->name));
}
/* */
int capwap_wtpname_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_wtpname_element_parsing(struct capwap_message_element* element) {
unsigned short namelength;
static void* capwap_wtpname_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_wtpname_element* data;
struct capwap_wtpname_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_WTPNAME);
namelength = ntohs(element->length);
if (!namelength || (namelength > CAPWAP_WTPNAME_MAXLENGTH)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if ((length < 1) || (length > CAPWAP_WTPNAME_MAXLENGTH)) {
capwap_logging_debug("Invalid WTP Name element");
return NULL;
}
/* */
dataraw = (struct capwap_wtpname_raw_element*)element->data;
data = (struct capwap_wtpname_element*)capwap_alloc(sizeof(struct capwap_wtpname_element));
if (!data) {
capwap_outofmemory();
}
/* */
memcpy(&data->name[0], &dataraw->name[0], namelength);
data->name[namelength] = 0;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_wtpname_element));
func->read_block(handle, data->name, length);
return data;
}
/* */
void capwap_wtpname_element_free(void* data) {
static void capwap_wtpname_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_wtpname_ops = {
.create_message_element = capwap_wtpname_element_create,
.parsing_message_element = capwap_wtpname_element_parsing,
.free_parsed_message_element = capwap_wtpname_element_free
};

14
src/common/capwap_element_wtpname.h
View File

@ -6,19 +6,9 @@
#define CAPWAP_WTPNAME_MAXLENGTH 512
struct capwap_wtpname_element {
char name[CAPWAP_WTPNAME_MAXLENGTH + 1];
uint8_t name[CAPWAP_WTPNAME_MAXLENGTH + 1];
};
struct capwap_message_element* capwap_wtpname_element_create(void* data, unsigned long datalength);
int capwap_wtpname_element_validate(struct capwap_message_element* element);
void* capwap_wtpname_element_parsing(struct capwap_message_element* element);
void capwap_wtpname_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_WTPNAME_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_WTPNAME); \
f->create(x, sizeof(struct capwap_wtpname_element)); \
})
extern struct capwap_message_elements_ops capwap_element_wtpname_ops;
#endif /* __CAPWAP_ELEMENT_WTPNAME_HEADER__ */

100
src/common/capwap_element_wtprebootstat.c
View File

@ -16,94 +16,70 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type: 48 for WTP Reboot Statistics
Length: 15
********************************************************************/
struct capwap_wtprebootstat_raw_element {
unsigned short rebootcount;
unsigned short acinitiatedcount;
unsigned short linkfailurecount;
unsigned short swfailurecount;
unsigned short hwfailurecount;
unsigned short otherfailurecount;
unsigned short unknownfailurecount;
unsigned char lastfailuretype;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_wtprebootstat_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_wtprebootstat_raw_element* dataraw;
struct capwap_wtprebootstat_element* dataelement = (struct capwap_wtprebootstat_element*)data;
static void capwap_wtprebootstat_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_wtprebootstat_element* element = (struct capwap_wtprebootstat_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_wtprebootstat_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_wtprebootstat_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_wtprebootstat_raw_element));
element->type = htons(CAPWAP_ELEMENT_WTPREBOOTSTAT);
element->length = htons(sizeof(struct capwap_wtprebootstat_raw_element));
dataraw = (struct capwap_wtprebootstat_raw_element*)element->data;
dataraw->rebootcount = htons(dataelement->rebootcount);
dataraw->acinitiatedcount = htons(dataelement->acinitiatedcount);
dataraw->linkfailurecount = htons(dataelement->linkfailurecount);
dataraw->swfailurecount = htons(dataelement->swfailurecount);
dataraw->hwfailurecount = htons(dataelement->hwfailurecount);
dataraw->otherfailurecount = htons(dataelement->otherfailurecount);
dataraw->unknownfailurecount = htons(dataelement->unknownfailurecount);
dataraw->lastfailuretype = dataelement->lastfailuretype;
return element;
/* */
func->write_u16(handle, element->rebootcount);
func->write_u16(handle, element->acinitiatedcount);
func->write_u16(handle, element->linkfailurecount);
func->write_u16(handle, element->swfailurecount);
func->write_u16(handle, element->hwfailurecount);
func->write_u16(handle, element->otherfailurecount);
func->write_u16(handle, element->unknownfailurecount);
func->write_u8(handle, element->lastfailuretype);
}
/* */
int capwap_wtprebootstat_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_wtprebootstat_element_parsing(struct capwap_message_element* element) {
static void* capwap_wtprebootstat_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_wtprebootstat_element* data;
struct capwap_wtprebootstat_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_WTPREBOOTSTAT);
if (ntohs(element->length) != sizeof(struct capwap_wtprebootstat_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 15) {
capwap_logging_debug("Invalid WTP Reboot Statistics element");
return NULL;
}
/* */
dataraw = (struct capwap_wtprebootstat_raw_element*)element->data;
data = (struct capwap_wtprebootstat_element*)capwap_alloc(sizeof(struct capwap_wtprebootstat_element));
if (!data) {
capwap_outofmemory();
}
/* */
data->rebootcount = ntohs(dataraw->rebootcount);
data->acinitiatedcount = ntohs(dataraw->acinitiatedcount);
data->linkfailurecount = ntohs(dataraw->linkfailurecount);
data->swfailurecount = ntohs(dataraw->swfailurecount);
data->hwfailurecount = ntohs(dataraw->hwfailurecount);
data->otherfailurecount = ntohs(dataraw->otherfailurecount);
data->unknownfailurecount = ntohs(dataraw->unknownfailurecount);
data->lastfailuretype = dataraw->lastfailuretype;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_wtprebootstat_element));
func->read_u16(handle, &data->rebootcount);
func->read_u16(handle, &data->acinitiatedcount);
func->read_u16(handle, &data->linkfailurecount);
func->read_u16(handle, &data->swfailurecount);
func->read_u16(handle, &data->hwfailurecount);
func->read_u16(handle, &data->otherfailurecount);
func->read_u16(handle, &data->unknownfailurecount);
func->read_u8(handle, &data->lastfailuretype);
return data;
}
/* */
void capwap_wtprebootstat_element_free(void* data) {
static void capwap_wtprebootstat_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_wtprebootstat_ops = {
.create_message_element = capwap_wtprebootstat_element_create,
.parsing_message_element = capwap_wtprebootstat_element_parsing,
.free_parsed_message_element = capwap_wtprebootstat_element_free
};

28
src/common/capwap_element_wtprebootstat.h
View File

@ -15,26 +15,16 @@
#define CAPWAP_LAST_FAILURE_UNKNOWN 255
struct capwap_wtprebootstat_element {
unsigned short rebootcount;
unsigned short acinitiatedcount;
unsigned short linkfailurecount;
unsigned short swfailurecount;
unsigned short hwfailurecount;
unsigned short otherfailurecount;
unsigned short unknownfailurecount;
unsigned char lastfailuretype;
uint16_t rebootcount;
uint16_t acinitiatedcount;
uint16_t linkfailurecount;
uint16_t swfailurecount;
uint16_t hwfailurecount;
uint16_t otherfailurecount;
uint16_t unknownfailurecount;
uint8_t lastfailuretype;
};
struct capwap_message_element* capwap_wtprebootstat_element_create(void* data, unsigned long datalength);
int capwap_wtprebootstat_element_validate(struct capwap_message_element* element);
void* capwap_wtprebootstat_element_parsing(struct capwap_message_element* element);
void capwap_wtprebootstat_element_free(void* data);
/* Helper */
#define CAPWAP_CREATE_WTPREBOOTSTAT_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_WTPREBOOTSTAT); \
f->create(x, sizeof(struct capwap_wtprebootstat_element)); \
})
extern struct capwap_message_elements_ops capwap_element_wtprebootstat_ops;
#endif /* __CAPWAP_ELEMENT_WTPREBOOTSTAT_HEADER__ */

83
src/common/capwap_element_wtpstaticipaddress.c
View File

@ -16,61 +16,33 @@
+-+-+-+-+-+-+-+-+
Type: 49 for WTP Static IP Address Information
Length: 13
********************************************************************/
struct capwap_wtpstaticipaddress_raw_element {
unsigned long address;
unsigned long netmask;
unsigned long gateway;
unsigned char staticip;
} __attribute__((__packed__));
/* */
struct capwap_message_element* capwap_wtpstaticipaddress_element_create(void* data, unsigned long datalength) {
struct capwap_message_element* element;
struct capwap_wtpstaticipaddress_element* dataelement = (struct capwap_wtpstaticipaddress_element*)data;
struct capwap_wtpstaticipaddress_raw_element* dataraw;
static void capwap_wtpstaticipaddress_element_create(void* data, capwap_message_elements_handle handle, struct capwap_write_message_elements_ops* func) {
struct capwap_wtpstaticipaddress_element* element = (struct capwap_wtpstaticipaddress_element*)data;
ASSERT(data != NULL);
ASSERT(datalength == sizeof(struct capwap_wtpstaticipaddress_element));
/* Alloc block of memory */
element = capwap_alloc(sizeof(struct capwap_message_element) + sizeof(struct capwap_wtpstaticipaddress_raw_element));
if (!element) {
capwap_outofmemory();
}
/* Create message element */
memset(element, 0, sizeof(struct capwap_message_element) + sizeof(struct capwap_wtpstaticipaddress_raw_element));
element->type = htons(CAPWAP_ELEMENT_WTPSTATICIPADDRESS);
element->length = htons(sizeof(struct capwap_wtpstaticipaddress_raw_element));
dataraw = (struct capwap_wtpstaticipaddress_raw_element*)element->data;
dataraw->address = dataelement->address.s_addr;
dataraw->netmask = dataelement->netmask.s_addr;
dataraw->gateway = dataelement->gateway.s_addr;
dataraw->staticip = dataelement->staticip;
return element;
/* */
func->write_block(handle, (uint8_t*)&element->address, sizeof(struct in_addr));
func->write_block(handle, (uint8_t*)&element->netmask, sizeof(struct in_addr));
func->write_block(handle, (uint8_t*)&element->gateway, sizeof(struct in_addr));
func->write_u8(handle, element->staticip);
}
/* */
int capwap_wtpstaticipaddress_element_validate(struct capwap_message_element* element) {
/* TODO */
return 1;
}
/* */
void* capwap_wtpstaticipaddress_element_parsing(struct capwap_message_element* element) {
static void* capwap_wtpstaticipaddress_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_wtpstaticipaddress_element* data;
struct capwap_wtpstaticipaddress_raw_element* dataraw;
ASSERT(element);
ASSERT(ntohs(element->type) == CAPWAP_ELEMENT_WTPSTATICIPADDRESS);
if (ntohs(element->length) != sizeof(struct capwap_wtpstaticipaddress_raw_element)) {
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 13) {
capwap_logging_debug("Invalid WTP Static IP Address Information element");
return NULL;
}
@ -80,19 +52,26 @@ void* capwap_wtpstaticipaddress_element_parsing(struct capwap_message_element* e
capwap_outofmemory();
}
/* */
dataraw = (struct capwap_wtpstaticipaddress_raw_element*)element->data;
data->address.s_addr = dataraw->address;
data->netmask.s_addr = dataraw->netmask;
data->gateway.s_addr = dataraw->gateway;
data->staticip = dataraw->staticip;
/* Retrieve data */
memset(data, 0, sizeof(struct capwap_wtpstaticipaddress_element));
func->read_block(handle, (uint8_t*)&data->address, sizeof(struct in_addr));
func->read_block(handle, (uint8_t*)&data->netmask, sizeof(struct in_addr));
func->read_block(handle, (uint8_t*)&data->gateway, sizeof(struct in_addr));
func->read_u8(handle, &data->staticip);
return data;
}
/* */
void capwap_wtpstaticipaddress_element_free(void* data) {
static void capwap_wtpstaticipaddress_element_free(void* data) {
ASSERT(data != NULL);
capwap_free(data);
}
/* */
struct capwap_message_elements_ops capwap_element_wtpstaticipaddress_ops = {
.create_message_element = capwap_wtpstaticipaddress_element_create,
.parsing_message_element = capwap_wtpstaticipaddress_element_parsing,
.free_parsed_message_element = capwap_wtpstaticipaddress_element_free
};

13
src/common/capwap_element_wtpstaticipaddress.h
View File

@ -7,18 +7,9 @@ struct capwap_wtpstaticipaddress_element {
struct in_addr address;
struct in_addr netmask;
struct in_addr gateway;
unsigned char staticip;
uint8_t staticip;
};
struct capwap_message_element* capwap_wtpstaticipaddress_element_create(void* data, unsigned long length);
int capwap_wtpstaticipaddress_element_validate(struct capwap_message_element* element);
void* capwap_wtpstaticipaddress_element_parsing(struct capwap_message_element* element);
void capwap_wtpstaticipaddress_element_free(void* data);
extern struct capwap_message_elements_ops capwap_element_wtpstaticipaddress_ops;
/* Helper */
#define CAPWAP_CREATE_WTPSTATICIPADDRESS_ELEMENT(x) ({ \
struct capwap_message_elements_func* f = capwap_get_message_element(CAPWAP_ELEMENT_WTPSTATICIPADDRESS); \
f->create(x, sizeof(struct capwap_wtpstaticipaddress_element)); \
})
#endif /* __CAPWAP_ELEMENT_WTPSTATICIPADDRESS_HEADER__ */

53
src/common/capwap_network.c
View File

@ -1,6 +1,8 @@
#include "capwap.h"
#include "capwap_list.h"
#include "capwap_array.h"
#include "capwap_network.h"
#include "capwap_protocol.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
@ -628,7 +630,7 @@ int capwap_sendto(int sock, void* buffer, int size, struct sockaddr_storage* sen
cmsg->cmsg_len = CMSG_LEN(sizeof(struct in_pktinfo));
pkt = (struct in_pktinfo*)CMSG_DATA(cmsg);
memset(pkt, 0, sizeof(struct in_pktinfo));
memset(pkt, 0, sizeof(struct in_pktinfo));
memcpy(&pkt->ipi_spec_dst, &addr->sin_addr, sizeof(struct in_addr));
#elif defined IP_RECVDSTADDR
struct in_addr* in;
@ -646,7 +648,7 @@ int capwap_sendto(int sock, void* buffer, int size, struct sockaddr_storage* sen
#else
#error "No method of getting the destination ip address supported"
#endif
} else if (sendfromaddr->ss_family == AF_INET6) {
} else if (sendfromaddr->ss_family == AF_INET6) {
struct in6_pktinfo* pkt;
struct sockaddr_in6* addr = (struct sockaddr_in6*)sendfromaddr;
@ -661,16 +663,41 @@ int capwap_sendto(int sock, void* buffer, int size, struct sockaddr_storage* sen
pkt = (struct in6_pktinfo*)CMSG_DATA(cmsg);
memset(pkt, 0, sizeof(struct in6_pktinfo));
memcpy(&pkt->ipi6_addr, &addr->sin6_addr, sizeof(struct in6_addr));
}
}
do {
result = sendmsg(sock, &msgh, 0);
result = sendmsg(sock, &msgh, 0);
} while ((result < 0) && ((errno == EAGAIN) || (errno == EINTR)));
}
return ((result > 0) ? size : 0);
}
/* */
int capwap_sendto_fragmentpacket(int sock, struct capwap_list* fragmentlist, struct sockaddr_storage* sendfromaddr, struct sockaddr_storage* sendtoaddr) {
struct capwap_list_item* item;
ASSERT(sock >= 0);
ASSERT(fragmentlist != NULL);
ASSERT(sendtoaddr != NULL);
item = fragmentlist->first;
while (item) {
struct capwap_fragment_packet_item* fragmentpacket = (struct capwap_fragment_packet_item*)item->item;
ASSERT(fragmentpacket != NULL);
ASSERT(fragmentpacket->offset > 0);
if (!capwap_sendto(sock, fragmentpacket->buffer, fragmentpacket->offset, sendfromaddr, sendtoaddr)) {
return 0;
}
/* */
item = item->next;
}
return 1;
}
/* */
int capwap_ipv4_mapped_ipv6(struct sockaddr_storage* source, struct sockaddr_storage* dest) {
ASSERT(source != NULL);
@ -1194,19 +1221,19 @@ void capwap_interface_list(struct capwap_network* net, struct capwap_list* list)
/* */
for (ifcurrentpos = ifaddrlist; ifcurrentpos != NULL; ifcurrentpos = ifcurrentpos->ifa_next) {
struct capwap_list_item* item;
struct sockaddr_storage* addr;
/* No loopback interface */
if ((ifcurrentpos->ifa_flags & IFF_LOOPBACK) != 0) {
continue;
}
struct capwap_list_item* item;
struct sockaddr_storage* addr;
/* No loopback interface */
if ((ifcurrentpos->ifa_flags & IFF_LOOPBACK) != 0) {
continue;
}
/* Only IPv4 and IPv6 */
if ((ifcurrentpos->ifa_addr == NULL) || ((ifcurrentpos->ifa_addr->sa_family != AF_INET) && (ifcurrentpos->ifa_addr->sa_family != AF_INET6))) {
continue;
}
/* Filter family */
if ((net->sock_family != AF_UNSPEC) && (net->sock_family != ifcurrentpos->ifa_addr->sa_family)) {
continue;

8
src/common/capwap_network.h
View File

@ -60,6 +60,13 @@ struct capwap_socket {
int isctrlsocket;
};
/* Network connection info */
struct capwap_connection {
struct capwap_socket socket;
struct sockaddr_storage localaddr;
struct sockaddr_storage remoteaddr;
};
void capwap_network_init(struct capwap_network* net);
int capwap_network_set_pollfd(struct capwap_network* net, struct pollfd* fds, int fdscount);
void capwap_interface_list(struct capwap_network* net, struct capwap_list* list);
@ -77,6 +84,7 @@ void capwap_close_sockets(struct capwap_network* net);
int capwap_compare_ip(struct sockaddr_storage* addr1, struct sockaddr_storage* addr2);
int capwap_sendto(int sock, void* buffer, int size, struct sockaddr_storage* sendfromaddr, struct sockaddr_storage* sendtoaddr);
int capwap_sendto_fragmentpacket(int sock, struct capwap_list* fragmentlist, struct sockaddr_storage* sendfromaddr, struct sockaddr_storage* sendtoaddr);
int capwap_recvfrom(struct pollfd* fds, int fdscount, void* buffer, int* size, struct sockaddr_storage* recvfromaddr, struct sockaddr_storage* recvtoaddr, struct timeout_control* timeout);
int capwap_ipv4_mapped_ipv6(struct sockaddr_storage* source, struct sockaddr_storage* dest);

2083
src/common/capwap_protocol.c
View File

File diff suppressed because it is too large Load Diff

332
src/common/capwap_protocol.h
View File

@ -1,174 +1,17 @@
#ifndef __CAPWAP_PROTOCOL_HEADER__
#define __CAPWAP_PROTOCOL_HEADER__
#include "capwap_rfc.h"
#include "capwap_element.h"
#include "capwap_network.h"
#include "capwap_dtls.h"
#define CAPWAP_PROTOCOL_VERSION 0
#define CAPWAP_RADIOID_NONE 0
#define CAPWAP_MTU_DEFAULT 1400
#define CAPWAP_DONT_FRAGMENT 0
#define CAPWAP_WIRELESS_BINDING_NONE 0
#define CAPWAP_WIRELESS_BINDING_IEEE80211 1
#define CAPWAP_WIRELESS_BINDING_EPCGLOBAL 3
/* Capwap preamble */
#define CAPWAP_PREAMBLE_HEADER 0
#define CAPWAP_PREAMBLE_DTLS_HEADER 1
struct capwap_preamble {
#ifdef CAPWAP_BIG_ENDIAN
unsigned char version : 4;
unsigned char type : 4;
#else
unsigned char type : 4;
unsigned char version : 4;
#endif
} __attribute__((__packed__));
/* Capwap DTLS header */
struct capwap_dtls_header {
struct capwap_preamble preamble;
unsigned char reserved1;
unsigned char reserved2;
unsigned char reserved3;
} __attribute__((__packed__));
/* Capwap header: 8 (header) + 12 (radio mac) + 256 (wireless info) */
#define CAPWAP_HEADER_MAX_SIZE 276
struct capwap_header {
struct capwap_preamble preamble;
#ifdef CAPWAP_BIG_ENDIAN
unsigned short hlen : 5;
unsigned short rid : 5;
unsigned short wbid : 5;
unsigned short flag_t : 1;
unsigned char flag_f : 1;
unsigned char flag_l : 1;
unsigned char flag_w : 1;
unsigned char flag_m : 1;
unsigned char flag_k : 1;
unsigned char flag_res : 3;
#else
unsigned short _rid_hi : 3;
unsigned short hlen : 5;
unsigned short flag_t : 1;
unsigned short wbid : 5;
unsigned short _rid_lo : 2;
unsigned char flag_res : 3;
unsigned char flag_k : 1;
unsigned char flag_m : 1;
unsigned char flag_w : 1;
unsigned char flag_l : 1;
unsigned char flag_f : 1;
#endif
unsigned short frag_id;
unsigned short frag_off; /* Only first 13 bit */
} __attribute__((__packed__));
#define FRAGMENT_OFFSET_MASK 0xfff8
/* Mac Address */
struct capwap_mac_address {
unsigned char length;
char address[0];
} __attribute__((__packed__));
/* Wireless Information */
struct capwap_wireless_information {
unsigned char length;
char data[0];
} __attribute__((__packed__));
/* Control Message Type */
#define CAPWAP_FIRST_MESSAGE_TYPE 1
#define CAPWAP_DISCOVERY_REQUEST 1
#define CAPWAP_DISCOVERY_RESPONSE 2
#define CAPWAP_JOIN_REQUEST 3
#define CAPWAP_JOIN_RESPONSE 4
#define CAPWAP_CONFIGURATION_STATUS_REQUEST 5
#define CAPWAP_CONFIGURATION_STATUS_RESPONSE 6
#define CAPWAP_CONFIGURATION_UPDATE_REQUEST 7
#define CAPWAP_CONFIGURATION_UPDATE_RESPONSE 8
#define CAPWAP_WTP_EVENT_REQUEST 9
#define CAPWAP_WTP_EVENT_RESPONSE 10
#define CAPWAP_CHANGE_STATE_EVENT_REQUEST 11
#define CAPWAP_CHANGE_STATE_EVENT_RESPONSE 12
#define CAPWAP_ECHO_REQUEST 13
#define CAPWAP_ECHO_RESPONSE 14
#define CAPWAP_IMAGE_DATA_REQUEST 15
#define CAPWAP_IMAGE_DATA_RESPONSE 16
#define CAPWAP_RESET_REQUEST 17
#define CAPWAP_RESET_RESPONSE 18
#define CAPWAP_PRIMARY_DISCOVERY_REQUEST 19
#define CAPWAP_PRIMARY_DISCOVERY_RESPONSE 20
#define CAPWAP_DATA_TRANSFER_REQUEST 21
#define CAPWAP_DATA_TRANSFER_RESPONSE 22
#define CAPWAP_CLEAR_CONFIGURATION_REQUEST 23
#define CAPWAP_CLEAR_CONFIGURATION_RESPONSE 24
#define CAPWAP_STATION_CONFIGURATION_REQUEST 25
#define CAPWAP_STATION_CONFIGURATION_RESPONSE 26
#define CAPWAP_LAST_MESSAGE_TYPE 26
/* Control Message */
struct capwap_control_message {
unsigned long type;
unsigned char seq;
unsigned short length;
unsigned char flags;
char elements[0];
} __attribute__((__packed__));
/* Data Message */
struct capwap_data_message {
unsigned short length;
char elements[0];
} __attribute__((__packed__));
/* Capwap dtls header helper */
#define GET_DTLS_BODY(x) (void*)(((char*)(x)) + sizeof(struct capwap_dtls_header))
/* Capwap header helper */
#define GET_VERSION_HEADER(x) ((x)->preamble.version)
#define SET_VERSION_HEADER(x, y) ((x)->preamble.version = (unsigned char)(y))
#define GET_TYPE_HEADER(x) ((x)->preamble.type)
#define SET_TYPE_HEADER(x, y) ((x)->preamble.type = (unsigned char)(y))
#define GET_HLEN_HEADER(x) ((x)->hlen)
#define SET_HLEN_HEADER(x, y) ((x)->hlen = (unsigned short)(y))
#ifdef CAPWAP_BIG_ENDIAN
#define GET_RID_HEADER(x) ((x)->rid)
#define SET_RID_HEADER(x, y) ((x)->rid = (unsigned short)(y))
#else
#define GET_RID_HEADER(x) ((unsigned short)((x)->_rid_hi << 2 | (x)->_rid_lo))
#define SET_RID_HEADER(x, y) ({ (x)->_rid_hi = (unsigned short)((y) >> 2); (x)->_rid_lo = (unsigned short)((y) & 0x0003); })
#endif
#define GET_WBID_HEADER(x) ((x)->wbid)
#define SET_WBID_HEADER(x, y) ((x)->wbid = (unsigned short)(y))
#define IS_FLAG_T_HEADER(x) ((x)->flag_t)
#define SET_FLAG_T_HEADER(x, y) ((x)->flag_t = ((y) ? 1 : 0))
#define IS_FLAG_F_HEADER(x) ((x)->flag_f)
#define SET_FLAG_F_HEADER(x, y) ((x)->flag_f = ((y) ? 1 : 0))
#define IS_FLAG_L_HEADER(x) ((x)->flag_l)
#define SET_FLAG_L_HEADER(x, y) ((x)->flag_l = ((y) ? 1 : 0))
#define IS_FLAG_W_HEADER(x) ((x)->flag_w)
#define SET_FLAG_W_HEADER(x, y) ((x)->flag_w = ((y) ? 1 : 0))
#define IS_FLAG_M_HEADER(x) ((x)->flag_m)
#define SET_FLAG_M_HEADER(x, y) ((x)->flag_m = ((y) ? 1 : 0))
#define IS_FLAG_K_HEADER(x) ((x)->flag_k)
#define SET_FLAG_K_HEADER(x, y) ((x)->flag_k = ((y) ? 1 : 0))
#define GET_FRAGMENT_ID_HEADER(x) (ntohs((x)->frag_id))
#define SET_FRAGMENT_ID_HEADER(x, y) ((x)->frag_id = htons((unsigned short)(y)))
#define GET_FRAGMENT_OFFSET_HEADER(x) (ntohs((x)->frag_off) & FRAGMENT_OFFSET_MASK)
#define SET_FRAGMENT_OFFSET_HEADER(x, y) ((x)->frag_off &= ~FRAGMENT_OFFSET_MASK, (x)->frag_off |= htons((unsigned short)(y) & FRAGMENT_OFFSET_MASK))
#define GET_RADIO_MAC_ADDRESS_STRUCT(x) ((struct capwap_mac_address*)(((char*)(x)) + sizeof(struct capwap_header)))
#define GET_WIRELESS_INFORMATION_STRUCT(x) ((struct capwap_wireless_information*)(((char*)(x)) + sizeof(struct capwap_header) + (IS_FLAG_M_HEADER(x) ? (((GET_RADIO_MAC_ADDRESS_STRUCT(x)->length + sizeof(struct capwap_mac_address)) + 3) / 4) * 4 : 0)))
#define GET_PAYLOAD_HEADER(x) ((void*)(((char*)(x)) + GET_HLEN_HEADER(x) * 4))
#define IS_SEQUENCE_SMALLER(s1, s2) (((((s1) < (s2)) && (((s2) - (s1)) < 128)) || (((s1) > (s2)) && (((s1) - (s2)) > 128))) ? 1 : 0)
/*********************************************************************************************************************/
/* Sanity check packet */
#define CAPWAP_WRONG_PACKET -1
#define CAPWAP_NONE_PACKET 0
@ -176,81 +19,110 @@ struct capwap_data_message {
#define CAPWAP_DTLS_PACKET 2
int capwap_sanity_check(int isctrlsocket, int state, void* buffer, int buffersize, int dtlsctrlenable, int dtlsdataenable);
/* Fragment packet */
struct capwap_fragment_packet {
void* buffer;
int size;
/* Fragment management */
struct capwap_fragment_packet_item {
unsigned short size;
unsigned short offset;
char buffer[0];
};
/* Fragment control list */
struct capwap_fragment_sender {
struct sockaddr_storage sendaddr;
unsigned short fragment_id;
int islastrecv;
/* Packet */
/* Capwap header function */
struct capwap_header_data {
char headerbuffer[CAPWAP_HEADER_MAX_SIZE];
};
void capwap_header_init(struct capwap_header_data* data, unsigned short radioid, unsigned short binding);
void capwap_header_set_radio_macaddress(struct capwap_header_data* data, int radiotype, char* macaddress);
void capwap_header_set_wireless_information(struct capwap_header_data* data, void* buffer, unsigned char length);
void capwap_header_set_keepalive_flag(struct capwap_header_data* data, int enable);
/* Management tx capwap packet */
struct write_block_from_pos {
struct capwap_list_item* item;
unsigned short pos;
};
struct capwap_packet_txmng {
unsigned short mtu;
struct capwap_list* fragmentlist;
/* Capwap header */
struct capwap_header* header;
struct capwap_list* packetlist;
};
typedef struct capwap_list capwap_fragment_list;
/* Packet */
struct capwap_packet {
unsigned short packetsize;
struct capwap_header* header;
void* payload;
struct sockaddr_storage localaddr;
struct sockaddr_storage remoteaddr;
struct capwap_socket socket;
};
#define CAPWAP_WRONG_FRAGMENT -1
#define CAPWAP_REQUEST_MORE_FRAGMENT 0
#define CAPWAP_RECEIVE_COMPLETE_PACKET 1
int capwap_defragment_packets(struct sockaddr_storage* sendaddr, void* buffer, int buffersize, capwap_fragment_list* defraglist, struct capwap_packet* packet);
capwap_fragment_list* capwap_defragment_init_list(void);
void capwap_defragment_flush_list(capwap_fragment_list* defraglist);
void capwap_defragment_free_list(capwap_fragment_list* defraglist);
int capwap_defragment_remove_sender(capwap_fragment_list* defraglist, struct sockaddr_storage* sendaddr);
struct capwap_fragment_sender* capwap_defragment_find_sender(capwap_fragment_list* defraglist, struct sockaddr_storage* sendaddr);
void capwap_free_packet(struct capwap_packet* packet);
/* Build tx packet */
struct capwap_build_packet {
/* Capwap message */
int isctrlpacket;
union {
struct capwap_header header;
char headerbuffer[CAPWAP_HEADER_MAX_SIZE];
struct capwap_control_message* ctrlmsg;
struct capwap_data_message* datamsg;
};
/* Control Packet */
int isctrlmsg;
/* Write functions */
struct capwap_write_message_elements_ops write_ops;
unsigned short writerpacketsize;
};
/* */
struct capwap_packet_txmng* capwap_packet_txmng_create_ctrl_message(struct capwap_header_data* data, unsigned long type, unsigned char seq, unsigned short mtu);
struct capwap_packet_txmng* capwap_packet_txmng_create_data_message(struct capwap_header_data* data, unsigned short mtu);
void capwap_packet_txmng_add_message_element(struct capwap_packet_txmng* txmngpacket, unsigned short type, void* data);
void capwap_packet_txmng_get_fragment_packets(struct capwap_packet_txmng* txmngpacket, struct capwap_list* fragmentlist, unsigned short fragmentid);
void capwap_packet_txmng_free(struct capwap_packet_txmng* txmngpacket);
/* Management rx capwap packet */
struct read_block_from_pos {
struct capwap_list_item* item;
unsigned short pos;
};
struct capwap_packet_rxmng {
struct capwap_list* fragmentlist;
unsigned long packetlength;
/* Capwap header */
struct capwap_header* header;
/* Capwap message */
int isctrlpacket;
union {
struct capwap_control_message ctrlmsg;
struct capwap_data_message datamsg;
};
/* Message element */
struct capwap_list* elementslist;
/* Position of message elements or binding data */
struct read_block_from_pos readbodypos;
/* Read functions */
struct capwap_read_message_elements_ops read_ops;
struct read_block_from_pos readpos;
unsigned short readerpacketallowed;
struct capwap_list_item* readerfragmentitem;
unsigned short readerfragmentoffset;
};
#define CAPWAP_RADIOID_NONE 0
#define CAPWAP_WIRELESS_BINDING_NONE 0
#define CAPWAP_WIRELESS_BINDING_IEEE80211 1
#define CAPWAP_WIRELESS_BINDING_EPCGLOBAL 3
/* */
#define CAPWAP_WRONG_FRAGMENT -1
#define CAPWAP_REQUEST_MORE_FRAGMENT 0
#define CAPWAP_RECEIVE_COMPLETE_PACKET 1
struct capwap_build_packet* capwap_tx_packet_create(unsigned short radioid, unsigned short binding);
struct capwap_build_packet* capwap_rx_packet_create(void* buffer, int buffersize, int isctrlpacket);
void capwap_build_packet_free(struct capwap_build_packet* buildpacket);
void capwap_build_packet_set_radio_macaddress(struct capwap_build_packet* buildpacket, int radiotype, char* macaddress);
void capwap_build_packet_set_wireless_information(struct capwap_build_packet* buildpacket, void* buffer, unsigned char length);
void capwap_build_packet_set_control_message_type(struct capwap_build_packet* buildpacket, unsigned long type, unsigned char seq);
void capwap_build_packet_add_message_element(struct capwap_build_packet* buildpacket, struct capwap_message_element* element);
struct capwap_packet_rxmng* capwap_packet_rxmng_create_message(int isctrlpacket);
int capwap_packet_rxmng_add_recv_packet(struct capwap_packet_rxmng* rxmngpacket, void* data, int length);
void capwap_packet_rxmng_free(struct capwap_packet_rxmng* rxmngpacket);
/* */
int capwap_is_request_type(unsigned long type);
/* Check capwap message type */
#define VALID_MESSAGE_TYPE 0
#define INVALID_MESSAGE_TYPE 1
#define INVALID_REQUEST_MESSAGE_TYPE 2
int capwap_check_message_type(struct capwap_packet_rxmng* rxmngpacket);
/* Retransmission function */
void capwap_get_packet_digest(struct capwap_packet_rxmng* rxmngpacket, struct capwap_connection* connection, unsigned char packetdigest[16]);
int capwap_recv_retrasmitted_request(struct capwap_dtls* dtls, struct capwap_packet_rxmng* rxmngpacket, struct capwap_connection* connection, unsigned char packetdigest[16], struct capwap_list* txfragmentpacket);
/* TODO utile ?
#define CAPWAP_VALID_PACKET 0x00000000
#define CAPWAP_MISSING_MANDATORY_MSG_ELEMENT 0x00000001
#define CAPWAP_UNRECOGNIZED_MSG_ELEMENT 0x00000002
@ -259,20 +131,6 @@ struct unrecognized_info {
unsigned short element;
unsigned char reason;
};
typedef struct capwap_array capwap_unrecognized_element_array;
unsigned long capwap_build_packet_validate(struct capwap_build_packet* buildpacket, capwap_unrecognized_element_array* reasonarray);
typedef struct capwap_array capwap_fragment_packet_array;
int capwap_fragment_build_packet(struct capwap_build_packet* buildpacket, capwap_fragment_packet_array* packets, unsigned short mtu, unsigned short fragmentid);
void capwap_fragment_free(capwap_fragment_packet_array* packets);
int capwap_is_request_type(unsigned long type);
void capwap_get_packet_digest(void* buffer, unsigned long length, unsigned char packetdigest[16]);
int capwap_recv_retrasmitted_request(struct capwap_dtls* dtls, struct capwap_packet* packet, unsigned char lastseqnumber, unsigned char packetdigest[16], struct capwap_socket* sock, capwap_fragment_packet_array* txfragmentpacket, struct sockaddr_storage* sendfromaddr, struct sockaddr_storage* sendtoaddr);
int capwap_check_message_type(struct capwap_dtls* dtls, struct capwap_packet* packet, unsigned short mtu);
int capwap_get_sessionid_from_keepalive(struct capwap_build_packet* buildpacket, struct capwap_sessionid_element* session);
*/
#endif /* __CAPWAP_PROTOCOL_HEADER__ */

180
src/common/capwap_rfc.h Normal file
View File

@ -0,0 +1,180 @@
#ifndef __CAPWAP_RFC_HEADER__
#define __CAPWAP_RFC_HEADER__
#include <inttypes.h>
#ifndef STRUCT_PACKED
#define STRUCT_PACKED __attribute__((__packed__))
#endif
#define CAPWAP_PROTOCOL_VERSION 0
#define CAPWAP_MTU_DEFAULT 1400
#define CAPWAP_DONT_FRAGMENT 0
/* Capwap preamble */
#define CAPWAP_PREAMBLE_HEADER 0
#define CAPWAP_PREAMBLE_DTLS_HEADER 1
struct capwap_preamble {
#ifdef CAPWAP_BIG_ENDIAN
uint8_t version : 4;
uint8_t type : 4;
#else
uint8_t type : 4;
uint8_t version : 4;
#endif
} STRUCT_PACKED;
/* Capwap DTLS header */
struct capwap_dtls_header {
struct capwap_preamble preamble;
uint8_t reserved1;
uint8_t reserved2;
uint8_t reserved3;
} STRUCT_PACKED;
/* Capwap header: 8 (header) + 12 (radio mac) + 256 (wireless info) */
#define CAPWAP_HEADER_MAX_SIZE 276
struct capwap_header {
struct capwap_preamble preamble;
#ifdef CAPWAP_BIG_ENDIAN
uint16_t hlen : 5;
uint16_t rid : 5;
uint16_t wbid : 5;
uint16_t flag_t : 1;
uint8_t flag_f : 1;
uint8_t flag_l : 1;
uint8_t flag_w : 1;
uint8_t flag_m : 1;
uint8_t flag_k : 1;
uint8_t flag_res : 3;
#else
uint16_t _rid_hi : 3;
uint16_t hlen : 5;
uint16_t flag_t : 1;
uint16_t wbid : 5;
uint16_t _rid_lo : 2;
uint8_t flag_res : 3;
uint8_t flag_k : 1;
uint8_t flag_m : 1;
uint8_t flag_w : 1;
uint8_t flag_l : 1;
uint8_t flag_f : 1;
#endif
uint16_t frag_id;
uint16_t frag_off; /* Only first 13 bit */
} STRUCT_PACKED;
#define FRAGMENT_OFFSET_MASK 0xfff8
/* Mac Address */
struct capwap_mac_address {
uint8_t length;
int8_t address[0];
} STRUCT_PACKED;
/* Wireless Information */
struct capwap_wireless_information {
uint8_t length;
int8_t data[0];
} STRUCT_PACKED;
/* Message element */
struct capwap_message_element {
uint16_t type;
uint16_t length;
int8_t data[0];
} STRUCT_PACKED;
/* Control Message Type */
#define CAPWAP_FIRST_MESSAGE_TYPE 1
#define CAPWAP_DISCOVERY_REQUEST 1
#define CAPWAP_DISCOVERY_RESPONSE 2
#define CAPWAP_JOIN_REQUEST 3
#define CAPWAP_JOIN_RESPONSE 4
#define CAPWAP_CONFIGURATION_STATUS_REQUEST 5
#define CAPWAP_CONFIGURATION_STATUS_RESPONSE 6
#define CAPWAP_CONFIGURATION_UPDATE_REQUEST 7
#define CAPWAP_CONFIGURATION_UPDATE_RESPONSE 8
#define CAPWAP_WTP_EVENT_REQUEST 9
#define CAPWAP_WTP_EVENT_RESPONSE 10
#define CAPWAP_CHANGE_STATE_EVENT_REQUEST 11
#define CAPWAP_CHANGE_STATE_EVENT_RESPONSE 12
#define CAPWAP_ECHO_REQUEST 13
#define CAPWAP_ECHO_RESPONSE 14
#define CAPWAP_IMAGE_DATA_REQUEST 15
#define CAPWAP_IMAGE_DATA_RESPONSE 16
#define CAPWAP_RESET_REQUEST 17
#define CAPWAP_RESET_RESPONSE 18
#define CAPWAP_PRIMARY_DISCOVERY_REQUEST 19
#define CAPWAP_PRIMARY_DISCOVERY_RESPONSE 20
#define CAPWAP_DATA_TRANSFER_REQUEST 21
#define CAPWAP_DATA_TRANSFER_RESPONSE 22
#define CAPWAP_CLEAR_CONFIGURATION_REQUEST 23
#define CAPWAP_CLEAR_CONFIGURATION_RESPONSE 24
#define CAPWAP_STATION_CONFIGURATION_REQUEST 25
#define CAPWAP_STATION_CONFIGURATION_RESPONSE 26
#define CAPWAP_LAST_MESSAGE_TYPE 26
/* Control Message */
struct capwap_control_message {
uint32_t type;
uint8_t seq;
uint16_t length;
uint8_t flags;
int8_t elements[0];
} STRUCT_PACKED;
/* Data Message */
struct capwap_data_message {
uint16_t length;
int8_t elements[0];
} STRUCT_PACKED;
/* Capwap dtls header helper */
#define GET_DTLS_BODY(x) (void*)(((int8_t*)(x)) + sizeof(struct capwap_dtls_header))
/* Capwap header helper */
#define GET_VERSION_HEADER(x) ((x)->preamble.version)
#define SET_VERSION_HEADER(x, y) ((x)->preamble.version = (uint8_t)(y))
#define GET_TYPE_HEADER(x) ((x)->preamble.type)
#define SET_TYPE_HEADER(x, y) ((x)->preamble.type = (uint8_t)(y))
#define GET_HLEN_HEADER(x) ((x)->hlen)
#define SET_HLEN_HEADER(x, y) ((x)->hlen = (uint16_t)(y))
#ifdef CAPWAP_BIG_ENDIAN
#define GET_RID_HEADER(x) ((x)->rid)
#define SET_RID_HEADER(x, y) ((x)->rid = (uint16_t)(y))
#else
#define GET_RID_HEADER(x) ((uint16_t)((x)->_rid_hi << 2 | (x)->_rid_lo))
#define SET_RID_HEADER(x, y) ({ (x)->_rid_hi = (uint16_t)((y) >> 2); (x)->_rid_lo = (uint16_t)((y) & 0x0003); })
#endif
#define GET_WBID_HEADER(x) ((x)->wbid)
#define SET_WBID_HEADER(x, y) ((x)->wbid = (uint16_t)(y))
#define IS_FLAG_T_HEADER(x) ((x)->flag_t)
#define SET_FLAG_T_HEADER(x, y) ((x)->flag_t = ((y) ? 1 : 0))
#define IS_FLAG_F_HEADER(x) ((x)->flag_f)
#define SET_FLAG_F_HEADER(x, y) ((x)->flag_f = ((y) ? 1 : 0))
#define IS_FLAG_L_HEADER(x) ((x)->flag_l)
#define SET_FLAG_L_HEADER(x, y) ((x)->flag_l = ((y) ? 1 : 0))
#define IS_FLAG_W_HEADER(x) ((x)->flag_w)
#define SET_FLAG_W_HEADER(x, y) ((x)->flag_w = ((y) ? 1 : 0))
#define IS_FLAG_M_HEADER(x) ((x)->flag_m)
#define SET_FLAG_M_HEADER(x, y) ((x)->flag_m = ((y) ? 1 : 0))
#define IS_FLAG_K_HEADER(x) ((x)->flag_k)
#define SET_FLAG_K_HEADER(x, y) ((x)->flag_k = ((y) ? 1 : 0))
#define GET_FRAGMENT_ID_HEADER(x) (ntohs((x)->frag_id))
#define SET_FRAGMENT_ID_HEADER(x, y) ((x)->frag_id = htons((uint16_t)(y)))
#define GET_FRAGMENT_OFFSET_HEADER(x) (ntohs((x)->frag_off) & FRAGMENT_OFFSET_MASK)
#define SET_FRAGMENT_OFFSET_HEADER(x, y) ((x)->frag_off &= ~FRAGMENT_OFFSET_MASK, (x)->frag_off |= htons((uint16_t)(y) & FRAGMENT_OFFSET_MASK))
#define GET_RADIO_MAC_ADDRESS_STRUCT(x) ((struct capwap_mac_address*)(((int8_t*)(x)) + sizeof(struct capwap_header)))
#define GET_WIRELESS_INFORMATION_STRUCT(x) ((struct capwap_wireless_information*)(((int8_t*)(x)) + sizeof(struct capwap_header) + (IS_FLAG_M_HEADER(x) ? (((GET_RADIO_MAC_ADDRESS_STRUCT(x)->length + sizeof(struct capwap_mac_address)) + 3) / 4) * 4 : 0)))
#define GET_PAYLOAD_HEADER(x) ((void*)(((int8_t*)(x)) + GET_HLEN_HEADER(x) * 4))
#define IS_SEQUENCE_SMALLER(s1, s2) (((((s1) < (s2)) && (((s2) - (s1)) < 128)) || (((s1) > (s2)) && (((s1) - (s2)) > 128))) ? 1 : 0)
#endif /* __CAPWAP_RFC_HEADER__ */