#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <unistd.h>
#include <ctype.h>
#include <string.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <linux/if.h>
#include <linux/if_packet.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <semaphore.h>

#include "wl_internal.h"
#include "wl_ioctl.h"
#include "wl_debug.h"

#ifndef MAX
#define MAX(a, b) (((a) >= (b)) ? (a) : (b))
#endif

#define DHD_IOCTL_MAGIC				(0x00444944)
#define DHD_GET_VAR					2
#define DHD_SET_VAR					3

#define WL_BSSCFG_PREX_STR			"bsscfg:"

#define WL_EVENT_LIST_SIZE			(5)
/* Timeout in second for event from driver */
#define WL_EVENT_TIMEOUT 			10
#define WL_EVENT_BUF_SIZE 			2048
#define WL_REG_EVENT_ONCE_MAX		(16)

#define THREAD_CLOSE_EVENT			"CLOSE"

/* Broadcom OUI (Organizationally Unique Identifier): Used in the proprietary(221) IE (Information Element) in all Broadcom devices */
#define BRCM_OUI            		"\x00\x10\x18"
/* Length in bytes of 802.11 OUI*/
#define DOT11_OUI_LEN 				3

#define JOIN_ASSOCIATED             (uint32_t)(1 << 0)
#define JOIN_AUTHENTICATED          (uint32_t)(1 << 1)
#define JOIN_LINK_READY             (uint32_t)(1 << 2)
#define JOIN_SECURITY_COMPLETE      (uint32_t)(1 << 3)
#define JOIN_SSID_SET               (uint32_t)(1 << 4)
#define JOIN_NO_NETWORKS            (uint32_t)(1 << 5)
#define JOIN_EAPOL_KEY_M1_TIMEOUT   (uint32_t)(1 << 6)
#define JOIN_EAPOL_KEY_M3_TIMEOUT   (uint32_t)(1 << 7)
#define JOIN_EAPOL_KEY_G1_TIMEOUT   (uint32_t)(1 << 8)
#define JOIN_EAPOL_KEY_FAILURE      (uint32_t)(1 << 9)
#define JOIN_COMPLETED 				(JOIN_AUTHENTICATED | JOIN_LINK_READY | JOIN_SSID_SET | JOIN_SECURITY_COMPLETE)

/* Linux network driver ioctl encoding */
typedef struct
{
	uint32_t cmd;		/**< common ioctl definition */
	void *buf;			/**< pointer to user buffer */
	uint32_t len;		/**< length of user buffer */
	uint8_t set;		/**< 1=set IOCTL; 0=query IOCTL */
	uint32_t used;		/**< bytes read or written (optional) */
	uint32_t needed;	/**< bytes needed (optional) */
	uint32_t driver;	/**< to identify target driver */
} wl_dhd_ioctl_t;

typedef struct
{
	uint8_t event_mask[WL_EVENTING_MASK_LEN];
#ifdef WL_CONFIG_CHECK_EVENT
	uint8_t reg_event_mask[WL_EVENTING_MASK_LEN];
	uint32_t is_event_set;
#endif /* WL_CONFIG_CHECK_EVENT */
	wl_event_cb_t callback;
	void* user_data;
} wl_event_item_t;

typedef enum
{
	WL_CONNECT_STATUS_DISCONNECTED = 0,
	WL_CONNECT_STATUS_DISCONNECTING,
	WL_CONNECT_STATUS_CONNECTED,
	WL_CONNECT_STATUS_CONNECTING,
} wl_connect_status_t;

static int wl_ioctl_init(const char* ifname);
static int wl_ioctl_deinit(void);
static int wl_event_init(void);
static int wl_event_deinit(void);
static void* wl_event_thread_func(void *args);
static void wl_connect_event_handler(wl_event_msg_t* msg, void* user_data);

pthread_mutex_t wl_dbg_mutex;

static int wl_ioctl_sockfd = -1;
static struct ifreq wl_ifr;
static bool wl_is_init;
static sem_t wl_connect_sem;
static pthread_mutex_t wl_mutex;
static pthread_t wl_event_thread;
static int wl_event_pipe[2];
static wl_event_item_t wl_event_list[WL_EVENT_LIST_SIZE];
static uint32_t wl_event_num;
static const uint32_t wl_connect_status_event[] = {
						WLC_E_SET_SSID,
                        WLC_E_JOIN,
                        WLC_E_LINK,
						WLC_E_AUTH,
						WLC_E_DEAUTH_IND,
						WLC_E_DISASSOC_IND,
						WLC_E_PSK_SUP
					};
static uint32_t wl_connect_status;
static uint32_t wl_join_status;

