/** @file wlan_mac_bss_info.c
 *  @brief BSS Info Subsystem
 *
 *  This contains code tracking BSS information. It also contains code for managing
 *  the active scan state machine.
 *
 *  @copyright Copyright 2014-2019, Mango Communications. All rights reserved.
 *          Distributed under the Mango Communications Reference Design License
 *              See LICENSE.txt included in the design archive or
 *              at http://mangocomm.com/802.11/license
 *
 *  This file is part of the Mango 802.11 Reference Design (https://mangocomm.com/802.11)
 */

/***************************** Include Files *********************************/

#include "wlan_mac_high_sw_config.h"

#include "xil_types.h"
#include "stdlib.h"
#include "stdio.h"
#include "wlan_platform_common.h"
#include "wlan_platform_high.h"
#include "xparameters.h"
#include "string.h"

#include "wlan_mac_pkt_buf_util.h"
#include "wlan_mac_high.h"
#include "wlan_mac_network_info.h"
#include "wlan_mac_station_info.h"
#include "wlan_mac_dl_list.h"
#include "wlan_mac_802_11_defs.h"
#include "wlan_mac_schedule.h"
#include "wlan_mac_mgmt_tags.h"
#include "wlan_mac_packet_types.h"
#include "wlan_mac_common.h"
#include "wlan_mac_queue.h"

/*********************** Global Variable Definitions *************************/

extern platform_high_dev_info_t platform_high_dev_info;
extern volatile function_ptr_t tx_queue_state_change_callback; ///< User callback for Tx queue state changes

/*************************** Variable Definitions ****************************/

/// The network_info_list is stored chronologically from .first being oldest
/// and .last being newest. The "find" function search from last to first
/// to minimize search time for new BSSes you hear from often.
static dl_list               network_info_list; ///< Filled network info
static dl_list               network_info_free;	///< Available network info
static dl_list               network_info_matching_ssid_list; ///< Filled network info that match the SSID provided to wlan_mac_high_find_network_info_SSID


/*************************** Functions Prototypes ****************************/

network_info_entry_t* wlan_mac_high_find_network_info_oldest();


/******************************** Functions **********************************/

void network_info_init() {

	u32 i;
	u32 num_network_info;
	network_info_entry_t* network_info_entry_base;

	dl_list_init(&network_info_free);
	dl_list_init(&network_info_list);
	dl_list_init(&network_info_matching_ssid_list);

	// Clear the memory in the dram used for bss_infos
	bzero((void*)BSS_INFO_BUFFER_BASE, BSS_INFO_BUFFER_SIZE);

	// The number of BSS info elements we can initialize is limited by the smaller of two values:
	//     (1) The number of network_info_entry_t structs we can squeeze into BSS_INFO_DL_ENTRY_MEM_SIZE
	//     (2) The number of bss_info structs we can squeeze into BSS_INFO_BUFFER_SIZE
	num_network_info = WLAN_MIN(BSS_INFO_DL_ENTRY_MEM_SIZE/sizeof(network_info_entry_t), BSS_INFO_BUFFER_SIZE/sizeof(network_info_t));

	// At boot, every dl_entry buffer descriptor is free
	// To set up the doubly linked list, we exploit the fact that we know the starting state is sequential.
	// This matrix addressing is not safe once the queue is used. The insert/remove helper functions should be used
	network_info_entry_base = (network_info_entry_t*)(BSS_INFO_DL_ENTRY_MEM_BASE);

	for (i = 0; i < num_network_info; i++) {
		network_info_entry_base[i].data = (void*)(BSS_INFO_BUFFER_BASE + (i*sizeof(network_info_t)));
		dl_entry_insertEnd(&network_info_free, (dl_entry*)&(network_info_entry_base[i]));
	}

	xil_printf("Network Info list (len %d) placed in DRAM: using %d kB\n", num_network_info, (num_network_info*sizeof(network_info_t))/1024);

	return;
}



void network_info_init_finish(){
	//Will be called after interrupts have been started. Safe to use scheduler now.
	wlan_mac_schedule_add_event(SCHEDULE_ID_COARSE, 10000000, SCHEDULE_REPEAT_FOREVER, (void*)network_info_timestamp_check);
}



