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

Improve memory administration for tx/rx packet manager

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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/ac/ac.c
View File

@ -22,11 +22,11 @@ static int ac_init(void) {
g_ac.binding = capwap_array_create(sizeof(unsigned short), 0);
/* Standard name */
strcpy(g_ac.acname.name, AC_STANDARD_NAME);
strcpy((char*)g_ac.acname.name, AC_STANDARD_NAME);
/* Descriptor */
g_ac.descriptor.stationlimit = AC_DEFAULT_MAXSTATION;
g_ac.descriptor.wtplimit = AC_DEFAULT_MAXSESSIONS;
g_ac.descriptor.maxwtp = AC_DEFAULT_MAXSESSIONS;
g_ac.descriptor.security = 0;
g_ac.descriptor.rmacfield = CAPWAP_ACDESC_RMACFIELD_NOTSUPPORTED;
g_ac.descriptor.dtlspolicy = CAPWAP_ACDESC_CLEAR_DATA_CHANNEL_ENABLED;
@ -44,8 +44,8 @@ static int ac_init(void) {
g_ac.dfa.wtpfallback.mode = AC_DEFAULT_WTP_FALLBACK_MODE;
/* */
g_ac.dfa.acipv4list = capwap_array_create(sizeof(struct capwap_acipv4list_element), 0);
g_ac.dfa.acipv6list = capwap_array_create(sizeof(struct capwap_acipv6list_element), 0);
g_ac.dfa.acipv4list.addresses = capwap_array_create(sizeof(struct in_addr), 0);
g_ac.dfa.acipv6list.addresses = capwap_array_create(sizeof(struct in6_addr), 0);
/* */
g_ac.dfa.rfcWaitJoin = AC_DEFAULT_WAITJOIN_INTERVAL;
@ -72,8 +72,8 @@ static void ac_destroy(void) {
capwap_array_free(g_ac.binding);
/* */
capwap_array_free(g_ac.dfa.acipv4list);
capwap_array_free(g_ac.dfa.acipv6list);
capwap_array_free(g_ac.dfa.acipv4list.addresses);
capwap_array_free(g_ac.dfa.acipv6list.addresses);
/* Sessions */
capwap_list_free(g_ac.sessions);
@ -152,7 +152,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
return 0;
}
strcpy(g_ac.acname.name, configString);
strcpy((char*)g_ac.acname.name, configString);
}
/* Set binding of AC */
@ -190,7 +190,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
/* Set max wtp of AC */
if (config_lookup_int(config, "application.descriptor.maxwtp", &configLongInt) == CONFIG_TRUE) {
if ((configLongInt > 0) && (configLongInt < 65536)) {
g_ac.descriptor.wtplimit = (unsigned short)configLongInt;
g_ac.descriptor.maxwtp = (unsigned short)configLongInt;
} else {
capwap_logging_error("Invalid configuration file, unknown application.descriptor.maxwtp value");
return 0;
@ -266,7 +266,7 @@ static int ac_parsing_configuration_1_0(config_t* config) {
desc->vendor = (unsigned long)configVendor;
desc->type = type;
desc->length = lengthValue;
strcpy(desc->data, configValue);
strcpy((char*)desc->data, configValue);
} else {
capwap_logging_error("Invalid configuration file, application.descriptor.info.value string length exceeded");
return 0;

4
src/ac/ac.h
View File

@ -55,8 +55,8 @@ struct ac_state {
struct capwap_wtpfallback_element wtpfallback;
/* */
capwap_acipv4list_element_array* acipv4list;
capwap_acipv6list_element_array* acipv6list;
struct capwap_acipv4list_element acipv4list;
struct capwap_acipv6list_element acipv6list;
/* */
int rfcWaitJoin;

156
src/ac/ac_dfa_configure.c
View File

@ -4,115 +4,73 @@
#include "ac_session.h"
/* */
int ac_dfa_state_configure(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_configure(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
unsigned long i;
unsigned short binding;
struct capwap_header_data capwapheader;
struct capwap_packet_txmng* txmngpacket;
int status = AC_DFA_ACCEPT_PACKET;
ASSERT(session != NULL);
if (packet) {
struct capwap_build_packet* buildpacket;
buildpacket = capwap_rx_packet_create((void*)packet->header, packet->packetsize, packet->socket.isctrlsocket);
if (buildpacket) {
if (!capwap_build_packet_validate(buildpacket, NULL)) {
unsigned short binding;
binding = GET_WBID_HEADER(packet->rxmngpacket->header);
/* TODO: gestione richiesta */
/* */
binding = GET_WBID_HEADER(&buildpacket->header);
if (ac_valid_binding(binding) && (ntohl(buildpacket->ctrlmsg.type) == CAPWAP_CONFIGURATION_STATUS_REQUEST) && IS_SEQUENCE_SMALLER(session->remoteseqnumber, buildpacket->ctrlmsg.seq)) {
struct capwap_element_configurationstatus_request configurationstatusrequest;
/* Configuration Status request info*/
capwap_init_element_configurationstatus_request(&configurationstatusrequest, binding);
/* Parsing elements list */
if (capwap_parsing_element_configurationstatus_request(&configurationstatusrequest, buildpacket->elementslist->first)) {
struct capwap_build_packet* responsepacket;
/* Create response */
capwap_header_init(&capwapheader, CAPWAP_RADIOID_NONE, binding);
txmngpacket = capwap_packet_txmng_create_ctrl_message(&capwapheader, CAPWAP_CONFIGURATION_STATUS_RESPONSE, packet->rxmngpacket->ctrlmsg.seq, session->mtu);
/* TODO: gestione richiesta */
/* Add message element */
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_TIMERS, &session->dfa.timers);
/* Create response */
responsepacket = capwap_tx_packet_create(CAPWAP_RADIOID_NONE, binding);
responsepacket->isctrlmsg = 1;
for (i = 0; i < packet->messageelements.radioadmstate->count; i++) {
struct capwap_decrypterrorreportperiod_element report;
struct capwap_radioadmstate_element* radioadm = *(struct capwap_radioadmstate_element**)capwap_array_get_item_pointer(packet->messageelements.radioadmstate, i);
/* Prepare configuration status response */
capwap_build_packet_set_control_message_type(responsepacket, CAPWAP_CONFIGURATION_STATUS_RESPONSE, buildpacket->ctrlmsg.seq);
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_TIMERS_ELEMENT(&session->dfa.timers));
for (i = 0; i < configurationstatusrequest.radioadmstatus->count; i++) {
struct capwap_decrypterrorreportperiod_element report;
struct capwap_radioadmstate_element* radioadm = (struct capwap_radioadmstate_element*)capwap_array_get_item_pointer(configurationstatusrequest.radioadmstatus, i);
report.radioid = radioadm->radioid;
report.interval = session->dfa.decrypterrorreport_interval;
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_DECRYPTERRORREPORTPERIOD_ELEMENT(&report));
}
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_IDLETIMEOUT_ELEMENT(&session->dfa.idletimeout));
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_WTPFALLBACK_ELEMENT(&session->dfa.wtpfallback));
if (session->dfa.acipv4list->count > 0) {
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_ACIPV4LIST_ELEMENT(session->dfa.acipv4list));
}
if (session->dfa.acipv6list->count > 0) {
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_ACIPV6LIST_ELEMENT(session->dfa.acipv6list));
}
/* CAPWAP_CREATE_RADIOOPRSTATE_ELEMENT */ /* TODO */
/* CAPWAP_CREATE_WTPSTATICIPADDRESS_ELEMENT */ /* TODO */
/* CAPWAP_CREATE_VENDORSPECIFICPAYLOAD_ELEMENT */ /* TODO */
if (!capwap_build_packet_validate(responsepacket, NULL)) {
int result;
/* Free old reference for this request */
ac_free_reference_last_response(session);
/* Send configuration status response to WTP */
result = capwap_fragment_build_packet(responsepacket, session->responsefragmentpacket, session->mtu, session->fragmentid);
if (result >= 0) {
if (result == 1) {
session->fragmentid++;
}
/* Save remote sequence number */
session->remoteseqnumber = buildpacket->ctrlmsg.seq;
capwap_get_packet_digest((void*)packet->header, packet->packetsize, session->lastrecvpackethash);
/* Send */
for (i = 0; i < session->responsefragmentpacket->count; i++) {
struct capwap_packet* txpacket = (struct capwap_packet*)capwap_array_get_item_pointer(session->responsefragmentpacket, i);
ASSERT(txpacket != NULL);
if (!capwap_crypt_sendto(&session->ctrldtls, session->ctrlsocket.socket[session->ctrlsocket.type], txpacket->header, txpacket->packetsize, &session->acctrladdress, &session->wtpctrladdress)) {
/* Response is already created and saved. When receive a re-request, DFA autoresponse */
capwap_logging_debug("Warning: error to send configuration status response packet");
break;
}
}
/* Change status */
ac_dfa_change_state(session, CAPWAP_DATA_CHECK_STATE);
capwap_set_timeout(session->dfa.rfcChangeStatePendingTimer, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
}
} else {
capwap_logging_debug("Warning: build invalid configuration status response packet");
}
/* Free memory */
capwap_build_packet_free(responsepacket);
}
/* Free */
capwap_free_element_configurationstatus_request(&configurationstatusrequest, binding);
}
}
/* Free */
capwap_build_packet_free(buildpacket);
report.radioid = radioadm->radioid;
report.interval = session->dfa.decrypterrorreport_interval;
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_DECRYPTERRORREPORTPERIOD, &report);
}
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_IDLETIMEOUT, &session->dfa.idletimeout);
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_WTPFALLBACK, &session->dfa.wtpfallback);
if (session->dfa.acipv4list.addresses->count > 0) {
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_ACIPV4LIST, &session->dfa.acipv4list);
}
if (session->dfa.acipv6list.addresses->count > 0) {
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_ACIPV6LIST, &session->dfa.acipv6list);
}
/* CAPWAP_CREATE_RADIOOPRSTATE_ELEMENT */ /* TODO */
/* CAPWAP_CREATE_WTPSTATICIPADDRESS_ELEMENT */ /* TODO */
/* CAPWAP_CREATE_VENDORSPECIFICPAYLOAD_ELEMENT */ /* TODO */
/* Configure response complete, get fragment packets */
ac_free_reference_last_response(session);
capwap_packet_txmng_get_fragment_packets(txmngpacket, session->responsefragmentpacket, session->fragmentid);
if (session->responsefragmentpacket->count > 1) {
session->fragmentid++;
}
/* Free packets manager */
capwap_packet_txmng_free(txmngpacket);
/* Save remote sequence number */
session->remoteseqnumber = packet->rxmngpacket->ctrlmsg.seq;
capwap_get_packet_digest(packet->rxmngpacket, packet->connection, session->lastrecvpackethash);
/* Send Configure response to WTP */
if (!capwap_crypt_sendto_fragmentpacket(&session->ctrldtls, session->ctrlsocket.socket[session->ctrlsocket.type], session->responsefragmentpacket, &session->acctrladdress, &session->wtpctrladdress)) {
/* Response is already created and saved. When receive a re-request, DFA autoresponse */
capwap_logging_debug("Warning: error to send configuration status response packet");
}
/* Change state */
ac_dfa_change_state(session, CAPWAP_DATA_CHECK_STATE);
capwap_set_timeout(session->dfa.rfcChangeStatePendingTimer, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
} else {
/* Configure timeout */
ac_dfa_change_state(session, CAPWAP_CONFIGURE_TO_DTLS_TEARDOWN_STATE);
@ -123,6 +81,6 @@ int ac_dfa_state_configure(struct ac_session_t* session, struct capwap_packet* p
}
/* */
int ac_dfa_state_configure_to_dtlsteardown(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_configure_to_dtlsteardown(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
return ac_session_teardown_connection(session);
}

196
src/ac/ac_dfa_datacheck.c
View File

@ -4,91 +4,48 @@
#include "ac_session.h"
/* */
int ac_dfa_state_datacheck(struct ac_session_t* session, struct capwap_packet* packet) {
unsigned long i;
int ac_dfa_state_datacheck(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
unsigned short binding;
struct capwap_header_data capwapheader;
struct capwap_packet_txmng* txmngpacket;
int status = AC_DFA_ACCEPT_PACKET;
ASSERT(session != NULL);
if (packet) {
struct capwap_build_packet* buildpacket;
buildpacket = capwap_rx_packet_create((void*)packet->header, packet->packetsize, packet->socket.isctrlsocket);
if (buildpacket) {
if (!capwap_build_packet_validate(buildpacket, NULL)) {
unsigned short binding;
binding = GET_WBID_HEADER(packet->rxmngpacket->header);
/* TODO: gestione richiesta */
/* */
binding = GET_WBID_HEADER(&buildpacket->header);
if (ac_valid_binding(binding) && (ntohl(buildpacket->ctrlmsg.type) == CAPWAP_CHANGE_STATE_EVENT_REQUEST) && IS_SEQUENCE_SMALLER(session->remoteseqnumber, buildpacket->ctrlmsg.seq)) {
struct capwap_element_changestateevent_request changeeventrequest;
/* Change event request info */
capwap_init_element_changestateevent_request(&changeeventrequest, binding);
/* Parsing elements list */
if (capwap_parsing_element_changestateevent_request(&changeeventrequest, buildpacket->elementslist->first)) {
struct capwap_build_packet* responsepacket;
/* Create response */
capwap_header_init(&capwapheader, CAPWAP_RADIOID_NONE, binding);
txmngpacket = capwap_packet_txmng_create_ctrl_message(&capwapheader, CAPWAP_CHANGE_STATE_EVENT_RESPONSE, packet->rxmngpacket->ctrlmsg.seq, session->mtu);
/* TODO: gestione richiesta */
/* Add message element */
/* CAPWAP_CREATE_VENDORSPECIFICPAYLOAD_ELEMENT */ /* TODO */
/* Create response */
responsepacket = capwap_tx_packet_create(CAPWAP_RADIOID_NONE, binding);
responsepacket->isctrlmsg = 1;
/* Prepare change event response */
capwap_build_packet_set_control_message_type(responsepacket, CAPWAP_CHANGE_STATE_EVENT_RESPONSE, buildpacket->ctrlmsg.seq);
/* CAPWAP_CREATE_VENDORSPECIFICPAYLOAD_ELEMENT */ /* TODO */
if (!capwap_build_packet_validate(responsepacket, NULL)) {
int result;
/* Free old reference for this request */
ac_free_reference_last_response(session);
/* Send change event response to WTP */
result = capwap_fragment_build_packet(responsepacket, session->responsefragmentpacket, session->mtu, session->fragmentid);
if (result >= 0) {
if (result == 1) {
session->fragmentid++;
}
/* Save remote sequence number */
session->remoteseqnumber = buildpacket->ctrlmsg.seq;
capwap_get_packet_digest((void*)packet->header, packet->packetsize, session->lastrecvpackethash);
/* Send */
for (i = 0; i < session->responsefragmentpacket->count; i++) {
struct capwap_packet* txpacket = (struct capwap_packet*)capwap_array_get_item_pointer(session->responsefragmentpacket, i);
ASSERT(txpacket != NULL);
if (!capwap_crypt_sendto(&session->ctrldtls, session->ctrlsocket.socket[session->ctrlsocket.type], txpacket->header, txpacket->packetsize, &session->acctrladdress, &session->wtpctrladdress)) {
/* Response is already created and saved. When receive a re-request, DFA autoresponse */
capwap_logging_debug("Warning: error to send change event response packet");
break;
}
}
/* Change status */
ac_dfa_change_state(session, CAPWAP_DATA_CHECK_TO_RUN_STATE);
capwap_set_timeout(session->dfa.rfcDataCheckTimer, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
}
} else {
capwap_logging_debug("Warning: build invalid configuration status response packet");
}
/* Free memory */
capwap_build_packet_free(responsepacket);
}
/* Free */
capwap_free_element_changestateevent_request(&changeeventrequest, binding);
}
}
/* Free */
capwap_build_packet_free(buildpacket);
/* Change event response complete, get fragment packets */
ac_free_reference_last_response(session);
capwap_packet_txmng_get_fragment_packets(txmngpacket, session->responsefragmentpacket, session->fragmentid);
if (session->responsefragmentpacket->count > 1) {
session->fragmentid++;
}
/* Free packets manager */
capwap_packet_txmng_free(txmngpacket);
/* Save remote sequence number */
session->remoteseqnumber = packet->rxmngpacket->ctrlmsg.seq;
capwap_get_packet_digest(packet->rxmngpacket, packet->connection, session->lastrecvpackethash);
/* Send Change event response to WTP */
if (!capwap_crypt_sendto_fragmentpacket(&session->ctrldtls, session->ctrlsocket.socket[session->ctrlsocket.type], session->responsefragmentpacket, &session->acctrladdress, &session->wtpctrladdress)) {
/* Response is already created and saved. When receive a re-request, DFA autoresponse */
capwap_logging_debug("Warning: error to send change event response packet");
}
/* Change state */
ac_dfa_change_state(session, CAPWAP_DATA_CHECK_TO_RUN_STATE);
capwap_set_timeout(session->dfa.rfcDataCheckTimer, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
} else {
/* Configure timeout */
ac_dfa_change_state(session, CAPWAP_DATA_CHECK_TO_DTLS_TEARDOWN_STATE);
@ -99,59 +56,54 @@ int ac_dfa_state_datacheck(struct ac_session_t* session, struct capwap_packet* p
}
/* */
int ac_dfa_state_datacheck_to_run(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_datacheck_to_run(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
struct capwap_list* txfragpacket;
struct capwap_header_data capwapheader;
struct capwap_packet_txmng* txmngpacket;
int status = AC_DFA_ACCEPT_PACKET;
ASSERT(session != NULL);
if (packet) {
/* Wait Data Channel Keep-Alive packet */
if (!packet->socket.isctrlsocket) {
struct capwap_build_packet* buildpacket;
buildpacket = capwap_rx_packet_create((void*)packet->header, packet->packetsize, packet->socket.isctrlsocket);
if (buildpacket) {
struct capwap_sessionid_element sessionid;
if (capwap_get_sessionid_from_keepalive(buildpacket, &sessionid)) {
if (!memcmp(&sessionid, &session->sessionid, sizeof(struct capwap_sessionid_element))) {
int result;
capwap_fragment_packet_array* txfragpacket;
/* Receive data packet keepalive, response with same packet */
txfragpacket = capwap_array_create(sizeof(struct capwap_packet), 0);
result = capwap_fragment_build_packet(buildpacket, txfragpacket, CAPWAP_DONT_FRAGMENT, 0);
if (!result) {
struct capwap_packet* txpacket;
ASSERT(txfragpacket->count == 1);
txpacket = (struct capwap_packet*)capwap_array_get_item_pointer(txfragpacket, 0);
ASSERT(txpacket != NULL);
if (!capwap_crypt_sendto(&session->datadtls, session->datasocket.socket[session->datasocket.type], txpacket->header, txpacket->packetsize, &session->acdataaddress, &session->wtpdataaddress)) {
capwap_logging_debug("Warning: error to send data channel keepalive packet");
result = -1;
}
}
/* */
capwap_fragment_free(txfragpacket);
capwap_array_free(txfragpacket);
if (!result) {
/* Capwap handshake complete */
ac_dfa_change_state(session, CAPWAP_RUN_STATE);
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
} else {
ac_dfa_change_state(session, CAPWAP_DATA_CHECK_TO_DTLS_TEARDOWN_STATE);
status = AC_DFA_NO_PACKET;
}
if (!packet->rxmngpacket->isctrlpacket && IS_FLAG_K_HEADER(packet->rxmngpacket->header)) {
if (!memcmp(packet->messageelements.sessionid, &session->sessionid, sizeof(struct capwap_sessionid_element))) {
int result = 0;
/* Build packet */
capwap_header_init(&capwapheader, CAPWAP_RADIOID_NONE, GET_WBID_HEADER(packet->rxmngpacket->header));
capwap_header_set_keepalive_flag(&capwapheader, 1);
txmngpacket = capwap_packet_txmng_create_data_message(&capwapheader, session->mtu);
/* Add message element */
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_SESSIONID, &session->sessionid);
/* Data keepalive complete, get fragment packets into local list */
txfragpacket = capwap_list_create();
capwap_packet_txmng_get_fragment_packets(txmngpacket, txfragpacket, 0);
if (txfragpacket->count == 1) {
/* Send Data keepalive to WTP */
if (capwap_crypt_sendto_fragmentpacket(&session->datadtls, session->datasocket.socket[session->datasocket.type], txfragpacket, &session->acdataaddress, &session->wtpdataaddress)) {
result = 1;
} else {
capwap_logging_debug("Warning: error to send data channel keepalive packet");
}
} else {
capwap_logging_debug("Warning: error to send data channel keepalive packet, fragment packet");
}
/* Free packets manager */
capwap_list_free(txfragpacket);
capwap_packet_txmng_free(txmngpacket);
if (result) {
/* Capwap handshake complete */
ac_dfa_change_state(session, CAPWAP_RUN_STATE);
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
} else {
ac_dfa_change_state(session, CAPWAP_DATA_CHECK_TO_DTLS_TEARDOWN_STATE);
status = AC_DFA_NO_PACKET;
}
/* Free */
capwap_build_packet_free(buildpacket);
}
}
} else {
@ -164,6 +116,6 @@ int ac_dfa_state_datacheck_to_run(struct ac_session_t* session, struct capwap_pa
}
/* */
int ac_dfa_state_datacheck_to_dtlsteardown(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_datacheck_to_dtlsteardown(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
return ac_session_teardown_connection(session);
}

6
src/ac/ac_dfa_dtls.c
View File

@ -14,7 +14,7 @@ int ac_bio_send(struct capwap_dtls* dtls, char* buffer, int length, void* param)
}
/* */
int ac_dfa_state_dtlssetup(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_dtlssetup(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
int status = AC_DFA_ACCEPT_PACKET;
ASSERT(session != NULL);
@ -37,7 +37,7 @@ int ac_dfa_state_dtlssetup(struct ac_session_t* session, struct capwap_packet* p
}
/* */
int ac_dfa_state_dtlsconnect(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_dtlsconnect(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
ASSERT(session != NULL);
ASSERT(packet == NULL);
@ -46,6 +46,6 @@ int ac_dfa_state_dtlsconnect(struct ac_session_t* session, struct capwap_packet*
}
/* */
int ac_dfa_state_dtlsconnect_to_dtlsteardown(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_dtlsconnect_to_dtlsteardown(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
return ac_session_teardown_connection(session);
}

4
src/ac/ac_dfa_imagedata.c
View File

@ -4,7 +4,7 @@
#include "ac_session.h"
/* */
int ac_dfa_state_imagedata(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_imagedata(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
int status = AC_DFA_ACCEPT_PACKET;
/* TODO */
@ -13,6 +13,6 @@ int ac_dfa_state_imagedata(struct ac_session_t* session, struct capwap_packet* p
}
/* */
int ac_dfa_state_imagedata_to_dtlsteardown(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_imagedata_to_dtlsteardown(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
return ac_session_teardown_connection(session);
}

322
src/ac/ac_dfa_join.c
View File

@ -4,227 +4,130 @@
#include "ac_session.h"
/* */
int ac_dfa_state_join(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_join(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
int i;
struct capwap_header_data capwapheader;
struct capwap_packet_txmng* txmngpacket;
int status = AC_DFA_ACCEPT_PACKET;
struct capwap_resultcode_element resultcode = { CAPWAP_RESULTCODE_FAILURE };
struct capwap_build_packet* responsepacket;
struct capwap_resultcode_element resultcode = { .code = CAPWAP_RESULTCODE_FAILURE };
ASSERT(session != NULL);
if (packet) {
struct capwap_build_packet* buildpacket;
buildpacket = capwap_rx_packet_create((void*)packet->header, packet->packetsize, packet->socket.isctrlsocket);
if (buildpacket) {
int validpacket;
unsigned long checkpacket;
struct capwap_array* returnedmessagearray = NULL;
capwap_unrecognized_element_array* unrecognizedarray;
struct capwap_element_join_request joinrequest;
unsigned short binding = GET_WBID_HEADER(&buildpacket->header);
unsigned short binding;
/* */
unrecognizedarray = capwap_array_create(sizeof(struct unrecognized_info), 0);
/* */
checkpacket = capwap_build_packet_validate(buildpacket, unrecognizedarray);
if (!checkpacket) {
if (ac_valid_binding(binding)) {
if (ntohl(buildpacket->ctrlmsg.type) == CAPWAP_JOIN_REQUEST) {
resultcode.code = CAPWAP_RESULTCODE_SUCCESS;
} else {
resultcode.code = CAPWAP_RESULTCODE_MSG_UNEXPECTED_INVALID_CURRENT_STATE;
}
} else {
resultcode.code = CAPWAP_RESULTCODE_JOIN_FAILURE_BINDING_NOT_SUPPORTED;
}
/* Check binding */
binding = GET_WBID_HEADER(packet->rxmngpacket->header);
if (ac_valid_binding(binding)) {
if (packet->rxmngpacket->ctrlmsg.type == CAPWAP_JOIN_REQUEST) {
resultcode.code = CAPWAP_RESULTCODE_SUCCESS;
/* Get sessionid */
memcpy(&session->sessionid, packet->messageelements.sessionid, sizeof(struct capwap_sessionid_element));
/* Get binding */
session->binding = binding;
} else {
if ((checkpacket & CAPWAP_MISSING_MANDATORY_MSG_ELEMENT) != 0) {
resultcode.code = CAPWAP_RESULTCODE_FAILURE_MISSING_MANDATORY_MSG_ELEMENT;
} else if ((checkpacket & CAPWAP_UNRECOGNIZED_MSG_ELEMENT) != 0) {
struct capwap_list_item* itemelement;
resultcode.code = CAPWAP_RESULTCODE_FAILURE_UNRECOGNIZED_MESSAGE_ELEMENT;
returnedmessagearray = capwap_array_create(sizeof(struct capwap_returnedmessage_element), unrecognizedarray->count);
resultcode.code = CAPWAP_RESULTCODE_MSG_UNEXPECTED_INVALID_CURRENT_STATE;
}
} else {
resultcode.code = CAPWAP_RESULTCODE_JOIN_FAILURE_BINDING_NOT_SUPPORTED;
}
for (i = 0; i < unrecognizedarray->count; i++) {
struct unrecognized_info* reasoninfo = capwap_array_get_item_pointer(unrecognizedarray, i);
/* Search element */
itemelement = buildpacket->elementslist->first;
while (itemelement != NULL) {
struct capwap_message_element* elementitem = (struct capwap_message_element*)itemelement->item;
if (ntohs(elementitem->type) == reasoninfo->element) {
struct capwap_returnedmessage_element* returnedelement = capwap_array_get_item_pointer(returnedmessagearray, i);
unsigned short length = sizeof(struct capwap_message_element) + ntohs(elementitem->length);
/* Create response */
capwap_header_init(&capwapheader, CAPWAP_RADIOID_NONE, binding);
txmngpacket = capwap_packet_txmng_create_ctrl_message(&capwapheader, CAPWAP_JOIN_RESPONSE, packet->rxmngpacket->ctrlmsg.seq, session->mtu);
returnedelement->reason = reasoninfo->reason;
returnedelement->length = min(length, CAPWAP_RETURNED_MESSAGE_MAX_LENGTH);
memcpy(&returnedelement->message[0], elementitem, returnedelement->length);
break;
}
/* Next */
itemelement = itemelement->next;
}
}
/* Add message element */
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_RESULTCODE, &resultcode);
/* Check is valid packet after parsing request */
if ((resultcode.code == CAPWAP_RESULTCODE_SUCCESS) || (resultcode.code == CAPWAP_RESULTCODE_SUCCESS_NAT_DETECTED)) {
struct capwap_list* controllist;
struct capwap_list_item* item;
/* Update statistics */
ac_update_statistics();
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_ACDESCRIPTION, &g_ac.descriptor);
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_ACNAME, &g_ac.acname);
if (binding == CAPWAP_WIRELESS_BINDING_IEEE80211) {
for (i = 0; i < packet->messageelements.ieee80211.wtpradioinformation->count; i++) {
struct capwap_80211_wtpradioinformation_element* radio;
radio = *(struct capwap_80211_wtpradioinformation_element**)capwap_array_get_item_pointer(packet->messageelements.ieee80211.wtpradioinformation, i);
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION, radio);
}
}
/* */
capwap_array_free(unrecognizedarray);
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_ECNSUPPORT, &session->dfa.ecn);
/* */
capwap_init_element_join_request(&joinrequest, binding);
if (resultcode.code == CAPWAP_RESULTCODE_SUCCESS) {
/* Parsing elements list */
if (capwap_parsing_element_join_request(&joinrequest, buildpacket->elementslist->first)) {
/* TODO: gestione richiesta */
/* Get information from any local address */
controllist = capwap_list_create();
ac_get_control_information(controllist);
for (item = controllist->first; item != NULL; item = item->next) {
struct ac_session_control* sessioncontrol = (struct ac_session_control*)item->item;
if (sessioncontrol->localaddress.ss_family == AF_INET) {
struct capwap_controlipv4_element element;
memcpy(&element.address, &((struct sockaddr_in*)&sessioncontrol->localaddress)->sin_addr, sizeof(struct in_addr));
element.wtpcount = sessioncontrol->count;
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_CONTROLIPV4, &element);
} else if (sessioncontrol->localaddress.ss_family == AF_INET6) {
struct capwap_controlipv6_element element;
/* Get sessionid */
memcpy(&session->sessionid, joinrequest.sessionid, sizeof(struct capwap_sessionid_element));
/* Get binding */
session->binding = binding;
resultcode.code = CAPWAP_RESULTCODE_SUCCESS;
memcpy(&element.address, &((struct sockaddr_in6*)&sessioncontrol->localaddress)->sin6_addr, sizeof(struct in6_addr));
element.wtpcount = sessioncontrol->count;
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_CONTROLIPV6, &element);
}
}
/* Create response */
responsepacket = capwap_tx_packet_create(CAPWAP_RADIOID_NONE, binding);
responsepacket->isctrlmsg = 1;
/* Prepare join response */
capwap_build_packet_set_control_message_type(responsepacket, CAPWAP_JOIN_RESPONSE, buildpacket->ctrlmsg.seq);
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_RESULTCODE_ELEMENT(&resultcode));
capwap_list_free(controllist);
/* Check is valid packet after parsing request */
validpacket = (((resultcode.code == CAPWAP_RESULTCODE_SUCCESS) || (resultcode.code == CAPWAP_RESULTCODE_SUCCESS_NAT_DETECTED)) ? 1 : 0);
if (validpacket) {
struct capwap_list* controllist;
struct capwap_list_item* item;
/* Update statistics */
ac_update_statistics();
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_ACDESCRIPTOR_ELEMENT(&g_ac.descriptor));
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_ACNAME_ELEMENT(&g_ac.acname));
if (session->acctrladdress.ss_family == AF_INET) {
struct capwap_localipv4_element addr;
if (binding == CAPWAP_WIRELESS_BINDING_IEEE80211) {
for (i = 0; i < joinrequest.binding.ieee80211.wtpradioinformation->count; i++) {
struct capwap_80211_wtpradioinformation_element* radio;
radio = (struct capwap_80211_wtpradioinformation_element*)capwap_array_get_item_pointer(joinrequest.binding.ieee80211.wtpradioinformation, i);
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_80211_WTPRADIOINFORMATION_ELEMENT(radio));
}
} else {
capwap_logging_debug("Unknown capwap binding");
}
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_ECNSUPPORT_ELEMENT(&session->dfa.ecn));
memcpy(&addr.address, &((struct sockaddr_in*)&session->acctrladdress)->sin_addr, sizeof(struct in_addr));
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_LOCALIPV4, &addr);
} else if (session->acctrladdress.ss_family == AF_INET6) {
struct capwap_localipv6_element addr;
/* Get information from any local address */
controllist = capwap_list_create();
ac_get_control_information(controllist);
for (item = controllist->first; item != NULL; item = item->next) {
struct ac_session_control* sessioncontrol = (struct ac_session_control*)item->item;
if (sessioncontrol->localaddress.ss_family == AF_INET) {
struct capwap_controlipv4_element element;
memcpy(&element.address, &((struct sockaddr_in*)&sessioncontrol->localaddress)->sin_addr, sizeof(struct in_addr));
element.wtpcount = sessioncontrol->count;
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_CONTROLIPV4_ELEMENT(&element));
} else if (sessioncontrol->localaddress.ss_family == AF_INET6) {
struct capwap_controlipv6_element element;
memcpy(&element.address, &((struct sockaddr_in6*)&sessioncontrol->localaddress)->sin6_addr, sizeof(struct in6_addr));
element.wtpcount = sessioncontrol->count;
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_CONTROLIPV6_ELEMENT(&element));
}
}
capwap_list_free(controllist);
if (session->acctrladdress.ss_family == AF_INET) {
struct capwap_localipv4_element addr;
memcpy(&addr.address, &((struct sockaddr_in*)&session->acctrladdress)->sin_addr, sizeof(struct in_addr));
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_LOCALIPV4_ELEMENT(&addr));
} else if (session->acctrladdress.ss_family == AF_INET6) {
struct capwap_localipv6_element addr;
memcpy(&addr.address, &((struct sockaddr_in6*)&session->acctrladdress)->sin6_addr, sizeof(struct in6_addr));
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_LOCALIPV6_ELEMENT(&addr));
}
/* CAPWAP_CREATE_ACIPV4LIST_ELEMENT */ /* TODO */
/* CAPWAP_CREATE_ACIPV6LIST_ELEMENT */ /* TODO */
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_TRANSPORT_ELEMENT(&session->dfa.transport));
/* CAPWAP_CREATE_IMAGEIDENTIFIER_ELEMENT */ /* TODO */
/* CAPWAP_CREATE_MAXIMUMMESSAGELENGTH_ELEMENT */ /* TODO */
/* CAPWAP_CREATE_VENDORSPECIFICPAYLOAD_ELEMENT */ /* TODO */
} else if (resultcode.code == CAPWAP_RESULTCODE_FAILURE_UNRECOGNIZED_MESSAGE_ELEMENT) {
ASSERT(returnedmessagearray != NULL);
for (i = 0; i < returnedmessagearray->count; i++) {
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_RETURNEDMESSAGE_ELEMENT(capwap_array_get_item_pointer(returnedmessagearray, i)));
}
capwap_array_free(returnedmessagearray);
memcpy(&addr.address, &((struct sockaddr_in6*)&session->acctrladdress)->sin6_addr, sizeof(struct in6_addr));
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_LOCALIPV6, &addr);
}
/* Validate packet */
if (!validpacket || !capwap_build_packet_validate(responsepacket, NULL)) {
int result;
/* Free old reference for this request */
ac_free_reference_last_response(session);
/* CAPWAP_CREATE_ACIPV4LIST_ELEMENT */ /* TODO */
/* CAPWAP_CREATE_ACIPV6LIST_ELEMENT */ /* TODO */
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_TRANSPORT, &session->dfa.transport);
/* CAPWAP_CREATE_IMAGEIDENTIFIER_ELEMENT */ /* TODO */
/* CAPWAP_CREATE_MAXIMUMMESSAGELENGTH_ELEMENT */ /* TODO */
/* CAPWAP_CREATE_VENDORSPECIFICPAYLOAD_ELEMENT */ /* TODO */
}
/* Send join response to WTP */
result = capwap_fragment_build_packet(responsepacket, session->responsefragmentpacket, session->mtu, session->fragmentid);
if (result >= 0) {
if (result == 1) {
session->fragmentid++;
}
/* Join response complete, get fragment packets */
ac_free_reference_last_response(session);
capwap_packet_txmng_get_fragment_packets(txmngpacket, session->responsefragmentpacket, session->fragmentid);
if (session->responsefragmentpacket->count > 1) {
session->fragmentid++;
}
/* Save remote sequence number */
session->remoteseqnumber = buildpacket->ctrlmsg.seq;
capwap_get_packet_digest((void*)packet->header, packet->packetsize, session->lastrecvpackethash);
/* Free packets manager */
capwap_packet_txmng_free(txmngpacket);
/* Send */
for (i = 0; i < session->responsefragmentpacket->count; i++) {
struct capwap_packet* txpacket = (struct capwap_packet*)capwap_array_get_item_pointer(session->responsefragmentpacket, i);
ASSERT(txpacket != NULL);
if (!capwap_crypt_sendto(&session->ctrldtls, session->ctrlsocket.socket[session->ctrlsocket.type], txpacket->header, txpacket->packetsize, &session->acctrladdress, &session->wtpctrladdress)) {
/* Response is already created and saved. When receive a re-request, DFA autoresponse */
capwap_logging_debug("Warning: error to send join response packet");
break;
}
}
}
} else {
capwap_logging_debug("Warning: build invalid join response packet");
}
/* Save remote sequence number */
session->remoteseqnumber = packet->rxmngpacket->ctrlmsg.seq;
capwap_get_packet_digest(packet->rxmngpacket, packet->connection, session->lastrecvpackethash);
/* Free memory */
capwap_build_packet_free(responsepacket);
capwap_free_element_join_request(&joinrequest, binding);
capwap_build_packet_free(buildpacket);
/* Change state */
if (validpacket) {
ac_dfa_change_state(session, CAPWAP_POSTJOIN_STATE);
} else {
ac_dfa_change_state(session, CAPWAP_JOIN_TO_DTLS_TEARDOWN_STATE);
status = AC_DFA_NO_PACKET;
}
/* Send Join response to WTP */
if (capwap_crypt_sendto_fragmentpacket(&session->ctrldtls, session->ctrlsocket.socket[session->ctrlsocket.type], session->responsefragmentpacket, &session->acctrladdress, &session->wtpctrladdress)) {
ac_dfa_change_state(session, CAPWAP_POSTJOIN_STATE);
} else {
/* Error to send packets */
capwap_logging_debug("Warning: error to send join response packet");
ac_dfa_change_state(session, CAPWAP_JOIN_TO_DTLS_TEARDOWN_STATE);
status = AC_DFA_NO_PACKET;
}
} else {
/* Join timeout */
@ -236,26 +139,21 @@ int ac_dfa_state_join(struct ac_session_t* session, struct capwap_packet* packet
}
/* */
int ac_dfa_state_postjoin(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_postjoin(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
int status = AC_DFA_ACCEPT_PACKET;
ASSERT(session != NULL);
if (packet) {
unsigned short lengthpayload;
lengthpayload = packet->packetsize - GET_HLEN_HEADER(packet->header) * 4;
if (lengthpayload >= sizeof(struct capwap_control_message)) {
struct capwap_control_message* ctrlmsg = (struct capwap_control_message*)packet->payload;
unsigned long type = ntohl(ctrlmsg->type);
if (type == CAPWAP_CONFIGURATION_STATUS_REQUEST) {
ac_dfa_change_state(session, CAPWAP_CONFIGURE_STATE);
status = ac_dfa_state_configure(session, packet);
} else if (type == CAPWAP_IMAGE_DATA_REQUEST) {
ac_dfa_change_state(session, CAPWAP_IMAGE_DATA_STATE);
status = ac_dfa_state_imagedata(session, packet);
}
if (packet->rxmngpacket->ctrlmsg.type == CAPWAP_CONFIGURATION_STATUS_REQUEST) {
ac_dfa_change_state(session, CAPWAP_CONFIGURE_STATE);
status = ac_dfa_state_configure(session, packet);
} else if (packet->rxmngpacket->ctrlmsg.type == CAPWAP_IMAGE_DATA_REQUEST) {
ac_dfa_change_state(session, CAPWAP_IMAGE_DATA_STATE);
status = ac_dfa_state_imagedata(session, packet);
} else {
ac_dfa_change_state(session, CAPWAP_JOIN_TO_DTLS_TEARDOWN_STATE);
status = AC_DFA_NO_PACKET;
}
} else {
/* Join timeout */
@ -267,6 +165,6 @@ int ac_dfa_state_postjoin(struct ac_session_t* session, struct capwap_packet* pa
}
/* */
int ac_dfa_state_join_to_dtlsteardown(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_join_to_dtlsteardown(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
return ac_session_teardown_connection(session);
}

59
src/ac/ac_dfa_reset.c
View File

@ -4,69 +4,34 @@
#include "ac_session.h"
/* */
int ac_dfa_state_reset(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_reset(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
int status = AC_DFA_ACCEPT_PACKET;
ASSERT(session != NULL);
if (packet) {
if (!capwap_compare_ip(&session->wtpctrladdress, &packet->remoteaddr)) {
struct capwap_build_packet* buildpacket;
unsigned short binding;
/* Parsing packet */
buildpacket = capwap_rx_packet_create((void*)packet->header, packet->packetsize, packet->socket.isctrlsocket);
if (buildpacket) {
if (!capwap_build_packet_validate(buildpacket, NULL)) {
unsigned short binding;
/* */
binding = GET_WBID_HEADER(&buildpacket->header);
if ((binding == session->binding) && (ntohl(buildpacket->ctrlmsg.type) == CAPWAP_RESET_RESPONSE) && ((session->localseqnumber - 1) == buildpacket->ctrlmsg.seq)) {
struct capwap_element_reset_response resetresponse;
/* Valid packet, free request packet */
ac_free_reference_last_request(session);
/* Configuration status response info */
capwap_init_element_reset_response(&resetresponse, binding);
/* Parsing elements list */
if (capwap_parsing_element_reset_response(&resetresponse, buildpacket->elementslist->first)) {
ac_dfa_change_state(session, CAPWAP_RESET_TO_DTLS_TEARDOWN_STATE);
status = AC_DFA_NO_PACKET;
}
/* Free join response */
capwap_free_element_reset_response(&resetresponse, binding);
}
}
/* Free */
capwap_build_packet_free(buildpacket);
}
/* */
binding = GET_WBID_HEADER(packet->rxmngpacket->header);
if ((binding == session->binding) && (packet->rxmngpacket->ctrlmsg.type == CAPWAP_RESET_RESPONSE) && ((session->localseqnumber - 1) == packet->rxmngpacket->ctrlmsg.seq)) {
ac_dfa_change_state(session, CAPWAP_RESET_TO_DTLS_TEARDOWN_STATE);
status = AC_DFA_NO_PACKET;
}
} else {
int i;
/* No Configuration status response received */
session->dfa.rfcRetransmitCount++;
if (session->dfa.rfcRetransmitCount >= session->dfa.rfcMaxRetransmit) {
/* Timeout join state */
/* Timeout reset state */
ac_free_reference_last_request(session);
ac_dfa_change_state(session, CAPWAP_RESET_TO_DTLS_TEARDOWN_STATE);
status = AC_DFA_NO_PACKET;
} else {
/* Retransmit configuration request */
for (i = 0; i < session->requestfragmentpacket->count; i++) {
struct capwap_packet* txpacket = (struct capwap_packet*)capwap_array_get_item_pointer(session->requestfragmentpacket, i);
ASSERT(txpacket != NULL);
if (!capwap_crypt_sendto(&session->ctrldtls, session->ctrlsocket.socket[session->ctrlsocket.type], txpacket->header, txpacket->packetsize, &session->acctrladdress, &session->wtpctrladdress)) {
capwap_logging_debug("Warning: error to send configuration status request packet");
break;
}
if (!capwap_crypt_sendto_fragmentpacket(&session->ctrldtls, session->ctrlsocket.socket[session->ctrlsocket.type], session->requestfragmentpacket, &session->acctrladdress, &session->wtpctrladdress)) {
capwap_logging_debug("Warning: error to resend reset request packet");
}
/* Update timeout */
capwap_set_timeout(session->dfa.rfcRetransmitInterval, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
}
@ -76,6 +41,6 @@ int ac_dfa_state_reset(struct ac_session_t* session, struct capwap_packet* packe
}
/* */
int ac_dfa_state_reset_to_dtlsteardown(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_reset_to_dtlsteardown(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
return ac_session_teardown_connection(session);
}

355
src/ac/ac_dfa_run.c
View File

@ -4,185 +4,148 @@
#include "ac_session.h"
/* */
static int receive_echo_request(struct ac_session_t* session, struct capwap_build_packet* buildpacket, struct capwap_packet* packet) {
unsigned long i;
unsigned short binding;
static int receive_echo_request(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
struct capwap_header_data capwapheader;
struct capwap_packet_txmng* txmngpacket;
ASSERT(session != NULL);
ASSERT(buildpacket != NULL);
ASSERT(packet != NULL);
/* */
binding = GET_WBID_HEADER(&buildpacket->header);
if (ac_valid_binding(binding) && IS_SEQUENCE_SMALLER(session->remoteseqnumber, buildpacket->ctrlmsg.seq)) {
struct capwap_element_echo_request echorequest;
/* Echo request info*/
capwap_init_element_echo_request(&echorequest, binding);
/* Parsing elements list */
if (capwap_parsing_element_echo_request(&echorequest, buildpacket->elementslist->first)) {
struct capwap_build_packet* responsepacket;
/* Create response */
capwap_header_init(&capwapheader, CAPWAP_RADIOID_NONE, GET_WBID_HEADER(packet->rxmngpacket->header));
txmngpacket = capwap_packet_txmng_create_ctrl_message(&capwapheader, CAPWAP_ECHO_RESPONSE, packet->rxmngpacket->ctrlmsg.seq, session->mtu);
/* Create response */
responsepacket = capwap_tx_packet_create(CAPWAP_RADIOID_NONE, binding);
responsepacket->isctrlmsg = 1;
/* Add message element */
/* CAPWAP_CREATE_VENDORSPECIFICPAYLOAD_ELEMENT */ /* TODO */
/* Prepare echo response */
capwap_build_packet_set_control_message_type(responsepacket, CAPWAP_ECHO_RESPONSE, buildpacket->ctrlmsg.seq);
/* CAPWAP_CREATE_VENDORSPECIFICPAYLOAD_ELEMENT */ /* TODO */
/* Echo response complete, get fragment packets */
ac_free_reference_last_response(session);
capwap_packet_txmng_get_fragment_packets(txmngpacket, session->responsefragmentpacket, session->fragmentid);
if (session->responsefragmentpacket->count > 1) {
session->fragmentid++;
}
if (!capwap_build_packet_validate(responsepacket, NULL)) {
int result;
/* Free old reference for this request */
ac_free_reference_last_response(session);
/* Free packets manager */
capwap_packet_txmng_free(txmngpacket);
/* Send echo response to WTP */
result = capwap_fragment_build_packet(responsepacket, session->responsefragmentpacket, session->mtu, session->fragmentid);
if (result >= 0) {
if (result == 1) {
session->fragmentid++;
}
/* Save remote sequence number */
session->remoteseqnumber = packet->rxmngpacket->ctrlmsg.seq;
capwap_get_packet_digest(packet->rxmngpacket, packet->connection, session->lastrecvpackethash);
/* Save remote sequence number */
session->remoteseqnumber = buildpacket->ctrlmsg.seq;
capwap_get_packet_digest((void*)packet->header, packet->packetsize, session->lastrecvpackethash);
/* Send */
for (i = 0; i < session->responsefragmentpacket->count; i++) {
struct capwap_packet* txpacket = (struct capwap_packet*)capwap_array_get_item_pointer(session->responsefragmentpacket, i);
ASSERT(txpacket != NULL);
if (!capwap_crypt_sendto(&session->ctrldtls, session->ctrlsocket.socket[session->ctrlsocket.type], txpacket->header, txpacket->packetsize, &session->acctrladdress, &session->wtpctrladdress)) {
/* Response is already created and saved. When receive a re-request, DFA autoresponse */
capwap_logging_debug("Warning: error to send echo response packet");
break;
}
}
}
}
/* Free memory */
capwap_build_packet_free(responsepacket);
}
/* Free */
capwap_free_element_echo_request(&echorequest, binding);
/* Send Configure response to WTP */
if (!capwap_crypt_sendto_fragmentpacket(&session->ctrldtls, session->ctrlsocket.socket[session->ctrlsocket.type], session->responsefragmentpacket, &session->acctrladdress, &session->wtpctrladdress)) {
/* Response is already created and saved. When receive a re-request, DFA autoresponse */
capwap_logging_debug("Warning: error to send echo response packet");
}
return 0;
}
/* */
int ac_dfa_state_run(struct ac_session_t* session, struct capwap_packet* packet) {
static int ac_send_data_keepalive(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
struct capwap_list* txfragpacket;
struct capwap_header_data capwapheader;
struct capwap_packet_txmng* txmngpacket;
int result = -1;
/* Build packet */
capwap_header_init(&capwapheader, CAPWAP_RADIOID_NONE, GET_WBID_HEADER(packet->rxmngpacket->header));
capwap_header_set_keepalive_flag(&capwapheader, 1);
txmngpacket = capwap_packet_txmng_create_data_message(&capwapheader, session->mtu);
/* Add message element */
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_SESSIONID, &session->sessionid);
/* Data keepalive complete, get fragment packets into local list */
txfragpacket = capwap_list_create();
capwap_packet_txmng_get_fragment_packets(txmngpacket, txfragpacket, 0);
if (txfragpacket->count == 1) {
/* Send Data keepalive to WTP */
if (capwap_crypt_sendto_fragmentpacket(&session->datadtls, session->datasocket.socket[session->datasocket.type], txfragpacket, &session->acdataaddress, &session->wtpdataaddress)) {
result = 0;
} else {
capwap_logging_debug("Warning: error to send data channel keepalive packet");
}
} else {
capwap_logging_debug("Warning: error to send data channel keepalive packet, fragment packet");
}
/* Free packets manager */
capwap_list_free(txfragpacket);
capwap_packet_txmng_free(txmngpacket);
return result;
}
/* */
int ac_dfa_state_run(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
int status = AC_DFA_ACCEPT_PACKET;
ASSERT(session != NULL);
if (packet) {
struct capwap_build_packet* buildpacket;
buildpacket = capwap_rx_packet_create((void*)packet->header, packet->packetsize, packet->socket.isctrlsocket);
if (buildpacket) {
if (!capwap_build_packet_validate(buildpacket, NULL)) {
if (packet->socket.isctrlsocket) {
unsigned long typemsg = ntohl(buildpacket->ctrlmsg.type);
if (capwap_is_request_type(typemsg) || ((session->localseqnumber - 1) == buildpacket->ctrlmsg.seq)) {
switch (typemsg) {
case CAPWAP_CONFIGURATION_UPDATE_REQUEST: {
/* TODO */
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
break;
}
case CAPWAP_CHANGE_STATE_EVENT_RESPONSE: {
/* TODO */
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
break;
}
case CAPWAP_ECHO_REQUEST: {
if (!receive_echo_request(session, buildpacket, packet)) {
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
} else {
ac_dfa_change_state(session, CAPWAP_RUN_TO_DTLS_TEARDOWN_STATE);
status = AC_DFA_NO_PACKET;
}
break;
}
case CAPWAP_CLEAR_CONFIGURATION_REQUEST: {
/* TODO */
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
break;
}
case CAPWAP_WTP_EVENT_RESPONSE: {
/* TODO */
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
break;
}
case CAPWAP_DATA_TRANSFER_REQUEST: {
/* TODO */
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
break;
}
case CAPWAP_DATA_TRANSFER_RESPONSE: {
/* TODO */
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
break;
}
}
}
} else {
if (IS_FLAG_K_HEADER(&buildpacket->header)) {
struct capwap_sessionid_element sessionid;
if (capwap_get_sessionid_from_keepalive(buildpacket, &sessionid)) {
if (!memcmp(&sessionid, &session->sessionid, sizeof(struct capwap_sessionid_element))) {
int result;
capwap_fragment_packet_array* txfragpacket;
/* Receive data packet keepalive, response with same packet */
txfragpacket = capwap_array_create(sizeof(struct capwap_packet), 0);
result = capwap_fragment_build_packet(buildpacket, txfragpacket, CAPWAP_DONT_FRAGMENT, 0);
if (!result) {
struct capwap_packet* txpacket;
ASSERT(txfragpacket->count == 1);
txpacket = (struct capwap_packet*)capwap_array_get_item_pointer(txfragpacket, 0);
ASSERT(txpacket != NULL);
if (!capwap_crypt_sendto(&session->datadtls, session->datasocket.socket[session->datasocket.type], txpacket->header, txpacket->packetsize, &session->acdataaddress, &session->wtpdataaddress)) {
capwap_logging_debug("Warning: error to send data channel keepalive packet");
result = -1;
}
}
/* */
capwap_fragment_free(txfragpacket);
capwap_array_free(txfragpacket);
if (result) {
ac_dfa_change_state(session, CAPWAP_RUN_TO_DTLS_TEARDOWN_STATE);
status = AC_DFA_NO_PACKET;
}
}
}
} else {
if (packet->rxmngpacket->isctrlpacket) {
if (capwap_is_request_type(packet->rxmngpacket->ctrlmsg.type) || ((session->localseqnumber - 1) == packet->rxmngpacket->ctrlmsg.seq)) {
switch (packet->rxmngpacket->ctrlmsg.type) {
case CAPWAP_CONFIGURATION_UPDATE_REQUEST: {
/* TODO */
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
break;
}
case CAPWAP_CHANGE_STATE_EVENT_RESPONSE: {
/* TODO */
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
break;
}
case CAPWAP_ECHO_REQUEST: {
if (!receive_echo_request(session, packet)) {
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
} else {
ac_dfa_change_state(session, CAPWAP_RUN_TO_DTLS_TEARDOWN_STATE);
status = AC_DFA_NO_PACKET;
}
break;
}
case CAPWAP_CLEAR_CONFIGURATION_REQUEST: {
/* TODO */
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
break;
}
case CAPWAP_WTP_EVENT_RESPONSE: {
/* TODO */
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
break;
}
case CAPWAP_DATA_TRANSFER_REQUEST: {
/* TODO */
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
break;
}
case CAPWAP_DATA_TRANSFER_RESPONSE: {
/* TODO */
capwap_set_timeout(AC_MAX_ECHO_INTERVAL, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
break;
}
}
}
/* Free */
capwap_build_packet_free(buildpacket);
} else {
if (IS_FLAG_K_HEADER(packet->rxmngpacket->header)) {
if (!memcmp(packet->messageelements.sessionid, &session->sessionid, sizeof(struct capwap_sessionid_element))) {
if (ac_send_data_keepalive(session, packet)) {
ac_dfa_change_state(session, CAPWAP_RUN_TO_DTLS_TEARDOWN_STATE);
status = AC_DFA_NO_PACKET;
}
}
} else {
/* TODO */
}
}
} else {
ac_dfa_change_state(session, CAPWAP_RUN_TO_DTLS_TEARDOWN_STATE);
@ -193,71 +156,49 @@ int ac_dfa_state_run(struct ac_session_t* session, struct capwap_packet* packet)
}
/* */
int ac_dfa_state_run_to_reset(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_run_to_reset(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
int status = AC_DFA_NO_PACKET;
struct capwap_build_packet* buildpacket;
struct capwap_header_data capwapheader;
struct capwap_packet_txmng* txmngpacket;
ASSERT(session != NULL);
ASSERT(packet == NULL);
/* Build packet */
buildpacket = capwap_tx_packet_create(CAPWAP_RADIOID_NONE, session->binding);
buildpacket->isctrlmsg = 1;
/* Prepare reset request */
capwap_build_packet_set_control_message_type(buildpacket, CAPWAP_RESET_REQUEST, session->localseqnumber++);
capwap_build_packet_add_message_element(buildpacket, CAPWAP_CREATE_IMAGEIDENTIFIER_ELEMENT(&session->startupimage));
capwap_header_init(&capwapheader, CAPWAP_RADIOID_NONE, session->binding);
txmngpacket = capwap_packet_txmng_create_ctrl_message(&capwapheader, CAPWAP_RESET_REQUEST, session->localseqnumber++, session->mtu);
/* Add message element */
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_IMAGEIDENTIFIER, &session->startupimage);
/* CAPWAP_CREATE_VENDORSPECIFICPAYLOAD_ELEMENT */ /* TODO */
if (!capwap_build_packet_validate(buildpacket, NULL)) {
int i;
int result;
/* Free old reference for this request */
ac_free_reference_last_request(session);
/* Send reset request to WTP */
result = capwap_fragment_build_packet(buildpacket, session->requestfragmentpacket, session->mtu, session->fragmentid);
if (result >= 0) {
if (result == 1) {
session->fragmentid++;
}
/* Send */
for (i = 0; i < session->requestfragmentpacket->count; i++) {
struct capwap_packet* txpacket = (struct capwap_packet*)capwap_array_get_item_pointer(session->requestfragmentpacket, i);
ASSERT(txpacket != NULL);
if (!capwap_crypt_sendto(&session->ctrldtls, session->ctrlsocket.socket[session->ctrlsocket.type], txpacket->header, txpacket->packetsize, &session->acctrladdress, &session->wtpctrladdress)) {
capwap_logging_debug("Warning: error to send reset request packet");
result = -1;
break;
}
}
}
if (result == -1) {
/* Error to send packets */
ac_free_reference_last_request(session);
ac_dfa_change_state(session, CAPWAP_RESET_TO_DTLS_TEARDOWN_STATE);
} else {
session->dfa.rfcRetransmitCount = 0;
capwap_killall_timeout(&session->timeout);
capwap_set_timeout(session->dfa.rfcRetransmitInterval, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
ac_dfa_change_state(session, CAPWAP_RESET_STATE);
status = AC_DFA_ACCEPT_PACKET;
}
/* Reset request complete, get fragment packets */
ac_free_reference_last_request(session);
capwap_packet_txmng_get_fragment_packets(txmngpacket, session->requestfragmentpacket, session->fragmentid);
if (session->requestfragmentpacket->count > 1) {
session->fragmentid++;
}
/* Free packets manager */
capwap_packet_txmng_free(txmngpacket);
/* Send Configure response to WTP */
if (capwap_crypt_sendto_fragmentpacket(&session->ctrldtls, session->ctrlsocket.socket[session->ctrlsocket.type], session->requestfragmentpacket, &session->acctrladdress, &session->wtpctrladdress)) {
session->dfa.rfcRetransmitCount = 0;
capwap_killall_timeout(&session->timeout);
capwap_set_timeout(session->dfa.rfcRetransmitInterval, &session->timeout, CAPWAP_TIMER_CONTROL_CONNECTION);
ac_dfa_change_state(session, CAPWAP_RESET_STATE);
status = AC_DFA_ACCEPT_PACKET;
} else {
capwap_logging_debug("Warning: error to send reset request packet");
ac_free_reference_last_request(session);
ac_dfa_change_state(session, CAPWAP_RESET_TO_DTLS_TEARDOWN_STATE);
}
/* Free memory */
capwap_build_packet_free(buildpacket);
return status;
}
/* */
int ac_dfa_state_run_to_dtlsteardown(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_run_to_dtlsteardown(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
return ac_session_teardown_connection(session);
}

4
src/ac/ac_dfa_teardown.c
View File

@ -4,7 +4,7 @@
#include "ac_session.h"
/* */
int ac_dfa_state_teardown(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_teardown(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
ASSERT(session != NULL);
ASSERT(packet == NULL);
@ -14,7 +14,7 @@ int ac_dfa_state_teardown(struct ac_session_t* session, struct capwap_packet* pa
}
/* */
int ac_dfa_state_dead(struct ac_session_t* session, struct capwap_packet* packet) {
int ac_dfa_state_dead(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
ASSERT(session != NULL);
ASSERT(packet == NULL);

153
src/ac/ac_discovery.c
View File

@ -88,44 +88,39 @@ void ac_discovery_add_packet(void* buffer, int buffersize, int sock, struct sock
}
/* */
static struct capwap_build_packet* ac_create_discovery_response(struct capwap_build_packet* packet, struct capwap_element_discovery_request* discoveryrequest, struct sockaddr_storage* sender) {
static struct capwap_packet_txmng* ac_create_discovery_response(struct capwap_parsed_packet* packet) {
int i;
unsigned short binding;
struct capwap_list* controllist;
struct capwap_list_item* item;
struct capwap_build_packet* responsepacket;
struct capwap_header_data capwapheader;
struct capwap_packet_txmng* txmngpacket;
ASSERT(packet != NULL);
ASSERT(discoveryrequest != NULL);
ASSERT(sender != NULL);
/* Check is valid binding */
binding = GET_WBID_HEADER(&packet->header);
binding = GET_WBID_HEADER(packet->rxmngpacket->header);
if (!ac_valid_binding(binding)) {
return NULL;
}
/* Build packet */
responsepacket = capwap_tx_packet_create(CAPWAP_RADIOID_NONE, binding);
responsepacket->isctrlmsg = 1;
/* Update statistics */
ac_update_statistics();
/* Prepare discovery response */
capwap_build_packet_set_control_message_type(responsepacket, CAPWAP_DISCOVERY_RESPONSE, packet->ctrlmsg.seq);
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_ACDESCRIPTOR_ELEMENT(&g_ac.descriptor));
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_ACNAME_ELEMENT(&g_ac.acname));
/* Build packet */
capwap_header_init(&capwapheader, CAPWAP_RADIOID_NONE, binding);
txmngpacket = capwap_packet_txmng_create_ctrl_message(&capwapheader, CAPWAP_DISCOVERY_RESPONSE, packet->rxmngpacket->ctrlmsg.seq, g_ac.mtu);
/* Prepare discovery response */
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_ACDESCRIPTION, &g_ac.descriptor);
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_ACNAME, &g_ac.acname);
if (binding == CAPWAP_WIRELESS_BINDING_IEEE80211) {
for (i = 0; i < discoveryrequest->binding.ieee80211.wtpradioinformation->count; i++) {
for (i = 0; i < packet->messageelements.ieee80211.wtpradioinformation->count; i++) {
struct capwap_80211_wtpradioinformation_element* radio;
radio = (struct capwap_80211_wtpradioinformation_element*)capwap_array_get_item_pointer(discoveryrequest->binding.ieee80211.wtpradioinformation, i);
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_80211_WTPRADIOINFORMATION_ELEMENT(radio));
radio = *(struct capwap_80211_wtpradioinformation_element**)capwap_array_get_item_pointer(packet->messageelements.ieee80211.wtpradioinformation, i);
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_80211_WTPRADIOINFORMATION, radio);
}
} else {
capwap_logging_debug("Unknown capwap binding");
}
/* Get information from any local address */
@ -137,24 +132,24 @@ static struct capwap_build_packet* ac_create_discovery_response(struct capwap_bu
if (sessioncontrol->localaddress.ss_family == AF_INET) {
struct capwap_controlipv4_element element;
memcpy(&element.address, &((struct sockaddr_in*)&sessioncontrol->localaddress)->sin_addr, sizeof(struct in_addr));
element.wtpcount = sessioncontrol->count;
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_CONTROLIPV4_ELEMENT(&element));
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_CONTROLIPV4, &element);
} else if (sessioncontrol->localaddress.ss_family == AF_INET6) {
struct capwap_controlipv6_element element;
memcpy(&element.address, &((struct sockaddr_in6*)&sessioncontrol->localaddress)->sin6_addr, sizeof(struct in6_addr));
element.wtpcount = sessioncontrol->count;
capwap_build_packet_add_message_element(responsepacket, CAPWAP_CREATE_CONTROLIPV6_ELEMENT(&element));
capwap_packet_txmng_add_message_element(txmngpacket, CAPWAP_ELEMENT_CONTROLIPV6, &element);
}
}
capwap_list_free(controllist);
capwap_list_free(controllist);
/* CAPWAP_CREATE_VENDORSPECIFICPAYLOAD_ELEMENT */ /* TODO */
return responsepacket;
return txmngpacket;
}
/* Cleanup info discovery */
@ -167,21 +162,21 @@ static void ac_discovery_cleanup(void) {
static void ac_discovery_run(void) {
int sizedata;
struct capwap_list_item* itempacket;
struct capwap_build_packet* buildpacket;
struct ac_discovery_packet* packet;
unsigned short binding;
struct ac_discovery_packet* acpacket;
struct capwap_parsed_packet packet;
struct capwap_packet_rxmng* rxmngpacket;
while (!g_ac_discovery.endthread) {
/* Get packet */
capwap_lock_enter(&g_ac_discovery.packetslock);
itempacket = NULL;
if (g_ac_discovery.packets->count > 0) {
itempacket = capwap_itemlist_remove_head(g_ac_discovery.packets);
}
capwap_lock_exit(&g_ac_discovery.packetslock);
if (!itempacket) {
/* Wait packet with timeout*/
if (!capwap_event_wait_timeout(&g_ac_discovery.waitpacket, AC_DISCOVERY_CLEANUP_TIMEOUT)) {
@ -190,74 +185,56 @@ static void ac_discovery_run(void) {
continue;
}
/* */
packet = (struct ac_discovery_packet*)itempacket->item;
acpacket = (struct ac_discovery_packet*)itempacket->item;
sizedata = itempacket->itemsize - sizeof(struct ac_discovery_packet);
/* Parsing packet */
buildpacket = capwap_rx_packet_create(packet->data, sizedata, 1);
if (buildpacket) {
if (!capwap_build_packet_validate(buildpacket, NULL)) {
struct capwap_element_discovery_request discoveryrequest;
/* */
binding = GET_WBID_HEADER(&buildpacket->header);
capwap_init_element_discovery_request(&discoveryrequest, binding);
/* Parsing elements list */
if (capwap_parsing_element_discovery_request(&discoveryrequest, buildpacket->elementslist->first)) {
struct capwap_build_packet* txpacket;
capwap_fragment_packet_array* responsefragmentpacket = NULL;
/* Accept only discovery request don't fragment */
rxmngpacket = capwap_packet_rxmng_create_message(1);
if (capwap_packet_rxmng_add_recv_packet(rxmngpacket, acpacket->data, sizedata) == CAPWAP_RECEIVE_COMPLETE_PACKET) {
/* Validate message */
if (capwap_check_message_type(rxmngpacket) == VALID_MESSAGE_TYPE) {
/* Parsing packet */
if (!capwap_parsing_packet(rxmngpacket, NULL, &packet)) {
/* Validate packet */
if (!capwap_validate_parsed_packet(&packet, NULL)) {
struct capwap_packet_txmng* txmngpacket;
/* Creare discovery response */
txpacket = ac_create_discovery_response(buildpacket, &discoveryrequest, &packet->sender);
if (txpacket) {
int result = -1;
if (!capwap_build_packet_validate(txpacket, NULL)) {
responsefragmentpacket = capwap_array_create(sizeof(struct capwap_packet), 0);
result = capwap_fragment_build_packet(txpacket, responsefragmentpacket, g_ac.mtu, g_ac_discovery.fragmentid);
if (result == 1) {
/* Creare discovery response */
txmngpacket = ac_create_discovery_response(&packet);
if (txmngpacket) {
struct capwap_list* responsefragmentpacket;
/* Discovery response complete, get fragment packets */
responsefragmentpacket = capwap_list_create();
capwap_packet_txmng_get_fragment_packets(txmngpacket, responsefragmentpacket, g_ac_discovery.fragmentid);
if (responsefragmentpacket->count > 1) {
g_ac_discovery.fragmentid++;
}
} else {
capwap_logging_debug("Warning: build invalid discovery response packet");
}
capwap_build_packet_free(txpacket);
/* Send discovery response to WTP */
if (result >= 0) {
int i;
for (i = 0; i < responsefragmentpacket->count; i++) {
struct capwap_packet* sendpacket = (struct capwap_packet*)capwap_array_get_item_pointer(responsefragmentpacket, i);
ASSERT(sendpacket != NULL);
if (!capwap_sendto(packet->sendsock, sendpacket->header, sendpacket->packetsize, NULL, &packet->sender)) {
capwap_logging_debug("Warning: error to send discovery response packet");
break;
}
/* Free packets manager */
capwap_packet_txmng_free(txmngpacket);
/* Send discovery response to WTP */
if (!capwap_sendto_fragmentpacket(acpacket->sendsock, responsefragmentpacket, NULL, &acpacket->sender)) {
capwap_logging_debug("Warning: error to send discovery response packet");
}
/* Don't buffering a packets sent */
capwap_list_free(responsefragmentpacket);
}
}
/* Don't buffering a packets sent */
if (responsefragmentpacket) {
capwap_fragment_free(responsefragmentpacket);
capwap_array_free(responsefragmentpacket);
}
}
/* Free discovery request */
capwap_free_element_discovery_request(&discoveryrequest, binding);
/* Free resource */
capwap_free_parsed_packet(&packet);
}
/* */
capwap_build_packet_free(buildpacket);
}
/* Free resource */
capwap_packet_rxmng_free(rxmngpacket);
/* Free packet */
capwap_itemlist_free(itempacket);
}

119
src/ac/ac_execute.c
View File

@ -58,44 +58,68 @@ static struct ac_session_t* ac_search_session_from_wtpaddress(struct sockaddr_st
/* */
static struct ac_session_t* ac_get_session_from_keepalive(void* buffer, int buffersize) {
struct capwap_parsed_packet packet;
struct capwap_packet_rxmng* rxmngpacket;
struct ac_session_t* result = NULL;
struct capwap_build_packet* buildpacket;
ASSERT(buffer != NULL);
ASSERT(buffersize > 0);
buildpacket = capwap_rx_packet_create(buffer, buffersize, 0);
if (buildpacket) {
struct capwap_sessionid_element sessionid;
if (capwap_get_sessionid_from_keepalive(buildpacket, &sessionid)) {
/* Build receive manager CAPWAP message */
rxmngpacket = capwap_packet_rxmng_create_message(0);
if (capwap_packet_rxmng_add_recv_packet(rxmngpacket, buffer, buffersize) != CAPWAP_RECEIVE_COMPLETE_PACKET) {
/* Accept only keep alive without fragmentation */
capwap_packet_rxmng_free(rxmngpacket);
capwap_logging_debug("Receive data keep alive packet fragmentated");
return NULL;
}
/* Validate message */
if (capwap_check_message_type(rxmngpacket) != VALID_MESSAGE_TYPE) {
/* Invalid message */
capwap_packet_rxmng_free(rxmngpacket);
capwap_logging_debug("Invalid data packet message type");
return NULL;
}
/* Parsing packet */
if (!capwap_parsing_packet(rxmngpacket, NULL, &packet)) {
/* Validate packet */
if (!capwap_validate_parsed_packet(&packet, NULL)) {
struct capwap_list_item* search;
ASSERT(packet.messageelements.sessionid != NULL);
capwap_lock_enter(&g_ac.sessionslock);
search = g_ac.sessions->first;
while (search != NULL) {
struct ac_session_t* session = (struct ac_session_t*)search->item;
ASSERT(session != NULL);
if (!memcmp(&sessionid, &session->sessionid, sizeof(struct capwap_sessionid_element))) {
if (!memcmp(packet.messageelements.sessionid, &session->sessionid, sizeof(struct capwap_sessionid_element))) {
session->count++;
result = session;
break;
}
search = search->next;
search = search->next;
}
capwap_lock_exit(&g_ac.sessionslock);
} else {
capwap_logging_debug("Failed validation parsed data packet");
}
/* Free */
capwap_build_packet_free(buildpacket);
} else {
capwap_logging_debug("Failed parsing data packet");
}
return result;
/* Free resource */
capwap_free_parsed_packet(&packet);
capwap_packet_rxmng_free(rxmngpacket);
return result;
}
/* Close session */
@ -117,7 +141,7 @@ static void ac_close_sessions() {
ac_close_session(session);
search = search->next;
search = search->next;
}
capwap_lock_exit(&g_ac.sessionslock);
@ -246,7 +270,7 @@ static struct ac_session_t* ac_create_session(struct sockaddr_storage* wtpaddres
int result;
struct capwap_list_item* itemlist;
struct ac_session_t* session;
ASSERT(acaddress != NULL);
ASSERT(wtpaddress != NULL);
ASSERT(ctrlsock != NULL);
@ -263,37 +287,36 @@ static struct ac_session_t* ac_create_session(struct sockaddr_storage* wtpaddres
/* Duplicate state for DFA */
memcpy(&session->dfa, &g_ac.dfa, sizeof(struct ac_state));
session->dfa.acipv4list = capwap_array_clone(g_ac.dfa.acipv4list);
session->dfa.acipv6list = capwap_array_clone(g_ac.dfa.acipv6list);
session->dfa.acipv4list.addresses = capwap_array_clone(g_ac.dfa.acipv4list.addresses);
session->dfa.acipv6list.addresses = capwap_array_clone(g_ac.dfa.acipv6list.addresses);
session->dfa.rfcRetransmitInterval = AC_DEFAULT_RETRANSMIT_INTERVAL;
session->dfa.rfcMaxRetransmit = AC_MAX_RETRANSMIT;
session->dfa.rfcDTLSSessionDelete = AC_DEFAULT_DTLS_SESSION_DELETE;
/* Add default AC list if empty*/
if ((session->dfa.acipv4list->count == 0) && (session->dfa.acipv6list->count == 0)) {
if ((session->dfa.acipv4list.addresses->count == 0) && (session->dfa.acipv6list.addresses->count == 0)) {
if (session->acctrladdress.ss_family == AF_INET) {
struct capwap_acipv4list_element* acip = (struct capwap_acipv4list_element*)capwap_array_get_item_pointer(session->dfa.acipv4list, 0);
memcpy(&acip->address, &((struct sockaddr_in*)&session->acctrladdress)->sin_addr, sizeof(struct in_addr));
struct in_addr* acip = (struct in_addr*)capwap_array_get_item_pointer(session->dfa.acipv4list.addresses, 0);
memcpy(acip, &((struct sockaddr_in*)&session->acctrladdress)->sin_addr, sizeof(struct in_addr));
} else if (session->acctrladdress.ss_family == AF_INET6) {
struct capwap_acipv6list_element* acip = (struct capwap_acipv6list_element*)capwap_array_get_item_pointer(session->dfa.acipv6list, 0);
memcpy(&acip->address, &((struct sockaddr_in6*)&session->acctrladdress)->sin6_addr, sizeof(struct in6_addr));
struct in6_addr* acip = (struct in6_addr*)capwap_array_get_item_pointer(session->dfa.acipv6list.addresses, 0);
memcpy(acip, &((struct sockaddr_in6*)&session->acctrladdress)->sin6_addr, sizeof(struct in6_addr));
}
}
/* Init */
capwap_event_init(&session->waitpacket);
capwap_lock_init(&session->packetslock);
session->controlpackets = capwap_list_create();
session->datapackets = capwap_list_create();
session->requestfragmentpacket = capwap_array_create(sizeof(struct capwap_packet), 0);
session->responsefragmentpacket = capwap_array_create(sizeof(struct capwap_packet), 0);
session->rxfragmentpacket = capwap_defragment_init_list();
session->requestfragmentpacket = capwap_list_create();
session->responsefragmentpacket = capwap_list_create();
session->mtu = g_ac.mtu;
session->state = CAPWAP_IDLE_STATE;
/* Update session list */
capwap_lock_enter(&g_ac.sessionslock);
capwap_itemlist_insert_after(g_ac.sessions, NULL, itemlist);
@ -323,10 +346,10 @@ static struct ac_session_t* ac_create_session(struct sockaddr_storage* wtpaddres
/* Update statistics */
void ac_update_statistics(void) {
g_ac.descriptor.station = 0; /* TODO */
g_ac.descriptor.stations = 0; /* TODO */
capwap_lock_enter(&g_ac.sessionslock);
g_ac.descriptor.wtp = g_ac.sessions->count;
g_ac.descriptor.activewtp = g_ac.sessions->count;
capwap_lock_exit(&g_ac.sessionslock);
}
@ -344,7 +367,7 @@ int ac_execute(void) {
int result = CAPWAP_SUCCESSFUL;
int index;
int check;
int check;
int isctrlsocket = 0;
struct sockaddr_storage recvfromaddr;
struct sockaddr_storage recvtoaddr;
@ -400,15 +423,15 @@ int ac_execute(void) {
if (getsockname(fds[index].fd, (struct sockaddr*)&sockinfo, &sockinfolen) < 0) {
break;
}
CAPWAP_SET_NETWORK_PORT(&recvtoaddr, CAPWAP_GET_NETWORK_PORT(&sockinfo));
}
}
/* Search the AC session */
isctrlsocket = ((index < (fdscount / 2)) ? 1 : 0);
session = ac_search_session_from_wtpaddress(&recvfromaddr, isctrlsocket);
if (session) {
/* Add packet*/
ac_session_add_packet(session, buffer, buffersize, isctrlsocket, 0);
@ -418,38 +441,38 @@ int ac_execute(void) {
} else {
if (isctrlsocket) {
unsigned short sessioncount;
/* Get current session number */
capwap_lock_enter(&g_ac.sessionslock);
sessioncount = g_ac.sessions->count;
capwap_lock_exit(&g_ac.sessionslock);
/* PreParsing packet for reduce a DoS attack */
check = capwap_sanity_check(isctrlsocket, CAPWAP_UNDEF_STATE, buffer, buffersize, g_ac.enabledtls, 0);
if (check == CAPWAP_PLAIN_PACKET) {
struct capwap_header* header = (struct capwap_header*)buffer;
/* Accepted only packet without fragmentation */
if (!IS_FLAG_F_HEADER(header)) {
int headersize = GET_HLEN_HEADER(header) * 4;
if (buffersize >= (headersize + sizeof(struct capwap_control_message))) {
struct capwap_control_message* control = (struct capwap_control_message*)((char*)buffer + headersize);
unsigned long type = ntohl(control->type);
if (type == CAPWAP_DISCOVERY_REQUEST) {
if (sessioncount < g_ac.descriptor.wtplimit) {
if (sessioncount < g_ac.descriptor.maxwtp) {
ac_discovery_add_packet(buffer, buffersize, fds[index].fd, &recvfromaddr);
}
} else if (!g_ac.enabledtls && (type == CAPWAP_JOIN_REQUEST)) {
if (sessioncount < g_ac.descriptor.wtplimit) {
if (sessioncount < g_ac.descriptor.maxwtp) {
/* Retrive socket info */
capwap_get_network_socket(&g_ac.net, &ctrlsock, fds[index].fd);
/* Create a new session */
session = ac_create_session(&recvfromaddr, &recvtoaddr, &ctrlsock);
if (session) {
ac_session_add_packet(session, buffer, buffersize, isctrlsocket, 1);
/* Release reference */
ac_session_release_reference(session);
}
@ -459,7 +482,7 @@ int ac_execute(void) {
}
} else if (check == CAPWAP_DTLS_PACKET) {
/* Need create a new sessione for check if it is a valid DTLS handshake */
if (sessioncount < g_ac.descriptor.wtplimit) {
if (sessioncount < g_ac.descriptor.maxwtp) {
/* TODO prevent dos attack add filtering ip for multiple error */
/* Retrive socket info */
@ -512,7 +535,7 @@ int ac_execute(void) {
/* Wait that list is changed */
capwap_logging_debug("Waiting for %d session terminate", count);
capwap_event_wait(&g_ac.changesessionlist);
capwap_event_wait(&g_ac.changesessionlist);
}
/* Free handshark session */

141
src/ac/ac_session.c
View File

@ -27,6 +27,11 @@ static int ac_network_read(struct ac_session_t* session, void* buffer, int lengt
struct capwap_list_item* itempacket;
*isctrlpacket = ((session->controlpackets->count > 0) ? 1 : 0);
if (*isctrlpacket) {
capwap_logging_debug("Receive control packet");
} else {
capwap_logging_debug("Receive data packet");
}
/* Get packet */
itempacket = capwap_itemlist_remove_head((*isctrlpacket ? session->controlpackets : session->datapackets));
@ -70,7 +75,7 @@ static int ac_network_read(struct ac_session_t* session, void* buffer, int lengt
return result;
}
capwap_lock_exit(&session->packetslock);
/* Update timeout */
@ -88,7 +93,7 @@ static int ac_network_read(struct ac_session_t* session, void* buffer, int lengt
}
/* */
static int ac_dfa_execute(struct ac_session_t* session, struct capwap_packet* packet) {
static int ac_dfa_execute(struct ac_session_t* session, struct capwap_parsed_packet* packet) {
int action = AC_DFA_ACCEPT_PACKET;
ASSERT(session != NULL);
@ -366,12 +371,47 @@ static int ac_dfa_execute(struct ac_session_t* session, struct capwap_packet* pa
return action;
}
/* */
static struct capwap_packet_rxmng* ac_get_packet_rxmng(struct ac_session_t* session, int isctrlmsg) {
struct capwap_packet_rxmng* rxmngpacket = NULL;
if (isctrlmsg) {
if (!session->rxmngctrlpacket) {
session->rxmngctrlpacket = capwap_packet_rxmng_create_message(1);
}
rxmngpacket = session->rxmngctrlpacket;
} else {
if (!session->rxmngdatapacket) {
session->rxmngdatapacket = capwap_packet_rxmng_create_message(0);
}
rxmngpacket = session->rxmngdatapacket;
}
return rxmngpacket;
}
/* */
static void ac_free_packet_rxmng(struct ac_session_t* session, int isctrlmsg) {
if (isctrlmsg && session->rxmngctrlpacket) {
capwap_packet_rxmng_free(session->rxmngctrlpacket);
session->rxmngctrlpacket = NULL;
} else if (!isctrlmsg && session->rxmngdatapacket) {
capwap_packet_rxmng_free(session->rxmngdatapacket);
session->rxmngdatapacket = NULL;
}
}
/* */
static void ac_session_run(struct ac_session_t* session) {
int res;
int check;
int length;
int isctrlsocket;
int action = AC_DFA_ACCEPT_PACKET;
struct capwap_connection connection;
char buffer[CAPWAP_MAX_PACKET_SIZE];
int action = AC_DFA_ACCEPT_PACKET;
ASSERT(session != NULL);
@ -402,35 +442,66 @@ static void ac_session_run(struct ac_session_t* session) {
/* Check generic capwap packet */
check = capwap_sanity_check(isctrlsocket, CAPWAP_UNDEF_STATE, buffer, length, 0, 0);
if (check == CAPWAP_PLAIN_PACKET) {
struct capwap_packet packet;
check = capwap_defragment_packets(&session->wtpctrladdress, buffer, length, session->rxfragmentpacket, &packet);
struct capwap_parsed_packet packet;
struct capwap_packet_rxmng* rxmngpacket;
/* Defragment management */
rxmngpacket = ac_get_packet_rxmng(session, isctrlsocket);
/* If request, defragmentation packet */
check = capwap_packet_rxmng_add_recv_packet(rxmngpacket, buffer, length);
if (check == CAPWAP_RECEIVE_COMPLETE_PACKET) {
int ignorepacket = 0;
/* Receive all fragment */
memcpy(&connection.socket, (isctrlsocket ? &session->ctrlsocket : &session->datasocket), sizeof(struct capwap_socket));
memcpy(&connection.localaddr, (isctrlsocket ? &session->acctrladdress : &session->acdataaddress), sizeof(struct sockaddr_storage));
memcpy(&connection.remoteaddr, (isctrlsocket ? &session->wtpctrladdress : &session->wtpdataaddress), sizeof(struct sockaddr_storage));
if (isctrlsocket) {
/* Check for already response to packet */
if (capwap_recv_retrasmitted_request(&session->ctrldtls, &packet, session->remoteseqnumber, session->lastrecvpackethash, &session->ctrlsocket, session->responsefragmentpacket, &session->acctrladdress, &session->wtpctrladdress)) {
ignorepacket = 1;
}
/* Check message type */
if (!capwap_check_message_type(&session->ctrldtls, &packet, session->mtu)) {
if (!capwap_recv_retrasmitted_request(&session->ctrldtls, rxmngpacket, &connection, session->lastrecvpackethash, session->responsefragmentpacket)) {
/* Check message type */
res = capwap_check_message_type(rxmngpacket);
if (res != VALID_MESSAGE_TYPE) {
if (res == INVALID_REQUEST_MESSAGE_TYPE) {
/*TODO wtp_send_invalid_request(rxmngpacket, &connection);*/
}
ignorepacket = 1;
capwap_logging_debug("Invalid message type");
}
} else {
ignorepacket = 1;
capwap_logging_debug("Retrasmitted packet");
}
}
/* Parsing packet */
if (!ignorepacket) {
if (!capwap_parsing_packet(rxmngpacket, &connection, &packet)) {
/* Validate packet */
if (capwap_validate_parsed_packet(&packet, NULL)) {
/* TODO gestione errore risposta */
ignorepacket = 1;
capwap_logging_debug("Failed validation parsed packet");
}
} else {
ignorepacket = 1;
capwap_logging_debug("Failed parsing packet");
}
}
/* */
if (!ignorepacket && (action == AC_DFA_ACCEPT_PACKET)) {
memcpy(&packet.socket, (isctrlsocket ? &session->ctrlsocket : &session->datasocket), sizeof(struct capwap_socket));
action = ac_dfa_execute(session, &packet);
}
/* Free packet */
capwap_free_packet(&packet);
/* Free memory */
capwap_free_parsed_packet(&packet);
ac_free_packet_rxmng(session, isctrlsocket);
} else if (check != CAPWAP_REQUEST_MORE_FRAGMENT) {
/* Discard fragments */
capwap_defragment_remove_sender(session->rxfragmentpacket, &session->wtpctrladdress);
ac_free_packet_rxmng(session, isctrlsocket);
}
}
}
@ -508,27 +579,27 @@ int ac_session_release_reference(struct ac_session_t* session) {
capwap_lock_exit(&session->packetslock);
capwap_list_free(session->controlpackets);
capwap_list_free(session->datapackets);
capwap_defragment_free_list(session->rxfragmentpacket);
/* Free fragments packet */
capwap_fragment_free(session->requestfragmentpacket);
capwap_fragment_free(session->responsefragmentpacket);
capwap_array_free(session->requestfragmentpacket);
capwap_array_free(session->responsefragmentpacket);
ac_free_packet_rxmng(session, 1);
ac_free_packet_rxmng(session, 0);
capwap_list_free(session->requestfragmentpacket);
capwap_list_free(session->responsefragmentpacket);
/* Free DFA resource */
capwap_array_free(session->dfa.acipv4list);
capwap_array_free(session->dfa.acipv6list);
capwap_array_free(session->dfa.acipv4list.addresses);
capwap_array_free(session->dfa.acipv6list.addresses);
/* Remove item from list */
remove = 1;
capwap_itemlist_free(capwap_itemlist_remove(g_ac.sessions, search));
capwap_event_signal(&g_ac.changesessionlist);
break;
}
search = search->next;
search = search->next;
}
}
@ -547,7 +618,7 @@ void* ac_session_thread(void* param) {
/* Thread exit */
pthread_exit(NULL);
return NULL;
return NULL;
}
/* */
@ -596,22 +667,22 @@ void ac_get_control_information(struct capwap_list* controllist) {
}
}
}
/* */
capwap_lock_exit(&g_ac.sessionslock);
capwap_lock_exit(&g_ac.sessionslock);
}
/* */
void ac_free_reference_last_request(struct ac_session_t* session) {
ASSERT(session);
capwap_fragment_free(session->requestfragmentpacket);
capwap_list_flush(session->requestfragmentpacket);
}
/* */
void ac_free_reference_last_response(struct ac_session_t* session) {
ASSERT(session);
capwap_fragment_free(session->responsefragmentpacket);
capwap_list_flush(session->responsefragmentpacket);
memset(&session->lastrecvpackethash[0], 0, sizeof(session->lastrecvpackethash));
}

47
src/ac/ac_session.h
View File

@ -51,9 +51,10 @@ struct ac_session_t {
unsigned char remoteseqnumber;
unsigned short mtu;
unsigned short fragmentid;
capwap_fragment_list* rxfragmentpacket;
capwap_fragment_packet_array* requestfragmentpacket;
capwap_fragment_packet_array* responsefragmentpacket;
struct capwap_packet_rxmng* rxmngctrlpacket;
struct capwap_packet_rxmng* rxmngdatapacket;
struct capwap_list* requestfragmentpacket;
struct capwap_list* responsefragmentpacket;
unsigned char lastrecvpackethash[16];
unsigned long state;
@ -73,40 +74,40 @@ void ac_free_reference_last_request(struct ac_session_t* session);
void ac_free_reference_last_response(struct ac_session_t* session);
/* */
int ac_dfa_state_join(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_postjoin(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_join_to_dtlsteardown(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_join(struct ac_session_t* session, struct capwap_parsed_packet* packet);
int ac_dfa_state_postjoin(struct ac_session_t* session, struct capwap_parsed_packet* packet);
int ac_dfa_state_join_to_dtlsteardown(struct ac_session_t* session, struct capwap_parsed_packet* packet);
/* */
int ac_bio_send(struct capwap_dtls* dtls, char* buffer, int length, void* param);
int ac_dfa_state_dtlssetup(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_dtlsconnect(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_dtlsconnect_to_dtlsteardown(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_dtlssetup(struct ac_session_t* session, struct capwap_parsed_packet* packet);
int ac_dfa_state_dtlsconnect(struct ac_session_t* session, struct capwap_parsed_packet* packet);
int ac_dfa_state_dtlsconnect_to_dtlsteardown(struct ac_session_t* session, struct capwap_parsed_packet* packet);
/* */
int ac_dfa_state_configure(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_configure_to_dtlsteardown(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_configure(struct ac_session_t* session, struct capwap_parsed_packet* packet);
int ac_dfa_state_configure_to_dtlsteardown(struct ac_session_t* session, struct capwap_parsed_packet* packet);
/* */
int ac_dfa_state_datacheck(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_datacheck_to_run(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_datacheck_to_dtlsteardown(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_datacheck(struct ac_session_t* session, struct capwap_parsed_packet* packet);
int ac_dfa_state_datacheck_to_run(struct ac_session_t* session, struct capwap_parsed_packet* packet);
int ac_dfa_state_datacheck_to_dtlsteardown(struct ac_session_t* session, struct capwap_parsed_packet* packet);
/* */
int ac_dfa_state_imagedata(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_imagedata_to_dtlsteardown(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_imagedata(struct ac_session_t* session, struct capwap_parsed_packet* packet);
int ac_dfa_state_imagedata_to_dtlsteardown(struct ac_session_t* session, struct capwap_parsed_packet* packet);
/* */
int ac_dfa_state_run(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_run_to_reset(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_run_to_dtlsteardown(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_run(struct ac_session_t* session, struct capwap_parsed_packet* packet);
int ac_dfa_state_run_to_reset(struct ac_session_t* session, struct capwap_parsed_packet* packet);
int ac_dfa_state_run_to_dtlsteardown(struct ac_session_t* session, struct capwap_parsed_packet* packet);
/* */
int ac_dfa_state_reset(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_reset_to_dtlsteardown(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_reset(struct ac_session_t* session, struct capwap_parsed_packet* packet);
int ac_dfa_state_reset_to_dtlsteardown(struct ac_session_t* session, struct capwap_parsed_packet* packet);
/* */
int ac_dfa_state_teardown(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_dead(struct ac_session_t* session, struct capwap_packet* packet);
int ac_dfa_state_teardown(struct ac_session_t* session, struct capwap_parsed_packet* packet);
int ac_dfa_state_dead(struct ac_session_t* session, struct capwap_parsed_packet* packet);
#endif /* __AC_SESSION_HEADER__ */

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__ */

Some files were not shown because too many files have changed in this diff Show More