static wl_connect_status_cb_t wl_connect_status_callback;
static void *wl_connect_status_userdata;

static int wl_mkiovar(
				const char* iovar_name,
				void* param,
				int32_t paramlen,
				int8_t* iovar_buf,
				int32_t buflen)
{
    int32_t len;

    len = strlen(iovar_name) + 1;
    if ((len + paramlen) > buflen)
    {
        return WL_E_BUFTOOSHORT;
    }

    strncpy((char*)iovar_buf, iovar_name, buflen);

	if ((param != NULL) && (paramlen > 0))
	{
	    /* append data onto the end of the name string */
	    memcpy(&iovar_buf[len], param, paramlen);
	    len += paramlen;
	}

    return len;
}

static int wl_mkiovar_bsscfg(
				const char* iovar_name,
				void* param,
				int32_t paramlen,
				int8_t* iovar_buf,
				int32_t buflen,
				int32_t bssidx)
{
	const char *prefix = WL_BSSCFG_PREX_STR;
	int8_t *p;
	uint32_t prefixlen;
	uint32_t namelen;
	uint32_t iolen;

	if ((iovar_buf == NULL) || (buflen == 0))
	{
		return WL_E_BADARG;
	}

	memset(iovar_buf, 0, buflen);

	if (bssidx == 0)
	{
		return wl_mkiovar(iovar_name, param, paramlen, iovar_buf, buflen);
	}

	prefixlen = strlen(prefix);
	namelen = strlen(iovar_name) + 1;
	iolen = prefixlen + namelen + sizeof(uint32_t) + paramlen;

	if (buflen < 0 || iolen > (uint32_t)buflen)
	{
		return WL_E_BADARG;
	}

	p = iovar_buf;

	/* copy prefix, no null */
	memcpy(p, prefix, prefixlen);
	p += prefixlen;

	/* copy iovar name including null */
	memcpy(p, iovar_name, namelen);
	p += namelen;

	/* bss config index as first param */
	memcpy(p, &bssidx, sizeof(uint32_t));
	p += sizeof(uint32_t);

	/* parameter buffer follows */
	if (paramlen)
	{
		memcpy(p, param, paramlen);
	}

	return iolen;
}

int wl_ioctl(uint32_t cmd, void* buf, uint32_t len, bool set)
{
    int ret = 0;
    wl_ioctl_t ioc;

#if WL_LOG_LEVEL >= WL_LOG_DEBUG
	if (cmd == WLC_SET_VAR)
	{
        WL_DBG("SET IOVAR %s\n", (char*)buf);
	}
	else if (cmd == WLC_GET_VAR)
	{
        WL_DBG("GET IOVAR %s\n", (char*)buf);
	}
	else
	{
		WL_DBG("cmd = %d\n", cmd);
	}
#endif /* WL_LOG_LEVEL >= WL_LOG_DEBUG */

	WL_DUMP(buf, len);

	if (wl_ioctl_sockfd < 0)
	{
		WL_ERR("wl is not init\n");
		return WL_E_IOCTL_ERROR;
	}

    ioc.cmd = cmd;
    ioc.buf = buf;
    ioc.len = len;
    ioc.set = set;
    wl_ifr.ifr_data = (caddr_t)&ioc;

	ret = ioctl(wl_ioctl_sockfd, SIOCDEVPRIVATE, &wl_ifr);

    if (ret < 0) {
#if WL_LOG_LEVEL >= WL_LOG_DEBUG
        if ((cmd != WLC_GET_VAR) || (strncmp(buf, "bcmerrorstr", strlen("bcmerrorstr") != 0)))
        {
    		char buf[128];

    		memset(buf, 0, sizeof(buf));


    		wl_iovar_get("bcmerrorstr", buf, sizeof(buf));

            WL_ERR("ioctl err = %d, bcmerror = %s\n", ret, buf);
        }
#else /* WL_LOG_LEVEL >= WL_LOG_DEBUG */
        WL_ERR("ioctl err = %d\n", ret);
#endif /* WL_LOG_LEVEL >= WL_LOG_DEBUG */

		return WL_E_IOCTL_ERROR;
    }

	return WL_E_OK;
}

int wl_iovar_getbuf(
		const char* iovar_name,
		void* param,
		int32_t paramlen,
		int8_t* iovar_buf,
		int32_t buflen)
{
    int ret;

    ret = wl_mkiovar(
				iovar_name,
		        param,
		        paramlen,
		        iovar_buf,
		        buflen);

	if (ret > 0)
	{
		ret = wl_ioctl(WLC_GET_VAR, iovar_buf, buflen, false);
	}

    return ret;
}