inline void network_info_rx_process(void* pkt_buf_addr) {

	rx_frame_info_t* rx_frame_info = (rx_frame_info_t*)pkt_buf_addr;
	void* mac_payload = (u8*)pkt_buf_addr + PHY_RX_PKT_BUF_MPDU_OFFSET;
	u8* mac_payload_ptr_u8 = (u8*)mac_payload;
	char* ssid;
	u8 ssid_length;
	mac_header_80211* rx_80211_header = (mac_header_80211*)((void *)mac_payload_ptr_u8);
	network_info_entry_t* curr_network_info_entry;
	network_info_t* curr_network_info;
	u8 unicast_to_me;
	u8 to_multicast;
	u8 update_rx_power = 0;
	u8 update_timestamp = 0;
	u16 length = rx_frame_info->phy_details.length;

	// Determine destination of packet
	unicast_to_me = wlan_addr_eq(rx_80211_header->address_1, get_mac_hw_addr_wlan());
	to_multicast  = wlan_addr_mcast(rx_80211_header->address_1);

	if ((rx_frame_info->flags & RX_FRAME_INFO_FLAGS_FCS_GOOD) && (unicast_to_me || to_multicast) ) {
		switch(rx_80211_header->frame_control_1) {
			case (MAC_FRAME_CTRL1_SUBTYPE_BEACON):
				update_rx_power = 1;
				update_timestamp = 1;
				/* no break */
			case (MAC_FRAME_CTRL1_SUBTYPE_PROBE_RESP):
			case (MAC_FRAME_CTRL1_SUBTYPE_ASSOC_RESP):

			curr_network_info_entry = wlan_mac_high_find_network_info_BSSID(rx_80211_header->address_3);

				if(curr_network_info_entry != NULL){
					curr_network_info = curr_network_info_entry->data;

					// Remove entry from bss_info_list; Will be added back at the bottom of the function
					dl_entry_remove(&network_info_list, (dl_entry*)curr_network_info_entry);
				} else {
					// We haven't seen this BSS ID before, so we'll attempt to checkout a new dl_entry
					// struct from the free pool
					curr_network_info_entry = network_info_checkout();

					if (curr_network_info_entry == NULL){
						// No free dl_entry!
						// We'll have to reallocate the oldest entry in the filled list
						curr_network_info_entry = wlan_mac_high_find_network_info_oldest();

						if (curr_network_info_entry != NULL) {
							dl_entry_remove(&network_info_list, (dl_entry*)curr_network_info_entry);
						} else {
							xil_printf("Cannot create network_info_t.\n");
							return;
						}
					}

					curr_network_info = curr_network_info_entry->data;

					// Clear any old information from the network info
					wlan_mac_high_clear_network_info(curr_network_info);

					// Initialize the members stations list
					dl_list_init(&(curr_network_info->members));

					// Copy BSSID into network_info_t struct
					memcpy(curr_network_info->bss_config.bssid, rx_80211_header->address_3, MAC_ADDR_LEN);

					// Copy BSSID into network_info_entry_t struct
					memcpy(curr_network_info_entry->bssid, rx_80211_header->address_3, MAC_ADDR_LEN);

				}

				// Move the packet pointer to after the header
				mac_payload_ptr_u8 += sizeof(mac_header_80211);

				if((rx_80211_header->frame_control_1 == MAC_FRAME_CTRL1_SUBTYPE_BEACON) || (rx_80211_header->frame_control_1 == MAC_FRAME_CTRL1_SUBTYPE_PROBE_RESP)){
					//Set values to zero that will be updated when processing tags
					curr_network_info->capabilities = 0;
					curr_network_info->bss_config.ht_capable = 0;
					curr_network_info->bss_config.dtim_period = 0;

					// Copy beacon capabilities into bss_info struct
					//     - Only a subset of beacon capabilities are recorded
					curr_network_info->capabilities |= (((beacon_probe_frame*)mac_payload_ptr_u8)->capabilities & BSS_CAPABILITIES_BEACON_MASK);

					// Copy beacon interval into bss_info struct
					curr_network_info->bss_config.beacon_interval = ((beacon_probe_frame*)mac_payload_ptr_u8)->beacon_interval;

					// Move the packet pointer to after the beacon/probe frame
					mac_payload_ptr_u8 += sizeof(beacon_probe_frame);
				} else {
					// This must be an association response
					mac_payload_ptr_u8 += sizeof(association_response_frame);
				}

				// Copy the channel on which this packet was received into the network_info struct
				//     - chan_spec will be overwritten later in this function if a HT
				//       capabilities tag is discovered
				curr_network_info->bss_config.chan_spec.chan_pri = rx_frame_info->channel;
				curr_network_info->bss_config.chan_spec.chan_type = CHAN_TYPE_BW20;


				// Parse the tagged parameters
				while( (((u32)mac_payload_ptr_u8) - ((u32)mac_payload)) < (length - WLAN_PHY_FCS_NBYTES)) {

					// Parse each of the tags
					switch(mac_payload_ptr_u8[0]){

						//-------------------------------------------------
						case MGMT_TAG_SSID:
							// SSID parameter set
							//
							ssid        = (char*)(&(mac_payload_ptr_u8[2]));
							ssid_length = WLAN_MIN(mac_payload_ptr_u8[1],SSID_LEN_MAX);

							memcpy(curr_network_info->bss_config.ssid, ssid, ssid_length);

							// Terminate the string
							(curr_network_info->bss_config.ssid)[ssid_length] = 0;
						break;

						//-------------------------------------------------
						case MGMT_TAG_HT_CAPABILITIES:
							curr_network_info->bss_config.ht_capable = 1;
						break;

						//-------------------------------------------------
						case MGMT_TAG_HT_OPERATION:
							curr_network_info->bss_config.chan_spec.chan_pri = mac_payload_ptr_u8[2];
							if(mac_payload_ptr_u8[2] & 0x4){
								// Channel widths larger than 20MHz are supported by this BSS
								if((mac_payload_ptr_u8[2] & 0x3) == 0x3){
									//Secondary Channel is below primary channel
									curr_network_info->bss_config.chan_spec.chan_type = CHAN_TYPE_BW40_SEC_BELOW;
								} else if((mac_payload_ptr_u8[2] & 0x3) == 0x1){
									//Secondary Channel is above primary channel
									curr_network_info->bss_config.chan_spec.chan_type = CHAN_TYPE_BW40_SEC_ABOVE;
								}
							}
						break;

						//-------------------------------------------------
						case MGMT_TAG_DSSS_PARAMETER_SET:
							// DS Parameter set (e.g. channel)
							curr_network_info->bss_config.chan_spec.chan_pri = mac_payload_ptr_u8[2];
						break;

						//-------------------------------------------------
						case MGMT_TAG_TIM:
							curr_network_info->bss_config.dtim_period = mac_payload_ptr_u8[3];
						break;
					}

					// Increment packet pointer to the next tag
					mac_payload_ptr_u8 += mac_payload_ptr_u8[1]+2;
				}

				// Update the beacon Rx power
				if (update_rx_power) curr_network_info->latest_beacon_rx_power = rx_frame_info->rx_power;

				// Update the beacon timestamp
				if (update_timestamp) curr_network_info->latest_beacon_rx_time = get_system_time_usec();

				// TODO: Potential here for a application-specific callback on new BSS capabilities

				// Add network info into bss_info_list
				dl_entry_insertEnd(&network_info_list, (dl_entry*)curr_network_info_entry);
			break;


			//---------------------------------------------------------------------
			default:
                // Only need to process MAC_FRAME_CTRL1_SUBTYPE_BEACON, MAC_FRAME_CTRL1_SUBTYPE_PROBE_RESP
				// to update BSS information.
			break;
		}
	}
}



