static void* capwap_80211_ie_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_80211_ie_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if (length < 4) {
log_printf(LOG_DEBUG, "Invalid IEEE 802.11 Information Element element");
return NULL;
}
/* */
length -= 3;
/* */
data = (struct capwap_80211_ie_element*)capwap_alloc(sizeof(struct capwap_80211_ie_element));
memset(data, 0, sizeof(struct capwap_80211_ie_element));
/* Retrieve data */
func->read_u8(handle, &data->radioid);
func->read_u8(handle, &data->wlanid);
func->read_u8(handle, &data->flags);
data->ielength = length;
data->ie = (uint8_t*)capwap_alloc(data->ielength);
func->read_block(handle, data->ie, data->ielength);
log_printf(LOG_DEBUG, "802.11 IE flags: %02x (%p)", data->flags, &data->flags);
return data;
}
static void* capwap_wtpboarddata_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_wtpboarddata_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) < 14) {
capwap_logging_debug("Invalid WTP Board Data element: underbuffer");
return NULL;
}
/* */
data = (struct capwap_wtpboarddata_element*)capwap_alloc(sizeof(struct capwap_wtpboarddata_element));
data->boardsubelement = capwap_array_create(sizeof(struct capwap_wtpboarddata_board_subelement), 0, 1);
/* Retrieve data */
func->read_u32(handle, &data->vendor);
if (!data->vendor) {
capwap_wtpboarddata_element_free((void*)data);
capwap_logging_debug("Invalid WTP Board Data element: invalid vendor");
return NULL;
}
/* 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);
if ((desc->type < CAPWAP_BOARD_SUBELEMENT_TYPE_FIRST) || (desc->type > CAPWAP_BOARD_SUBELEMENT_TYPE_LAST)) {
capwap_logging_debug("Invalid WTP Board Data element: invalid type");
capwap_wtpboarddata_element_free(data);
return NULL;
}
/* Check buffer size */
length = func->read_ready(handle);
if (!length || (length > CAPWAP_BOARD_SUBELEMENT_MAXDATA) || (length < desc->length)) {
capwap_logging_debug("Invalid WTP Board Data element: invalid length");
capwap_wtpboarddata_element_free(data);
return NULL;
}
desc->data = (uint8_t*)capwap_alloc(desc->length);
func->read_block(handle, desc->data, desc->length);
}
return data;
}
int ac_execute_update_fdspool(struct ac_fds* fds) {
int totalcount;
int kmodcount;
struct pollfd* fdsbuffer;
ASSERT(fds != NULL);
/* Retrieve number of Dynamic File Descriptor Event */
kmodcount = ac_kmod_getfd(NULL, NULL, 0);
if (kmodcount < 0) {
return -1;
}
/* Kernel Module Events Callback */
fds->kmodeventsstartpos = -1;
if (kmodcount != fds->kmodeventscount) {
if (fds->kmodevents) {
capwap_free(fds->kmodevents);
}
/* */
fds->kmodeventscount = kmodcount;
fds->kmodevents = (struct ac_kmod_event*)((kmodcount > 0) ? capwap_alloc(sizeof(struct ac_kmod_event) * kmodcount) : NULL);
}
/* Resize poll */
totalcount = fds->fdsnetworkcount + fds->msgqueuecount + fds->kmodeventscount;
if (fds->fdstotalcount != totalcount) {
fdsbuffer = (struct pollfd*)capwap_alloc(sizeof(struct pollfd) * totalcount);
if (fds->fdspoll) {
int count = fds->fdsnetworkcount + fds->msgqueuecount;
if (count > 0) {
memcpy(fdsbuffer, fds->fdspoll, sizeof(struct pollfd) * count);
}
capwap_free(fds->fdspoll);
}
/* */
fds->fdspoll = fdsbuffer;
fds->fdstotalcount = totalcount;
}
/* Retrieve File Descriptor Kernel Module Event */
if (fds->kmodeventscount > 0) {
fds->kmodeventsstartpos = fds->fdsnetworkcount + fds->msgqueuecount;
ac_kmod_getfd(&fds->fdspoll[fds->kmodeventsstartpos], fds->kmodevents, fds->kmodeventscount);
}
return fds->fdstotalcount;
}
static void* capwap_addstation_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_addstation_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if (length < 8) {
capwap_logging_debug("Invalid Add Station element: underbuffer");
return NULL;
}
length -= 2;
/* */
data = (struct capwap_addstation_element*)capwap_alloc(sizeof(struct capwap_addstation_element));
memset(data, 0, sizeof(struct capwap_addstation_element));
/* Retrieve data */
func->read_u8(handle, &data->radioid);
func->read_u8(handle, &data->length);
if (!IS_VALID_RADIOID(data->radioid)) {
capwap_addstation_element_free((void*)data);
capwap_logging_debug("Invalid Add Station element: invalid radio");
return NULL;
} else if (!IS_VALID_MACADDRESS_LENGTH(data->length) || (length < data->length)) {
capwap_addstation_element_free((void*)data);
capwap_logging_debug("Invalid Add Station element: invalid length");
return NULL;
}
data->address = (uint8_t*)capwap_alloc(data->length);
func->read_block(handle, data->address, data->length);
length -= data->length;
if (length > 0) {
if (length <= CAPWAP_ADDSTATION_VLAN_MAX_LENGTH) {
data->vlan = (uint8_t*)capwap_alloc(length + 1);
func->read_block(handle, data->vlan, length);
data->vlan[length] = 0;
} else {
capwap_addstation_element_free((void*)data);
capwap_logging_debug("Invalid Add Station element: invalid vlan");
return NULL;
}
}
return data;
}
static void* ac_json_80211_supportedrates_createmessageelement(struct json_object* jsonparent, uint16_t radioid) {
int i;
int length;
struct capwap_80211_supportedrates_element* supportedrates;
if (json_object_get_type(jsonparent) != json_type_array) {
return NULL;
}
length = json_object_array_length(jsonparent);
if ((length < CAPWAP_SUPPORTEDRATES_MINLENGTH) || (length > CAPWAP_SUPPORTEDRATES_MAXLENGTH)) {
return NULL;
}
supportedrates = (struct capwap_80211_supportedrates_element*)capwap_alloc(sizeof(struct capwap_80211_supportedrates_element));
memset(supportedrates, 0, sizeof(struct capwap_80211_supportedrates_element));
supportedrates->radioid = radioid;
for (i = 0; i < length; i++) {
struct json_object* jsonvalue = json_object_array_get_idx(jsonparent, i);
if (jsonvalue && (json_object_get_type(jsonvalue) == json_type_int)) {
supportedrates->supportedratescount++;
supportedrates->supportedrates[i] = (uint8_t)json_object_get_int(jsonvalue);
}
}
return supportedrates;
}
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;
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 16) {
capwap_logging_debug("Invalid IEEE 802.11 MAC Operation element");
return NULL;
}
/* */
data = (struct capwap_80211_macoperation_element*)capwap_alloc(sizeof(struct capwap_80211_macoperation_element));
memset(data, 0, sizeof(struct capwap_80211_macoperation_element));
/* Retrieve data */
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;
}
static void* capwap_radioadmstate_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_radioadmstate_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 2) {
log_printf(LOG_DEBUG, "Invalid Radio Administrative State element: underbuffer");
return NULL;
}
/* Retrieve data */
data = (struct capwap_radioadmstate_element*)capwap_alloc(sizeof(struct capwap_radioadmstate_element));
func->read_u8(handle, &data->radioid);
func->read_u8(handle, &data->state);
if (!IS_VALID_RADIOID(data->radioid)) {
capwap_radioadmstate_element_free((void*)data);
log_printf(LOG_DEBUG, "Invalid Radio Administrative State element: invalid radioid");
return NULL;
} else if ((data->state != CAPWAP_RADIO_ADMIN_STATE_ENABLED) && (data->state != CAPWAP_RADIO_ADMIN_STATE_DISABLED)) {
capwap_radioadmstate_element_free((void*)data);
log_printf(LOG_DEBUG, "Invalid Radio Administrative State element: invalid state");
return NULL;
}
return data;
}
static void* capwap_80211_station_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_80211_station_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if (length < 14) {
capwap_logging_debug("Invalid IEEE 802.11 Station element");
return NULL;
}
length -= 13;
if (length > CAPWAP_STATION_RATES_MAXLENGTH) {
capwap_logging_debug("Invalid IEEE 802.11 Station element");
return NULL;
}
/* */
data = (struct capwap_80211_station_element*)capwap_alloc(sizeof(struct capwap_80211_station_element));
memset(data, 0, sizeof(struct capwap_80211_station_element));
/* Retrieve data */
func->read_u8(handle, &data->radioid);
func->read_u16(handle, &data->associationid);
func->read_u8(handle, &data->flags);
func->read_block(handle, data->address, MACADDRESS_EUI48_LENGTH);
func->read_u16(handle, &data->capabilities);
func->read_u8(handle, &data->wlanid);
data->supportedratescount = length;
func->read_block(handle, data->supportedrates, length);
return data;
}
static int ac_execute_init_fdspool(struct ac_fds* fds, struct capwap_network* net, int fdmsgqueue) {
ASSERT(fds != NULL);
ASSERT(net != NULL);
ASSERT(fdmsgqueue > 0);
/* */
memset(fds, 0, sizeof(struct ac_fds));
fds->fdsnetworkcount = capwap_network_set_pollfd(net, NULL, 0);
fds->msgqueuecount = 1;
fds->fdspoll = (struct pollfd*)capwap_alloc(sizeof(struct pollfd) * (fds->fdsnetworkcount + fds->msgqueuecount));
/* Retrive all socket for polling */
fds->fdstotalcount = capwap_network_set_pollfd(net, fds->fdspoll, fds->fdsnetworkcount);
if (fds->fdsnetworkcount != fds->fdstotalcount) {
capwap_free(fds->fdspoll);
return -1;
}
/* Unix socket message queue */
fds->msgqueuestartpos = fds->fdsnetworkcount;
fds->fdspoll[fds->msgqueuestartpos].events = POLLIN | POLLERR | POLLHUP | POLLNVAL;
fds->fdspoll[fds->msgqueuestartpos].fd = fdmsgqueue;
fds->fdstotalcount += fds->msgqueuecount;
return ac_execute_update_fdspool(fds);
}
static void* capwap_80211_updatestationqos_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
int i;
struct capwap_80211_updatestationqos_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 14) {
capwap_logging_debug("Invalid IEEE 802.11 Update Station QoS element");
return NULL;
}
/* */
data = (struct capwap_80211_updatestationqos_element*)capwap_alloc(sizeof(struct capwap_80211_updatestationqos_element));
memset(data, 0, sizeof(struct capwap_80211_updatestationqos_element));
/* Retrieve data */
func->read_u8(handle, &data->radioid);
func->read_block(handle, data->address, MACADDRESS_EUI48_LENGTH);
for (i = 0; i < CAPWAP_UPDATE_STATION_QOS_SUBELEMENTS; i++) {
func->read_u8(handle, &data->qos[i].priority8021p);
data->qos[i].priority8021p &= CAPWAP_UPDATE_STATION_QOS_PRIORIY_MASK;
func->read_u8(handle, &data->qos[i].dscp);
data->qos[i].dscp &= CAPWAP_UPDATE_STATION_QOS_DSCP_MASK;
}
return data;
}
static void* ac_json_80211_wtpradiofailalarm_createmessageelement(struct json_object* jsonparent, uint16_t radioid) {
struct json_object* jsonitem;
struct capwap_80211_wtpradiofailalarm_element* wtpradiofailalarm;
wtpradiofailalarm = (struct capwap_80211_wtpradiofailalarm_element*)capwap_alloc(sizeof(struct capwap_80211_wtpradiofailalarm_element));
memset(wtpradiofailalarm, 0, sizeof(struct capwap_80211_wtpradiofailalarm_element));
wtpradiofailalarm->radioid = radioid;
/* */
jsonitem = compat_json_object_object_get(jsonparent, "Type");
if (jsonitem && (json_object_get_type(jsonitem) == json_type_int)) {
wtpradiofailalarm->type = (uint8_t)json_object_get_int(jsonitem);
} else {
capwap_free(wtpradiofailalarm);
return NULL;
}
/* */
jsonitem = compat_json_object_object_get(jsonparent, "Status");
if (jsonitem && (json_object_get_type(jsonitem) == json_type_int)) {
wtpradiofailalarm->status = (uint8_t)json_object_get_int(jsonitem);
} else {
capwap_free(wtpradiofailalarm);
return NULL;
}
return wtpradiofailalarm;
}
static void* ac_json_80211_ofdmcontrol_createmessageelement(struct json_object* jsonparent, uint16_t radioid) {
struct json_object* jsonitem;
struct capwap_80211_ofdmcontrol_element* ofdmcontrol;
ofdmcontrol = (struct capwap_80211_ofdmcontrol_element*)capwap_alloc(sizeof(struct capwap_80211_ofdmcontrol_element));
memset(ofdmcontrol, 0, sizeof(struct capwap_80211_ofdmcontrol_element));
ofdmcontrol->radioid = radioid;
/* */
jsonitem = compat_json_object_object_get(jsonparent, "CurrentChan");
if (jsonitem && (json_object_get_type(jsonitem) == json_type_int)) {
ofdmcontrol->currentchannel = (uint8_t)json_object_get_int(jsonitem);
} else {
capwap_free(ofdmcontrol);
return NULL;
}
jsonitem = compat_json_object_object_get(jsonparent, "BandSupport");
if (jsonitem && (json_object_get_type(jsonitem) == json_type_int)) {
ofdmcontrol->bandsupport = (uint8_t)json_object_get_int(jsonitem) & CAPWAP_OFDMCONTROL_BAND_MASK;
} else {
capwap_free(ofdmcontrol);
return NULL;
}
jsonitem = compat_json_object_object_get(jsonparent, "TIThreshold");
if (jsonitem && (json_object_get_type(jsonitem) == json_type_int)) {
ofdmcontrol->tithreshold = (uint32_t)json_object_get_int(jsonitem);
} else {
capwap_free(ofdmcontrol);
return NULL;
}
return ofdmcontrol;
}
void capwap_array_resize(struct capwap_array* array, unsigned long count) {
int newcount;
void* newbuffer = NULL;
ASSERT(array != NULL);
ASSERT(array->itemsize > 0);
if (array->count == count) {
return;
}
newcount = min(array->count, count);
if (count > 0) {
newbuffer = capwap_alloc(array->itemsize * count);
/* Zeroed new items */
if (array->zeroed && (count > newcount)) {
memset(newbuffer + array->itemsize * newcount, 0, array->itemsize * (count - newcount));
}
}
if (array->buffer) {
if ((newbuffer != NULL) && (newcount > 0)) {
memcpy(newbuffer, array->buffer, array->itemsize * newcount);
}
capwap_free(array->buffer);
}
array->buffer = newbuffer;
array->count = count;
}
struct capwap_list_item* capwap_itemlist_create(int size) {
void* item;
ASSERT(size > 0);
item = capwap_alloc(size);
return capwap_itemlist_create_with_item(item, size);
}
struct capwap_list* capwap_list_create(void) {
struct capwap_list* list;
list = (struct capwap_list*)capwap_alloc(sizeof(struct capwap_list));
memset(list, 0, sizeof(struct capwap_list));
return list;
}
struct capwap_hash* capwap_hash_create(unsigned long hashsize) {
unsigned long size;
struct capwap_hash* hash;
ASSERT(hashsize > 0);
/* */
hash = (struct capwap_hash*)capwap_alloc(sizeof(struct capwap_hash));
hash->hashsize = hashsize;
hash->count = 0;
size = sizeof(struct capwap_hash_item*) * hashsize;
hash->items = (struct capwap_hash_item**)capwap_alloc(size);
memset(hash->items, 0, size);
return hash;
}
static void* capwap_imagedata_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_imagedata_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if (length < 1) {
log_printf(LOG_DEBUG, "Invalid Image Data element: underbuffer");
return NULL;
}
length -= 1;
/* */
data = (struct capwap_imagedata_element*)capwap_alloc(sizeof(struct capwap_imagedata_element));
memset(data, 0, sizeof(struct capwap_imagedata_element));
/* Retrieve data */
func->read_u8(handle, &data->type);
if ((data->type != CAPWAP_IMAGEDATA_TYPE_DATA_IS_INCLUDED) && (data->type != CAPWAP_IMAGEDATA_TYPE_DATA_EOF) && (data->type != CAPWAP_IMAGEDATA_TYPE_ERROR)) {
capwap_imagedata_element_free((void*)data);
log_printf(LOG_DEBUG, "Invalid Image Data element: underbuffer: invalid type");
return NULL;
} else if ((data->type == CAPWAP_IMAGEDATA_TYPE_ERROR) && (length > 0)) {
capwap_imagedata_element_free((void*)data);
log_printf(LOG_DEBUG, "Invalid Image Data element: underbuffer: invalid error type");
return NULL;
} else if (length > CAPWAP_IMAGEDATA_DATA_MAX_LENGTH) {
capwap_imagedata_element_free((void*)data);
log_printf(LOG_DEBUG, "Invalid Image Data element: underbuffer: invalid length");
return NULL;
}
data->length = length;
if (!length) {
data->data = NULL;
} else {
data->data = (uint8_t*)capwap_alloc(length);
func->read_block(handle, data->data, length);
}
return data;
}
static void* capwap_addmacacl_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_addmacacl_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if (length < 8) {
log_printf(LOG_DEBUG, "Invalid Add MAC ACL Entry element: underbuffer");
return NULL;
}
length -= 2;
/* */
data = (struct capwap_addmacacl_element*)capwap_alloc(sizeof(struct capwap_addmacacl_element));
memset(data, 0, sizeof(struct capwap_addmacacl_element));
/* Retrieve data */
func->read_u8(handle, &data->entry);
func->read_u8(handle, &data->length);
if (!data->entry) {
capwap_addmacacl_element_free((void*)data);
log_printf(LOG_DEBUG, "Invalid Add MAC ACL Entry element: invalid entry");
return NULL;
} else if (!IS_VALID_MACADDRESS_LENGTH(data->length)) {
capwap_addmacacl_element_free((void*)data);
log_printf(LOG_DEBUG, "Invalid Add MAC ACL Entry element: invalid length");
return NULL;
}
if (length != (data->entry * data->length)) {
capwap_addmacacl_element_free((void*)data);
log_printf(LOG_DEBUG, "Invalid Add MAC ACL Entry element: invalid total length");
return NULL;
}
data->address = (uint8_t*)capwap_alloc(length);
func->read_block(handle, data->address, length);
return data;
}
static void* capwap_datatransferdata_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_datatransferdata_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if (length < 5) {
log_printf(LOG_DEBUG, "Invalid Data Transfer Data element: underbuffer");
return NULL;
}
length -= 4;
/* */
data = (struct capwap_datatransferdata_element*)capwap_alloc(sizeof(struct capwap_datatransferdata_element));
memset(data, 0, sizeof(struct capwap_datatransferdata_element));
/* Retrieve data */
func->read_u8(handle, &data->type);
func->read_u8(handle, &data->mode);
func->read_u16(handle, &data->length);
if ((data->type != CAPWAP_DATATRANSFERDATA_TYPE_DATA_IS_INCLUDED) && (data->type != CAPWAP_DATATRANSFERDATA_TYPE_DATA_EOF) && (data->type != CAPWAP_DATATRANSFERDATA_TYPE_ERROR)) {
capwap_datatransferdata_element_free((void*)data);
log_printf(LOG_DEBUG, "Invalid Data Transfer Data element: invalid type");
return NULL;
} else if ((data->mode != CAPWAP_DATATRANSFERDATA_MODE_CRASH_DUMP) && (data->mode != CAPWAP_DATATRANSFERDATA_MODE_MEMORY_DUMP)) {
capwap_datatransferdata_element_free((void*)data);
log_printf(LOG_DEBUG, "Invalid Data Transfer Data element: invalid mode");
return NULL;
} else if (length != data->length) {
capwap_datatransferdata_element_free((void*)data);
log_printf(LOG_DEBUG, "Invalid Data Transfer Data element: invalid length");
return NULL;
}
data->data = (uint8_t*)capwap_alloc(length);
func->read_block(handle, data->data, length);
return data;
}
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;
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if ((length < 1) || (length > CAPWAP_LOCATION_MAXLENGTH)) {
capwap_logging_debug("Invalid Location Data element: underbuffer");
return NULL;
}
/* Retrieve data */
data = (struct capwap_location_element*)capwap_alloc(sizeof(struct capwap_location_element));
data->value = (uint8_t*)capwap_alloc(length + 1);
func->read_block(handle, data->value, length);
data->value[length] = 0;
return data;
}
struct capwap_list_item* capwap_itemlist_create_with_item(void* item, int size) {
struct capwap_list_item* itemlist;
itemlist = (struct capwap_list_item*)capwap_alloc(sizeof(struct capwap_list_item));
memset(itemlist, 0, sizeof(struct capwap_list_item));
itemlist->item = item;
itemlist->itemsize = size;
itemlist->autodelete = 1;
return itemlist;
}
static void* capwap_duplicateipv6_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
unsigned short length;
struct capwap_duplicateipv6_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
length = func->read_ready(handle);
if (length < 24) {
log_printf(LOG_DEBUG, "Invalid Duplicate IPv6 Address element: underbuffer");
return NULL;
}
length -= 18;
/* */
data = (struct capwap_duplicateipv6_element*)capwap_alloc(sizeof(struct capwap_duplicateipv6_element));
memset(data, 0, sizeof(struct capwap_duplicateipv6_element));
/* Retrieve data */
func->read_block(handle, (uint8_t*)&data->address, sizeof(struct in6_addr));
func->read_u8(handle, &data->status);
func->read_u8(handle, &data->length);
if ((data->status != CAPWAP_DUPLICATEIPv6_CLEARED) && (data->status != CAPWAP_DUPLICATEIPv6_DETECTED)) {
capwap_duplicateipv6_element_free((void*)data);
log_printf(LOG_DEBUG, "Invalid Duplicate IPv6 Address element: invalid status");
return NULL;
} else if (!IS_VALID_MACADDRESS_LENGTH(data->length) || (length != data->length)) {
capwap_duplicateipv6_element_free((void*)data);
log_printf(LOG_DEBUG, "Invalid Duplicate IPv6 Address element: invalid length");
return NULL;
}
data->macaddress = (uint8_t*)capwap_alloc(data->length);
func->read_block(handle, data->macaddress, data->length);
return data;
}
static void* capwap_80211_antenna_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
int i;
uint8_t count;
unsigned short length;
struct capwap_80211_antenna_element* data;
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;
}
length -= 4;
if (length > CAPWAP_ANTENNASELECTIONS_MAXLENGTH) {
capwap_logging_debug("Invalid IEEE 802.11 Antenna element");
return NULL;
}
/* */
data = (struct capwap_80211_antenna_element*)capwap_alloc(sizeof(struct capwap_80211_antenna_element));
memset(data, 0, sizeof(struct capwap_80211_antenna_element));
data->selections = capwap_array_create(sizeof(uint8_t), 0, 1);
/* Retrieve data */
func->read_u8(handle, &data->radioid);
if (!IS_VALID_RADIOID(data->radioid)) {
capwap_80211_antenna_element_free((void*)data);
capwap_logging_debug("Invalid IEEE 802.11 Antenna element element: invalid radio");
return NULL;
}
func->read_u8(handle, &data->diversity);
func->read_u8(handle, &data->combiner);
func->read_u8(handle, &count);
/* Check */
if (count != length) {
capwap_logging_debug("Invalid IEEE 802.11 Antenna element");
capwap_free(data);
return NULL;
}
for (i = 0; i < count; i++) {
func->read_u8(handle, (uint8_t*)capwap_array_get_item_pointer(data->selections, i));
}
return data;
}
static struct capwap_hash_item* capwap_hash_create_item(struct capwap_hash* hash, void* data) {
struct capwap_hash_item* item;
ASSERT(hash != NULL);
ASSERT(data != NULL);
/* */
item = (struct capwap_hash_item*)capwap_alloc(sizeof(struct capwap_hash_item));
memset(item, 0, sizeof(struct capwap_hash_item));
item->data = data;
return item;
}
struct capwap_array* capwap_array_create(unsigned short itemsize, unsigned long initcount, int zeroed) {
struct capwap_array* array;
ASSERT(itemsize > 0);
array = (struct capwap_array*)capwap_alloc(sizeof(struct capwap_array));
memset(array, 0, sizeof(struct capwap_array));
array->itemsize = itemsize;
array->zeroed = zeroed;
if (initcount > 0) {
capwap_array_resize(array, initcount);
}
return array;
}
static void* capwap_localipv4_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_localipv4_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 4) {
log_printf(LOG_DEBUG, "Invalid Local IPv4 Address element: underbuffer");
return NULL;
}
/* Retrieve data */
data = (struct capwap_localipv4_element*)capwap_alloc(sizeof(struct capwap_localipv4_element));
func->read_block(handle, (uint8_t*)&data->address, sizeof(struct in_addr));
return data;
}
char* ac_get_printable_wtpid(struct capwap_wtpboarddata_element* wtpboarddata) {
char* wtpid = NULL;
struct capwap_wtpboarddata_board_subelement* wtpboarddatamacaddress;
ASSERT(wtpboarddata != NULL);
/* TODO: build printable wtpid depending on the model device */
/* Get macaddress */
wtpboarddatamacaddress = capwap_wtpboarddata_get_subelement(wtpboarddata, CAPWAP_BOARD_SUBELEMENT_MACADDRESS);
if (wtpboarddatamacaddress != NULL) {
wtpid = capwap_alloc(((wtpboarddatamacaddress->length == MACADDRESS_EUI48_LENGTH) ? CAPWAP_MACADDRESS_EUI48_BUFFER : CAPWAP_MACADDRESS_EUI64_BUFFER));
capwap_printf_macaddress(wtpid, (unsigned char*)wtpboarddatamacaddress->data, wtpboarddatamacaddress->length);
}
return wtpid;
}
static void* capwap_idletimeout_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_idletimeout_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 4) {
log_printf(LOG_DEBUG, "Invalid Idle Timeout element: underbuffer");
return NULL;
}
/* Retrieve data */
data = (struct capwap_idletimeout_element*)capwap_alloc(sizeof(struct capwap_idletimeout_element));
func->read_u32(handle, &data->timeout);
return data;
}
static void* capwap_maximumlength_element_parsing(capwap_message_elements_handle handle, struct capwap_read_message_elements_ops* func) {
struct capwap_maximumlength_element* data;
ASSERT(handle != NULL);
ASSERT(func != NULL);
if (func->read_ready(handle) != 2) {
capwap_logging_debug("Invalid Maxium Message Length element: underbuffer");
return NULL;
}
/* Retrieve data */
data = (struct capwap_maximumlength_element*)capwap_alloc(sizeof(struct capwap_maximumlength_element));
func->read_u16(handle, &data->length);
return data;
}
struct capwap_timeout* capwap_timeout_init(void) {
struct capwap_timeout* timeout;
/* */
timeout = (struct capwap_timeout*)capwap_alloc(sizeof(struct capwap_timeout));
memset(timeout, 0, sizeof(struct capwap_timeout));
/* */
timeout->itemsreference = capwap_hash_create(CAPWAP_TIMEOUT_HASH_COUNT);
timeout->itemsreference->item_gethash = capwap_timeout_hash_item_gethash;
timeout->itemsreference->item_getkey = capwap_timeout_hash_item_getkey;
timeout->itemsreference->item_cmp = capwap_timeout_hash_item_cmp;
timeout->itemstimeout = capwap_list_create();
return timeout;
}