int wl_iovar_setbuf(
		const char* iovar_name,
		void* param,
		int32_t paramlen,
		int8_t* iovar_buf,
		int32_t buflen)
{
    int ret;

    ret = wl_mkiovar(
				iovar_name,
		        param,
		        paramlen,
		        iovar_buf,
		        buflen);

	if (ret > 0)
	{
		ret = wl_ioctl(WLC_SET_VAR, iovar_buf, ret, true);
	}

    return ret;
}

int wl_iovar_get(const char* iovar_name, void* outbuf, int32_t len)
{
	int ret;
	int8_t smbuf[WLC_IOCTL_SMLEN];

	/* use the return buffer if it is bigger than what we have on the stack */
	if (len > WLC_IOCTL_SMLEN)
	{
		ret = wl_iovar_getbuf(iovar_name, NULL, 0, outbuf, len);
	}
	else
	{
		memset(smbuf, 0, sizeof(smbuf));

		ret = wl_iovar_getbuf(
					iovar_name,
					NULL,
					0,
					smbuf,
					sizeof(smbuf));

		if (ret == 0)
		{
			memcpy(outbuf, smbuf, len);
		}
	}

	return ret;
}

int wl_iovar_set(const char* iovar_name, void* param, int32_t paramlen)
{
	int8_t smbuf[WLC_IOCTL_SMLEN * 2];

	memset(smbuf, 0, sizeof(smbuf));

	return wl_iovar_setbuf(
				iovar_name,
				param,
				paramlen,
				smbuf,
				sizeof(smbuf));
}

int wl_iovar_getint(const char* iovar_name, int32_t* pval)
{
	return wl_iovar_get(iovar_name, pval, sizeof(int32_t));
}

int wl_iovar_setint(const char* iovar_name, int32_t val)
{
	return wl_iovar_set(iovar_name, &val, sizeof(int32_t));
}

int wl_iovar_bsscfg_getbuf(
	    const char* iovar_name,
	    void* param,
	    int32_t paramlen,
	    void* iovar_buf,
	    int32_t buflen,
	    int32_t bsscfg_idx)
{
	int ret = 0;

	wl_mkiovar_bsscfg(iovar_name, param, paramlen, iovar_buf, buflen, bsscfg_idx);

	ret = wl_ioctl(WLC_GET_VAR, iovar_buf, buflen, false);

	return ret;
}

int wl_iovar_bsscfg_setbuf(
        const char*iovar_name,
	    void* param,
	    int32_t paramlen,
	    void* iovar_buf,
	    int32_t buflen,
	    int32_t bsscfg_idx)
{
	int ret = 0;
	int32_t iovar_len;

	iovar_len = wl_mkiovar_bsscfg(iovar_name, param, paramlen, iovar_buf, buflen, bsscfg_idx);

    if (iovar_len > 0)
		ret = wl_ioctl(WLC_SET_VAR, iovar_buf, iovar_len, true);
	else {
		ret = WL_E_BUFTOOSHORT;
	}

	return ret;
}

int wl_iovar_bsscfg_get(
		const char* iovar_name,
		void* outbuf,
		int32_t len,
		int32_t bsscfg_idx)
{
	int ret;
	int8_t smbuf[WLC_IOCTL_SMLEN];

	/* use the return buffer if it is bigger than what we have on the stack */
	if (len > WLC_IOCTL_SMLEN)
	{
		ret = wl_iovar_bsscfg_getbuf(iovar_name, NULL, 0, outbuf, len, bsscfg_idx);
	}
	else
	{
		memset(smbuf, 0, sizeof(smbuf));

		ret = wl_iovar_bsscfg_getbuf(
					iovar_name,
					NULL,
					0,
					smbuf,
					sizeof(smbuf),
					bsscfg_idx);

		if (ret == 0)
		{
			memcpy(outbuf, smbuf, len);
		}
	}

	return ret;
}

int wl_iovar_bsscfg_set(
		const char* iovar_name,
		void* param,
		int32_t paramlen,
		int32_t bsscfg_idx)
{
	int8_t smbuf[WLC_IOCTL_SMLEN * 2];

	memset(smbuf, 0, sizeof(smbuf));

	return wl_iovar_bsscfg_setbuf(
				iovar_name,
				param,
				paramlen,
				smbuf,
				sizeof(smbuf),
				bsscfg_idx);
}

int wl_iovar_bsscfg_getint(
		const char*iovar_name,
		int32_t* pval,
		int32_t bsscfg_idx)
{
	return wl_iovar_bsscfg_get(iovar_name, pval, sizeof(int32_t), bsscfg_idx);
}