void print_network_info(){
	int iter;
	u32 i;
	network_info_entry_t* curr_network_info_entry;
	network_info_t* curr_network_info;

	i = 0;
	iter = network_info_list.length;
	curr_network_info_entry = (network_info_entry_t*)network_info_list.last;

	// Print the header
	xil_printf("************************ Network Info *************************\n");

	while ((curr_network_info_entry != NULL) && (iter-- > 0)) {
		curr_network_info = curr_network_info_entry->data;

		xil_printf("[%d] SSID:     %s ", i, curr_network_info->bss_config.ssid);

		if(curr_network_info->capabilities & BSS_CAPABILITIES_PRIVACY){
			xil_printf("(*)");
		}
		if(curr_network_info->capabilities & BSS_CAPABILITIES_IBSS){
			xil_printf("(I)");
		}
		if(curr_network_info->flags & NETWORK_FLAGS_KEEP){
			xil_printf("(my BSS)");
		}
		xil_printf("\n");

		xil_printf("    BSSID:         %02x-%02x-%02x-%02x-%02x-%02x\n", curr_network_info->bss_config.bssid[0], curr_network_info->bss_config.bssid[1],
																		 curr_network_info->bss_config.bssid[2], curr_network_info->bss_config.bssid[3],
																		 curr_network_info->bss_config.bssid[4], curr_network_info->bss_config.bssid[5]);
		xil_printf("    Channel:       %d\n", wlan_mac_high_bss_channel_spec_to_radio_chan(curr_network_info->bss_config.chan_spec));

		xil_printf("    DTIM Period:   %d\n", curr_network_info->bss_config.dtim_period);

		xil_printf("    HT Capable:    %d\n", curr_network_info->bss_config.ht_capable);

		xil_printf("    Last update:   %d msec ago\n", (u32)((get_system_time_usec() - curr_network_info->latest_beacon_rx_time)/1000));

		xil_printf("    Capabilities:  0x%04x\n", curr_network_info->capabilities);
		curr_network_info_entry = dl_entry_prev(curr_network_info_entry);
		i++;
	}
}