int wl_iovar_bsscfg_setint(
	    const char* iovar_name,
	    int32_t val,
	    int32_t bsscfg_idx)
{
	return wl_iovar_bsscfg_set(iovar_name, &val, sizeof(int32_t), bsscfg_idx);
}

int wl_dhd_iovar_setint(const char* iovar_name, int32_t val)
{
    int ret = 0;
    wl_dhd_ioctl_t ioc;
	int8_t iovar_buf[WLC_IOCTL_SMLEN];
    int32_t len;

	if (wl_ioctl_sockfd < 0)
	{
		WL_ERR("wl is not init\n");
		return WL_E_IOCTL_ERROR;
	}

    WL_DBG("IOVAR %s\n", (char*)iovar_name);

	memset(iovar_buf, 0, WLC_IOCTL_SMLEN);

    len = strlen(iovar_name) + 1;

	if ((len + sizeof(int32_t)) > WLC_IOCTL_SMLEN)
	{
		return WL_E_BUFTOOSHORT;
	}

    strncpy((char*)iovar_buf, iovar_name, WLC_IOCTL_SMLEN);
    memcpy(&iovar_buf[len], &val, sizeof(int32_t));
    len += sizeof(int32_t);

    ioc.cmd = DHD_SET_VAR;
    ioc.buf = iovar_buf;
    ioc.len = len;
    ioc.set = true;
	ioc.driver = DHD_IOCTL_MAGIC;
    wl_ifr.ifr_data = (caddr_t)&ioc;

	ret = ioctl(wl_ioctl_sockfd, SIOCDEVPRIVATE, &wl_ifr);

    if (ret < 0) {
		return WL_E_IOCTL_ERROR;
    }

	return WL_E_OK;
}

int wl_init(const char* ifname)
{
	int ret;
	wl_ether_addr_t bssid;

	pthread_mutex_init(&wl_dbg_mutex, NULL);

	WL_DBG("ifname = %s\n", ifname);

	if (wl_is_init)
	{
		WL_INFO("already init\n");
		return WL_E_OK;
	}

	ret = wl_ioctl_init(ifname);

	if (ret != WL_E_OK)
	{
		return ret;
	}

	ret = wl_get_bssid(&bssid);

	if (ret == 0)
	{
	#ifdef WL_FIX_CONNECT_STATUS_OPTIONS
		uint32_t wakeind = 0;
	
		ret = wl_wowl_get_wakeind(&wakeind);

		if ((ret == WL_E_OK) && (wakeind & WL_WOWL_DIS))
		{
			wl_connect_status = WL_CONNECT_STATUS_DISCONNECTED;
		}
		else
		{
			wl_connect_status = WL_CONNECT_STATUS_CONNECTED;
            wl_join_status = JOIN_COMPLETED;
		}
	#else /* WL_FIX_CONNECT_STATUS_OPTIONS */
		wl_connect_status = WL_CONNECT_STATUS_CONNECTED;
        wl_join_status = JOIN_COMPLETED;
	#endif /* WL_FIX_CONNECT_STATUS_OPTIONS */	
	}
	else
	{
		wl_connect_status = WL_CONNECT_STATUS_DISCONNECTED;
	}

	ret = wl_event_init();

	if (ret != WL_E_OK)
	{
		wl_ioctl_deinit();
	}

	pthread_mutex_init(&wl_mutex, NULL);
	sem_init(&wl_connect_sem, 0, 0);

	wl_is_init = true;

    return ret;
}

int wl_deinit(void)
{
	WL_DBG("enter\n");

	wl_event_deinit();
	wl_ioctl_deinit();
	pthread_mutex_destroy(&wl_mutex);
	sem_destroy(&wl_connect_sem);
	pthread_mutex_destroy(&wl_dbg_mutex);
	wl_is_init = false;

	return 0;
}

bool wl_is_associated(void)
{
	return (wl_connect_status == WL_CONNECT_STATUS_CONNECTED);
}

int wl_error(void)
{
	int ret;
	int32_t error;

	ret = wl_iovar_getint("bcmerror", &error);

	if (ret == 0)
	{
		return error;
	}
	else
	{
		return WL_E_OK;
	}
}

static int wl_ioctl_init(const char* ifname)
{
	int ret;
	struct ifreq ifr;

	WL_DBG("ifname = %s\n", ifname);

	ret = socket(AF_INET, SOCK_DGRAM, 0);

    if (ret < 0)
	{
		WL_ERR("create socket error = %d\n", ret);
		return WL_E_IOCTL_ERROR;
    }

	wl_ioctl_sockfd = ret;

    memset(&wl_ifr, 0, sizeof(struct ifreq));
    strncpy(wl_ifr.ifr_name, ifname, IFNAMSIZ);

	memcpy(&ifr, &wl_ifr, sizeof(struct ifreq));

	ret = ioctl(wl_ioctl_sockfd, SIOCGIFINDEX, &ifr);

    if (ret >= 0)
	{
		if (ifr.ifr_ifindex <= 0)
		{
			WL_ERR("invalid device %s\n", ifname);
			ret = WL_E_NODEVICE;
		}
    }

	if (ret < 0)
	{
		WL_ERR("ioctl error = %d\n", ret);
		close(wl_ioctl_sockfd);
		wl_ioctl_sockfd = -1;
		return WL_E_IOCTL_ERROR;
	}

    return WL_E_OK;
}

static int wl_ioctl_deinit(void)
{
	WL_DBG("enter\n");

	if (wl_ioctl_sockfd >= 0)
	{
		close(wl_ioctl_sockfd);
		wl_ioctl_sockfd = -1;
	}

	return WL_E_OK;
}

static int wl_event_init(void)
{
	int ret;

	WL_DBG("enter\n");

	ret = pthread_create(
				&wl_event_thread,
				NULL,
				wl_event_thread_func,
				NULL);

	if (ret < 0)
	{
		WL_ERR("create thread failed.\n");
		return WL_E_ERROR;
	}

	ret = wl_event_register(
				wl_connect_status_event, 
				sizeof(wl_connect_status_event) / sizeof(uint32_t),
				wl_connect_event_handler,
				NULL);

	return ret;
}

static int wl_event_deinit(void)
{
	WL_DBG("enter\n");

	wl_event_deregister(wl_connect_event_handler, NULL);

	WL_DBG("send close event to pipe\n");
   	write(wl_event_pipe[1], THREAD_CLOSE_EVENT, sizeof(THREAD_CLOSE_EVENT));

	WL_DBG("waiting event thread close\n");
    pthread_join(wl_event_thread, NULL);

	WL_DBG("exit\n");

	return WL_E_OK;
}

static void *wl_event_thread_func(void *args)
{
	int ret;
	int sockfd;
//	struct sockaddr_ll sll;
	char *buf = NULL;
	fd_set rfds;
	int fdsize;

	WL_DBG("enter\n");

	sockfd = socket(PF_PACKET, SOCK_RAW, htons(ETHER_TYPE_BRCM));
	if (sockfd < 0)
	{
		WL_ERR("create socket err = %d\n", sockfd);
		return NULL;
	}

	FD_ZERO(&rfds);

	ret = pipe(wl_event_pipe);

	if (ret < 0)
	{
		WL_ERR("create pipe err = %d\n", ret);
		goto exit;
	}

	fdsize = MAX(sockfd, wl_event_pipe[0]);

#if (0)
	/* bind the socket first before starting escan so we won't miss any event */
	memset(&sll, 0, sizeof(sll));
	sll.sll_family = AF_PACKET;
	sll.sll_protocol = htons(ETHER_TYPE_BRCM);
	sll.sll_ifindex = wl_ifr.ifr_ifindex;

	ret = bind(fd, (struct sockaddr *)&sll, sizeof(sll));

	if (ret < 0) {
		WL_ERR("bind socket error = %d\n", ret);
		goto exit;
	}
#endif

	buf = (char*)malloc(WL_EVENT_BUF_SIZE);

	if (buf == NULL)
	{
		WL_ERR("alloc event buf failed.\n");
		goto pipeexit;
	}

	while (1)
	{
		int size;
		bcm_event_t *msg;

		WL_DBG("waiting event\n");

		FD_SET(sockfd, &rfds);
		FD_SET(wl_event_pipe[0], &rfds);

		ret = select(fdsize + 1, &rfds, NULL, NULL, NULL);

		if (ret < 0)
		{
			WL_ERR("select err = %d\n", ret);
			break;
		}

		if (FD_ISSET(wl_event_pipe[0], &rfds))
		{
			WL_ERR("Receive thread close event from pipe\n");
			break;
		}

		if (!FD_ISSET(sockfd, &rfds))
		{
			WL_ERR("unknown fd\n");
			break;
		}

		size = recv(sockfd, buf, WL_EVENT_BUF_SIZE, 0);

		WL_DBG("recv buf size = %d\n", size);

		if (size >= sizeof(bcm_event_t))
		{
			int i;

			msg = (bcm_event_t*)buf;

            if (memcmp(BRCM_OUI, &msg->bcm_hdr.oui[0], DOT11_OUI_LEN) != 0)
            {
				WL_INFO("Event OUI mismatch\n");
                continue;
            }

            msg->event.flags = NTOH16(msg->event.flags);
		    msg->event.event_type = NTOH32(msg->event.event_type);
            msg->event.status = NTOH32(msg->event.status);
            msg->event.reason = NTOH32(msg->event.reason);
            msg->event.auth_type = NTOH32(msg->event.auth_type);
            msg->event.datalen = NTOH32(msg->event.datalen);

			WL_DBG("recv event = %d\n", msg->event.event_type);

			if (msg->event.event_type > WLC_E_LAST)
			{
				WL_INFO("Invalid event\n");
				continue;
			}

			for (i = 0; i < wl_event_num; i++)
			{
				wl_event_item_t *item = &wl_event_list[i];

				if (ISSET(item->event_mask, msg->event.event_type))
				{
					item->callback(&msg->event, item->user_data);
				}
			}
		}
	}

pipeexit:
	close(wl_event_pipe[0]);
	close(wl_event_pipe[1]);

exit:
	if (buf != NULL)
	{
		free(buf);
	}

	close(sockfd);

	pthread_exit(NULL);

	return NULL;
}