void network_info_timestamp_check() {
	network_info_entry_t* curr_network_info_entry;
	network_info_t* curr_network_info;
	curr_network_info_entry = (network_info_entry_t*)network_info_list.first;

	while(curr_network_info_entry != NULL){
		curr_network_info = curr_network_info_entry->data;

		if((get_system_time_usec() - curr_network_info->latest_beacon_rx_time) > NETWORK_INFO_TIMEOUT_USEC){
			if((curr_network_info->flags & NETWORK_FLAGS_KEEP) == 0){
				wlan_mac_high_clear_network_info(curr_network_info);
				dl_entry_remove(&network_info_list, (dl_entry*)curr_network_info_entry);
				network_info_checkin(curr_network_info_entry);
			}
		} else {
			// Nothing after this entry is older, so it's safe to quit
			return;
		}

		curr_network_info_entry = dl_entry_next(curr_network_info_entry);
	}
}



network_info_entry_t* network_info_checkout(){
	network_info_entry_t* network_info_entry;
	network_info_t* curr_network_info;

	if(network_info_free.length > 0){
		network_info_entry = ((network_info_entry_t*)(network_info_free.first));
		dl_entry_remove(&network_info_free,network_info_free.first);

		curr_network_info = network_info_entry->data;
		dl_list_init(&(curr_network_info->members));
		return network_info_entry;
	} else {
		return NULL;
	}
}

void network_info_checkin(network_info_entry_t* network_info_entry){
	dl_entry_insertEnd(&network_info_free, (dl_entry*)network_info_entry);
	return;
}