static int wl_connect_status_update(bool is_connected)
{
    WL_DBG("is_connected = %d\n", is_connected);

    if (wl_connect_status_callback != NULL)
    {
        wl_connect_status_callback(is_connected, wl_connect_status_userdata);
    }
}

static void wl_connecting_ap_handler(wl_event_msg_t* msg, void* user_data)
{
	bool is_join_completed = false;

	WL_DBG("Before event handler, join state = 0x%08x\n", wl_join_status);

	switch(msg->event_type)
	{
        case WLC_E_PSK_SUP:
			WL_DBG("WLC_E_PSK_SUP, status = %d\n", msg->status);
            /* Ignore WLC_E_PSK_SUP event if link is not up */
            if (wl_join_status & JOIN_LINK_READY)
            {
                if (msg->status == WLC_SUP_KEYED)
                {
                    /* Successful WPA key exchange */
                    wl_join_status |= JOIN_SECURITY_COMPLETE;
                }
                else
                {
                    /* join has completed with an error */
                    is_join_completed = true;
                    if ((msg->status == WLC_SUP_KEYXCHANGE_WAIT_M1) && (msg->reason == WLC_E_SUP_WPA_PSK_TMO))
                    {
                        /* A timeout waiting for M1 may occur at the edge of the cell or if the AP is particularly slow. */
                        WL_DBG("Supplicant M1 timeout event\n");
                        wl_join_status |= JOIN_EAPOL_KEY_M1_TIMEOUT;
                    }
                    else if ((msg->status == WLC_SUP_KEYXCHANGE_WAIT_M3) && ( msg->reason == WLC_E_SUP_WPA_PSK_TMO))
                    {
                        /* A timeout waiting for M3 is an indicator that the passphrase may be incorrect. */
                        WL_DBG("Supplicant M3 timeout event\n");
                        wl_join_status |= JOIN_EAPOL_KEY_M3_TIMEOUT;
                    }
                    else if ((msg->status == WLC_SUP_KEYXCHANGE_WAIT_G1) && (msg->reason == WLC_E_SUP_WPA_PSK_TMO))
                    {
                        /* A timeout waiting for G1 (group key) may occur at the edge of the cell. */
                        WL_DBG("Supplicant G1 timeout event\n");
                        wl_join_status |= JOIN_EAPOL_KEY_G1_TIMEOUT;
                    }
                    else
                    {
                        WL_DBG("Unsuccessful supplicant event; status=0x%x\n", msg->status);
                        /* Unknown failure during EAPOL key handshake */
                        wl_join_status |= JOIN_EAPOL_KEY_FAILURE;
                    }
                }
            }
            break;

        case WLC_E_JOIN:
        case WLC_E_SET_SSID:
			WL_DBG("WLC_E_SET_SSID, status = %d\n", msg->status);
            if (msg->status == WLC_E_STATUS_SUCCESS)
            {
                /* SSID has been successfully set. */
                wl_join_status |= JOIN_SSID_SET;
            }
            else if ((msg->status & 0xFF) == WLC_E_STATUS_NO_NETWORKS)
            {
                wl_join_status |= JOIN_NO_NETWORKS;
                is_join_completed = true;
            }
            else
            {
                is_join_completed = true;
            }
            break;

        case WLC_E_LINK:
			WL_DBG("WLC_E_LINK, flags = 0x%08x\n", msg->flags);
			if (msg->flags & WLC_EVENT_MSG_LINK)
            {
                wl_join_status |= JOIN_LINK_READY;
            }
            else
            {
                wl_join_status &= ~JOIN_LINK_READY;
            }
            break;

        case WLC_E_DEAUTH_IND:
        case WLC_E_DISASSOC_IND:
			WL_DBG("Disconnect\n");
            wl_join_status &= ~(JOIN_AUTHENTICATED | JOIN_LINK_READY);
            break;

        case WLC_E_AUTH:
			WL_DBG("WLC_E_AUTH, status = %d\n", msg->status);
            if (msg->status == WLC_E_STATUS_SUCCESS)
            {
                wl_join_status |= JOIN_AUTHENTICATED;
            }
            else if (msg->status == WLC_E_STATUS_UNSOLICITED)
            {
                WL_DBG("Ignore UNSOLICITED pkt event\n");
            }
            else
            {
                /* We cannot authenticate. Perhaps we're blocked or at the edge of a cell. */
                is_join_completed = true;
            }
            break;

		default:
            break;
	}

	WL_DBG("After event handler, join state = 0x%08x, connect status = %d\n", wl_join_status, wl_connect_status);

    if (wl_join_status == JOIN_COMPLETED)
    {
        is_join_completed = true;
    }

    WL_DBG("is_join_completed = %d\n", is_join_completed);

    if (is_join_completed)
    {
        if (wl_join_status == JOIN_COMPLETED)
        {
            wl_connect_status = WL_CONNECT_STATUS_CONNECTED;
        }
        else
        {
            wl_connect_status = WL_CONNECT_STATUS_DISCONNECTED;
        }

		wl_join_wake();

        if (wl_connect_status == WL_CONNECT_STATUS_CONNECTED)
        {
            wl_connect_status_update(true);
        }
    }
}