dl_list* wlan_mac_high_find_network_info_SSID(char* ssid){
	// This function will return a pointer to a dl_list that contains every
	// network_info_t struct that matches the SSID argument.

    int iter;
	network_info_entry_t* curr_network_info_entry_primary_list;
	network_info_entry_t* curr_network_info_entry_match_list;
	network_info_entry_t* next_network_info_entry_match_list;
	network_info_t* curr_network_info;

	// Remove/free any members of network_info_matching_ssid_list that exist since the last time
	// this function was called

	iter = network_info_matching_ssid_list.length;
	curr_network_info_entry_match_list = (network_info_entry_t*)network_info_matching_ssid_list.first;

	while ((curr_network_info_entry_match_list != NULL) && (iter-- > 0)) {
		next_network_info_entry_match_list = dl_entry_next(curr_network_info_entry_match_list);
		dl_entry_remove(&network_info_matching_ssid_list, (dl_entry*)curr_network_info_entry_match_list);
		wlan_mac_high_free(curr_network_info_entry_match_list);
		curr_network_info_entry_match_list = next_network_info_entry_match_list;
	}

	// At this point in the code, network_info_matching_ssid_list is guaranteed to be empty.
	// We will fill it with new network_info_entry_t that point to existing network_info_t structs that
	// match the SSID argument to this function. Note: these network_info_t structs will continue
	// to be pointed to by the existing network_info_entry_t

	iter = network_info_list.length;
	curr_network_info_entry_primary_list = (network_info_entry_t*)network_info_list.last;

	while ((curr_network_info_entry_primary_list != NULL) && (iter-- > 0)) {
		curr_network_info = curr_network_info_entry_primary_list->data;

		if (strcmp(ssid, curr_network_info->bss_config.ssid) == 0) {
			curr_network_info_entry_match_list = wlan_mac_high_malloc(sizeof(network_info_entry_t));
			curr_network_info_entry_match_list->data = curr_network_info;
			memcpy(curr_network_info_entry_match_list->bssid, curr_network_info->bss_config.bssid, MAC_ADDR_LEN);
			dl_entry_insertEnd(&network_info_matching_ssid_list, (dl_entry*)curr_network_info_entry_match_list);
		}

		curr_network_info_entry_primary_list = dl_entry_prev(curr_network_info_entry_primary_list);
	}

	return &network_info_matching_ssid_list;
}


network_info_entry_t* wlan_mac_high_find_network_info_BSSID(u8* bssid){
	int iter;
	network_info_entry_t* curr_network_info_entry;

	iter = network_info_list.length;
	curr_network_info_entry = (network_info_entry_t*)network_info_list.last;

	while ((curr_network_info_entry != NULL) && (iter-- > 0)) {
		if (wlan_addr_eq(bssid,curr_network_info_entry->bssid)) {
			return curr_network_info_entry;
		}
		curr_network_info_entry = dl_entry_prev(curr_network_info_entry);
	}
	return NULL;
}

network_info_entry_t* wlan_mac_high_find_network_info_oldest(){
	int iter;
	network_info_entry_t* curr_network_info_entry;
	network_info_t* curr_network_info;

	iter = network_info_list.length;
	curr_network_info_entry = (network_info_entry_t*)network_info_list.first;

	while ((curr_network_info_entry != NULL) && (iter-- > 0)) {
		curr_network_info = curr_network_info_entry->data;

		if ((curr_network_info->flags & NETWORK_FLAGS_KEEP) == 0) {
			return curr_network_info_entry;
		}

		curr_network_info_entry = dl_entry_next(curr_network_info_entry);
	}
	return NULL;
}