static void wl_connect_status_change_handler(wl_event_msg_t* msg, void* user_data)
{
	bool is_join_completed = false;
    uint32_t old_status = wl_connect_status;

	WL_DBG("connect status = %d\n", wl_connect_status);

	switch(msg->event_type)
	{
        case WLC_E_LINK:
			WL_DBG("WLC_E_LINK, flags = 0x%08x\n", msg->flags);
			if (msg->flags & WLC_EVENT_MSG_LINK)
            {
                wl_connect_status = WL_CONNECT_STATUS_CONNECTED;                
            }
            else
            {
                wl_connect_status = WL_CONNECT_STATUS_DISCONNECTED;                
            }
            break;

        case WLC_E_DEAUTH_IND:
        case WLC_E_DISASSOC_IND:
			WL_DBG("Disconnect\n");
            wl_connect_status = WL_CONNECT_STATUS_DISCONNECTED;                
            break;

		default:
            break;
	}

    if (old_status != wl_connect_status)
    {
        bool is_connected = (wl_connect_status == WL_CONNECT_STATUS_CONNECTED);
    
        wl_connect_status_update(is_connected);
    }
}

static void wl_connect_event_handler(wl_event_msg_t* msg, void* user_data)
{
	if (wl_connect_status == WL_CONNECT_STATUS_CONNECTING)
    {
        wl_connecting_ap_handler(msg, user_data);
    }
    else
    {
        wl_connect_status_change_handler(msg, user_data);
    }
}

int wl_join_init(uint32_t security)
{
	WL_DBG("security = 0x%08x\n", security);

	if ((security == WL_SECURITY_OPEN) ||
		(security == WL_SECURITY_WPS_OPEN) ||
		(security == WL_SECURITY_WPS_SECURE))
	{
		wl_join_status = JOIN_SECURITY_COMPLETE;
	}
	else
	{
		wl_join_status = 0;
	}

	wl_connect_status = WL_CONNECT_STATUS_CONNECTING;

	return 0;
}

int wl_join_wait(uint32_t timeout)
{
	WL_DBG("timeout = %d\n", timeout);
	return wl_wait(&wl_connect_sem, timeout);
}

int wl_join_wake(void)
{
	WL_DBG("enter\n");

	sem_post(&wl_connect_sem);

	return 0;
}

int wl_join_error(void)
{
	if (wl_join_status == JOIN_COMPLETED)
	{
		return WL_E_OK;
	}
	else if (wl_join_status & JOIN_NO_NETWORKS)
	{
		return WL_E_NO_NETWORK;
	}
	else
	{
		return WL_E_ERROR;
	}
}

int wl_wait(sem_t* sem, uint32_t timeout)
{
	struct timespec ts;
	int ret;

	clock_gettime(CLOCK_REALTIME, &ts);
    ts.tv_sec += timeout / 1000;
    ts.tv_nsec += (timeout % 1000) * 1000;

	ret = sem_timedwait(sem, &ts);

	if (ret == -ETIMEDOUT)
	{
		WL_DBG("semaphore timeout\n");
		return WL_E_TIMEOUT;
	}
	else
	{
		return WL_E_OK;
	}
}