// Function will create a bss_info and make sure that the BSS ID is unique
// in the bss_info list.
//
network_info_t* wlan_mac_high_create_network_info(u8* bssid, char* ssid, u8 chan){
	network_info_entry_t* curr_network_info_entry;
	network_info_t* curr_network_info = NULL;

	curr_network_info_entry = wlan_mac_high_find_network_info_BSSID(bssid);

	if (curr_network_info_entry != NULL){
		// Get the BSS info from the entry
		curr_network_info = curr_network_info_entry->data;

		// Remove the entry from the info list so it can be added back later
		dl_entry_remove(&network_info_list, (dl_entry*)curr_network_info_entry);
	} else {
		// Have not seen this BSS ID before; attempt to grab a new network_info_entry_t
		// struct from the free pool
		curr_network_info_entry = network_info_checkout();

		if (curr_network_info_entry == NULL){
			// No free network_info_entry_t; Re-allocate the oldest entry in the filled list
			curr_network_info_entry = wlan_mac_high_find_network_info_oldest();

			if (curr_network_info_entry != NULL) {
				dl_entry_remove(&network_info_list, (dl_entry*)curr_network_info_entry);
			} else {
				xil_printf("Cannot create network_info_t.\n");
				return NULL;
			}
		}

		// Get the network_info_t from the entry
		curr_network_info = curr_network_info_entry->data;

		// Clear any old information from the network info
		wlan_mac_high_clear_network_info(curr_network_info);

		// Initialize the associated stations list
		dl_list_init(&(curr_network_info->members));

		// Copy the BSS ID to the network_info_t struct
		memcpy(curr_network_info->bss_config.bssid, bssid, MAC_ADDR_LEN);

		// Copy the BSS ID to the network_info_entry_t struct
		memcpy(curr_network_info_entry->bssid, bssid, MAC_ADDR_LEN);
	}

	// Update the fields of the BSS Info
	strncpy(curr_network_info->bss_config.ssid, ssid, SSID_LEN_MAX);
	curr_network_info->bss_config.chan_spec.chan_pri       = chan;
	curr_network_info->bss_config.chan_spec.chan_type      = CHAN_TYPE_BW20;
	curr_network_info->latest_beacon_rx_time    = get_system_time_usec();
	curr_network_info->latest_beacon_rx_power   = 127; //Maximum s8 value with unrealistic power value. This let's downstream
													   // processes know that no beacon has actually ever been received if they
													   // see this value

	//
	// The following fields have their previous value retained if the were
	// in the network list (i.e. wlan_mac_high_find_bss_info_BSSID() returned
	// a non-NULL entry):
	//    - latest_beacon_rx_power
	//    - capabilities
	//    - beacon_interval
	//    - flags
	//    - station_info_list
	//

	// Insert the updated entry into the network list
	dl_entry_insertEnd(&network_info_list, (dl_entry*)curr_network_info_entry);

	return curr_network_info;
}

/**
 * @brief Reset List of Networks
 *
 * Reset all BSS Info except ones flagged to be kept
 *
 * @param  None
 * @return None
 */
void wlan_mac_high_reset_network_list(){
	network_info_entry_t* next_network_info_entry = (network_info_entry_t*)network_info_list.first;
	network_info_entry_t* curr_network_info_entry;
    network_info_t* curr_network_info;
    int iter = network_info_list.length;

	while( (next_network_info_entry != NULL) && (iter-- > 0) ){
		curr_network_info_entry = next_network_info_entry;
		next_network_info_entry = dl_entry_next(curr_network_info_entry);
		curr_network_info = curr_network_info_entry->data;

		if( (curr_network_info->flags & NETWORK_FLAGS_KEEP) == 0){
			wlan_mac_high_clear_network_info(curr_network_info);
			dl_entry_remove(&network_info_list, (dl_entry*)curr_network_info_entry);
			network_info_checkin(curr_network_info_entry);
		}
	}
}

void wlan_mac_high_clear_network_info(network_info_t* info){
	int iter;
	station_info_t* curr_station_info;
	station_info_entry_t* next_station_info_entry;
	station_info_entry_t* curr_station_info_entry;

	if (info != NULL){
        // Remove any station infos
		iter                    = info->members.length;
		next_station_info_entry = (station_info_entry_t*)(info->members.first);

		if (((info->flags & NETWORK_FLAGS_KEEP) == 0) && (next_station_info_entry != NULL)) {
            xil_printf("WARNING:  network_info_t not flagged to be kept but contained station_info_t entries.\n");
		}

		// Set any members to ~STATION_INFO_FLAG_KEEP so the framework can remove them
		while ((next_station_info_entry != NULL) && (iter-- > 0)) {
			curr_station_info_entry = next_station_info_entry;
			next_station_info_entry = dl_entry_next(curr_station_info_entry);

			curr_station_info       = curr_station_info_entry->data;

			// Remove the "keep" flag for this station_info so the framework can cleanup later.
			curr_station_info->flags &= ~STATION_INFO_FLAG_KEEP;
			network_info_remove_member(info, curr_station_info->addr);
		}


		// Clear the bss_info
        bzero(info, sizeof(network_info_t));

        // Set beacon_interval to "unknown"
        info->bss_config.beacon_interval = BEACON_INTERVAL_UNKNOWN;
	}
}

station_info_t* network_info_add_member(network_info_t* network_info, u8* addr, u32 max_queue_size){

	// This function always:
	//  1) keeps the ID fields of each station_info_t orthogonal, starting with the value 1 and packed such that
	//     any holes are filled before larger IDs are used.
	//  2) opens a Tx queue fo this station
	//
	//  Both of the above behaviors would need to be made optional before promiscuously adding station_info_t
	//  into non-active network_info_t

	station_info_entry_t* station_info_entry = NULL;
	station_info_t* station_info = NULL;
	s16 max_existing_ID = 0;
	s16 new_ID = 0;
	u8* ones_array;
	u32 i;

	if(network_info == NULL) return NULL;

	station_info_entry = station_info_find_by_addr(addr, &(network_info->members));

	// If we found a this station is already a member, return it.
	if(station_info_entry) return station_info_entry->data;

	// 1) Select a valid ID for this member. network_info->members is not ordered.
	//    We need to, first, find any gaps in currently used IDs and fill those. If
	//    no gaps exist, we will use an ID higher that the current maximum.
	station_info_entry = (station_info_entry_t*)(network_info->members.first);
	for(i = 0; i < network_info->members.length; i++){
		max_existing_ID = WLAN_MAX(max_existing_ID, station_info_entry->data->ID);
		station_info_entry = dl_entry_next(station_info_entry);
	}

	if(max_existing_ID > 0){
		ones_array = wlan_mac_high_malloc(max_existing_ID * sizeof(u8));

		if(ones_array){
			// Set ones_array to all ones
			memset(ones_array, 1, max_existing_ID * sizeof(u8));

			station_info_entry = (station_info_entry_t*)(network_info->members.first);
			for(i = 0; i < network_info->members.length; i++){
				if(station_info_entry->data->ID > 0){
					// Mark this ID has used
					ones_array[ (station_info_entry->data->ID) - 1 ] = 0;
				}
				station_info_entry = dl_entry_next(station_info_entry);
			}

			//Find the first unused ID in the ones_array
			for(i = 0; i < (u32)max_existing_ID; i++){
				if(ones_array[i]){
					new_ID = i+1;
					break;
				}
			}
			wlan_mac_high_free(ones_array);
		}
	}

	if(new_ID == 0){
		// If we didn't find any gaps in the existing IDs, we will use a new
		// maximum value.
		new_ID = max_existing_ID + 1;
	}

	// If not, we need to add it to the member list
	station_info = station_info_add_to_list(&(network_info->members), addr);

	if(station_info == NULL) return NULL;


	station_info->ID = new_ID;
	station_info->QID = queue_open(tx_queue_state_change_callback, new_ID, max_queue_size);

	// Initialize the latest activity timestamp
	//     NOTE:  This is so we don't run into a race condition when we try to check the association timeout
	//
	station_info->latest_rx_timestamp = get_system_time_usec();

	// Set the last received sequence number to something invalid so we don't accidentally
	// de-duplicate the next reception if that sequence number is 0.
	station_info->latest_rx_seq = 0xFFFF; //Sequence numbers are only 12 bits long. This is intentionally invalid.

	return station_info;

}

int network_info_remove_member(network_info_t* network_info, u8* addr){

	station_info_entry_t* station_info_entry;

	if(network_info == NULL) return WLAN_FAILURE;

	station_info_entry = station_info_find_by_addr(addr, &(network_info->members));

	if(station_info_entry){
		if(station_info_entry->data->QID >= 0) queue_close(station_info_entry->data->QID);
		station_info_entry->data->QID = -1;
		station_info_entry->data->ID = -1;
		station_info_remove_from_list(&(network_info->members), addr);
		return WLAN_SUCCESS;
	} else {
		return WLAN_FAILURE;
	}

}

inline dl_list* wlan_mac_high_get_network_info_list(){
	return &network_info_list;
}