int wl_wake(sem_t* sem)
{
	return sem_post(sem);
}

int wl_event_register(
		const uint32_t *event_type,
		uint32_t event_num,
		wl_event_cb_t callback,
		void* user_data)
{
	int ret = WL_E_OK;
#ifdef WL_CONFIG_CHECK_EVENT
	uint8_t event_mask[WL_EVENTING_MASK_LEN];
	uint32_t count = 0;
#endif /* WL_CONFIG_CHECK_EVENT */
	wl_event_item_t *item;
	int i;

	WL_DBG("callback = 0x%08x, user_data = 0x%08x, wl_event_num = %d\n",
		(int)callback, (int)user_data, wl_event_num);

	pthread_mutex_lock(&wl_mutex);

	if (wl_event_num == WL_EVENT_LIST_SIZE)
	{
		return -1;
	}

#ifdef WL_CONFIG_CHECK_EVENT
	memset(event_mask, 0, WL_EVENTING_MASK_LEN);

	ret = wl_iovar_get("event_msgs", event_mask, WL_EVENTING_MASK_LEN);
	if (ret < 0)
	{
		return ret;
	}
#endif /* WL_CONFIG_CHECK_EVENT */

	item = &wl_event_list[wl_event_num];

	for (i = 0; i < event_num; i++)
	{
		if (event_type[i] > WL_EVENT_TYPE_MAX)
		{
			return -1;
		}
	
#ifdef WL_CONFIG_CHECK_EVENT
		if (!ISSET(event_mask, event_type[i]))
		{
			SETBIT(event_mask, event_type[i]);
			SETBIT(item->reg_event_mask, event_type[i]);			
			count++;
		}
#endif /* WL_CONFIG_CHECK_EVENT */

		SETBIT(item->event_mask, event_type[i]);	
	}

#ifdef WL_CONFIG_CHECK_EVENT
	if (count > 0)
	{
		item->is_event_set = true;

		ret = wl_iovar_set("event_msgs", &event_mask, WL_EVENTING_MASK_LEN);

		if (ret < 0)
		{
			return ret;
		}
	}
#endif /* WL_CONFIG_CHECK_EVENT */

	item->callback = callback;
	item->user_data = user_data;

	wl_event_num++;

	pthread_mutex_unlock(&wl_mutex);

	return ret;
}

int wl_event_deregister(wl_event_cb_t callback, void* user_data)
{
	int i;
	wl_event_item_t *item = NULL;

	WL_DBG("callback = 0x%08x, user_data = 0x%08x, wl_event_num = %d\n",
		(int)callback, (int)user_data, wl_event_num);

	pthread_mutex_lock(&wl_mutex);

	for (i = 0; i < wl_event_num; i++)
	{
		if ((wl_event_list[i].callback == callback) &&
			(wl_event_list[i].user_data == user_data))
		{
			item = &wl_event_list[i];
			break;
		}
	}

	if (item == NULL)
	{
		return 0;
	}

#ifdef WL_CONFIG_CHECK_EVENT
	if (item->is_event_set)
	{
		int ret;
		uint8_t event_mask[WL_EVENTING_MASK_LEN];

		ret = wl_iovar_get("event_msgs", event_mask, WL_EVENTING_MASK_LEN);
		if (ret == 0)
		{
			for (int j = 0; j < WL_EVENTING_MASK_LEN; i++)
			{
				event_mask[j] &= (~item->reg_event_mask[j]);
			}

			wl_iovar_set("event_msgs", &event_mask, WL_EVENTING_MASK_LEN);
		}
	}
#endif /* WL_CONFIG_CHECK_EVENT */

	if (i < (wl_event_num - 1))
	{
		memcpy(
			item,
			&wl_event_list[i + 1],
			sizeof(wl_event_item_t) * (wl_event_num - i - 1));
	}

	wl_event_num--;

	memset(&wl_event_list[wl_event_num], 0, sizeof(wl_event_item_t));

	pthread_mutex_unlock(&wl_mutex);

	return 0;
}

int wl_connect_status_register(wl_connect_status_cb_t callback, void* user_data)
{
    wl_connect_status_callback = callback;
    wl_connect_status_userdata = user_data;
}

int wl_connect_status_deregister(wl_connect_status_cb_t callback)
{
    wl_connect_status_callback = NULL;
    wl_connect_status_userdata = NULL;
}