#include <ctype.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <net/if.h>
#include <errno.h>
#include <sys/prctl.h>
#include <sys/time.h>

#include "RK_encode.h"
#include "Rk_wifi.h"
#include "slog.h"
#include "utility.h"

typedef _Bool bool;
#define true 1
#define false 0

static bool save_last_ap = false;
static int connecting_id = -1;
static volatile bool wifi_onoff_flag = -1;

static RK_WIFI_RUNNING_State_e gstate = RK_WIFI_State_OFF;

static char retry_connect_cmd[128];

typedef struct {
	char ssid[SSID_BUF_LEN];
	char bssid[BSSID_BUF_LEN];
} RK_WIFI_CONNECT_INFO;

static RK_WIFI_CONNECT_INFO connect_info =
{
	"",
	"",
};

typedef struct RK_WIFI_encode_gbk {
	char ori[128];
	char utf8[128];
	struct RK_WIFI_encode_gbk *next;
} RK_WIFI_encode_gbk_t;

static int _RK_wifi_getSavedInfo(RK_WIFI_SAVED_INFO_s **pInfo, int *ap_cnt);
static int _RK_wifi_running_getConnectionInfo(RK_WIFI_INFO_Connection_s* pInfo);

// GBK编码路由链表
static RK_WIFI_encode_gbk_t *m_gbk_head = NULL;
// 无密码路由链表
static RK_WIFI_encode_gbk_t *m_nonpsk_head = NULL;

static RK_WIFI_encode_gbk_t* encode_gbk_insert(RK_WIFI_encode_gbk_t *head, const char *ori, const char *utf8)
{
	if ((ori == NULL || strlen(ori) == 0) || (utf8 == NULL || strlen(utf8) == 0))
		return head;

	RK_WIFI_encode_gbk_t *gbk = (RK_WIFI_encode_gbk_t*) malloc(sizeof(RK_WIFI_encode_gbk_t));
	memset(gbk->ori, 0, sizeof(gbk->ori));
	memset(gbk->utf8, 0, sizeof(gbk->utf8));

	if (strlen(ori) >= sizeof(gbk->ori) || strlen(utf8) >= sizeof(gbk->utf8)) {
		free(gbk);
		return head;
	}

	strcat(gbk->ori, ori);
	strcat(gbk->utf8, utf8);
	pr_info("encode_gbk_insert gbk->ori: %s, gbk->utf8: %s\n", gbk->ori, gbk->utf8);

	gbk->next = head;
	head = gbk;

	return head;
}

static RK_WIFI_encode_gbk_t* encode_gbk_reset(RK_WIFI_encode_gbk_t *head)
{
	RK_WIFI_encode_gbk_t *gbk, *gbk_next;

	gbk = head;
	while (gbk) {
		gbk_next = gbk->next;
		free(gbk);

		gbk = gbk_next;
	}
	head = NULL;

	return head;
}

static char* get_encode_gbk_ori(RK_WIFI_encode_gbk_t* head, const char* str, char* dst)
{
	int is_gbk = 0;
	RK_WIFI_encode_gbk_t *gbk = head;

	while (gbk) {
		pr_info("get_encode_gbk_ori gbk->ori: %s, gbk->utf8: %s, str: %s\n", gbk->ori, gbk->utf8, str);
		if (strcmp(gbk->utf8, str) == 0) {
			is_gbk = 1;
			strncpy(dst, gbk->ori, strlen(gbk->ori));
			break;
		}
		gbk = gbk->next;
	}
	if (!is_gbk) {
		strncpy(dst, str, strlen(str));
	}

	return dst;
}

static char* get_encode_gbk_utf8(RK_WIFI_encode_gbk_t* head, const char* str, char* dst)
{
	int is_gbk = 0;
	RK_WIFI_encode_gbk_t *gbk = head;

	while (gbk) {
		pr_info("get_encode_gbk_utf8 gbk->ori: %s, gbk->utf8: %s, str: %s\n", gbk->ori, gbk->utf8, str);
		if (strcmp(gbk->ori, str) == 0) {
			is_gbk = 1;
			strncpy(dst, gbk->utf8, strlen(gbk->utf8));
			break;
		}
		gbk = gbk->next;
	}
	if (!is_gbk) {
		strncpy(dst, str, strlen(str));
	}

	return dst;
}

static int is_non_psk(const char* str)
{
	RK_WIFI_encode_gbk_t *nonpsk = m_nonpsk_head;
	while (nonpsk) {
		if (strcmp(nonpsk->utf8, str) == 0) {
			return 1;
		}
		nonpsk = nonpsk->next;
	}

	return 0;
}

static RK_wifi_state_callback m_cb;
static int priority = 0;
static volatile bool wifi_wrong_key = false;
static volatile bool wifi_cancel = false;
static volatile bool wifi_connect_lock = false;
static volatile bool wifi_is_exist = false;
static volatile bool wpa_exit = false;
static volatile bool is_wep = false;
static int wep_id = -1;

static void format_wifiinfo(int flag, char *info);
static int get_pid(const char Name[]);
static void *RK_wifi_start_monitor(void *arg);

static char* wifi_state[] = {
	"RK_WIFI_State_IDLE",
	"RK_WIFI_State_CONNECTING",
	"RK_WIFI_State_CONNECTFAILED",
	"RK_WIFI_State_CONNECTFAILED_WRONG_KEY",
	"RK_WIFI_State_CONNECTED",
	"RK_WIFI_State_DISCONNECTED",
	"RK_WIFI_State_OPEN",
	"RK_WIFI_State_OFF",
	"RK_WIFI_State_SCAN_RESULTS",
	"RK_WIFI_State_DHCP_OK",
};

static void wifi_state_send(RK_WIFI_RUNNING_State_e state, RK_WIFI_INFO_Connection_s *info)
{
	if (m_cb == NULL)
		return;

	pr_info("[RKWIFI]: %s: [%d]: %s\n", __func__, state, wifi_state[state]);

	if(state == RK_WIFI_State_CONNECTFAILED || state ==RK_WIFI_State_CONNECTING) {
		RK_WIFI_INFO_Connection_s cndinfo;

		_RK_wifi_running_getConnectionInfo(&cndinfo);
		strncpy(cndinfo.ssid, connect_info.ssid, SSID_BUF_LEN);
		strncpy(cndinfo.bssid, connect_info.bssid, BSSID_BUF_LEN);
		cndinfo.ssid[SSID_BUF_LEN - 1] = '\0';
		cndinfo.bssid[BSSID_BUF_LEN - 1] = '\0';
		pr_info("[RKWIFI]: %s: %s, %s, %s, reason=%d\n", __func__, wifi_state[state], cndinfo.ssid, cndinfo.bssid, cndinfo.reason);
		m_cb(state, &cndinfo);
	} else {
		if (info) {
			info->ssid[SSID_BUF_LEN - 1] = '\0';
			info->bssid[BSSID_BUF_LEN - 1] = '\0';
			pr_info("[RKWIFI]: %s: %s, %s, %s, reason=%d\n", __func__, wifi_state[state], info->ssid, info->bssid, info->reason);
		}
		m_cb(state, info);
	}
}


static char *remove_escape_character(const char *buf, char *dst)
{
	char buf_temp[strlen(buf) + 1];
	int i = 0;

	memset(buf_temp, 0, sizeof(buf_temp));
	while(*buf != '\0') {
		if (*buf == '\\' && (*(buf + 1) == '\\' || *(buf + 1) == '\"')) {
			dst[i] = *(buf + 1);
			buf = buf + 2;
		} else {
			dst[i] = *buf;
			buf++;
		}
		i++;
	}
	dst[i] = '\0';

	return dst;
}

static char *spec_char_convers(const char *buf, char *dst)
{
	char buf_temp[strlen(buf) + 1];
	int i = 0;
	unsigned long con;

	memset(buf_temp, 0, sizeof(buf_temp));
	while(*buf != '\0') {
		if(*buf == '\\' && *(buf + 1) == 'x') {
			strcpy(buf_temp, buf);
			*buf_temp = '0';
			*(buf_temp + 4) = '\0';
			con = strtoul(buf_temp, NULL, 16);
			dst[i] = con;
			buf += 4;
		} else {
			dst[i] = *buf;
			buf++;
		}
		i++;
	}
	dst[i] = '\0';
	return dst;
}

int RK_wifi_register_callback(RK_wifi_state_callback cb)
{
	m_cb = cb;
	return 1;
}

static int RK_wifi_search_with_bssid(const char *bssid)
{
	RK_WIFI_SAVED_INFO_s *wsi;
	int id, ap_cnt = 0;
	pr_info("%s: enter\n", __func__);

	_RK_wifi_getSavedInfo(&wsi, &ap_cnt);
	if (ap_cnt <= 0)
		return -1;

	for (int i = 0; i < ap_cnt; i++) {
		if (strncmp(wsi[i].bssid, bssid, strlen(bssid)) == 0) {
			id = wsi[i].id;
			free(wsi);
			return id;
		}
	}

	free(wsi);
	return -1;
}

static int RK_wifi_search_with_ssid(char *ssid)
{
	RK_WIFI_SAVED_INFO_s *wsi = NULL;
	int id, len, ap_cnt = 0;
	pr_info("%s: enter\n", __func__);

	_RK_wifi_getSavedInfo(&wsi, &ap_cnt);
	if (ap_cnt <= 0)
		return -1;

	for (int i = 0; i < ap_cnt; i++) {
		if ((strlen(wsi[i].ssid) > 64) || (strlen(ssid) > 64))
			pr_err("RK_wifi_search_with_ssid ssid error!!!\n");
		pr_err("RK_wifi_search_with_ssid save_info[%d].ssid: [%s], ssid: [%s] [%d:%d:%d]\n",
				i, wsi[i].ssid, ssid, strlen(wsi[i].ssid), strlen(ssid), ap_cnt);
		if (strlen(wsi[i].ssid) > strlen(ssid))
			len = strlen(wsi[i].ssid);
		else
			len = strlen(ssid);
		if (strncmp(wsi[i].ssid, ssid, len) == 0) {
			id = wsi[i].id;
			return id;
		}
	}

	if (wsi)
		free(wsi);

	return -1;
}

static bool get_ssid_directly(char *flags, int row, int columns)
{
	/* <=3: id ssid bssid
	   4: id ssid bssid flags*/
	if(columns <= 3 || (columns == 4 && strlen(flags) > 0))
		return true;

	return false;
}

static char *ltrim(char *str) {
		if (str == NULL || *str == '\0') {
				return str;
		}

		int len = 0;
		char *p = str;
		while (*p != '\0' && isspace(*p)) {
				++p;
				++len;
		}

		memmove(str, p, strlen(str) - len + 1);

		return str;
}

static char *rtrim(char *str) {
		if (str == NULL || *str == '\0') {
				return str;
		}

		int len = strlen(str);
		char *p = str + len - 1;
		while (p >= str  && isspace(*p)) {
				*p = '\0';
				--p;
		}

		return str;
}

static char *RK_property_trim(char *str)
{
		str = rtrim(str);
		str = ltrim(str);

		return str;
}

static int get_ssid_from_list_network(RK_WIFI_SAVED_INFO_s *info, int row, int columns)
{
	int start = 0, end = 0;
	char cmd[256], str[256];
	char ssid[256], sname[256], utf8[256];
	char *bssid;
	pr_info("%s: enter\n", __func__);

	if(!info)
		return -1;

	memset(info->ssid, 0, SSID_BUF_LEN);
	memset(cmd, 0, sizeof(cmd));
	memset(str, 0, sizeof(str));

	if(get_ssid_directly(info->state, row, columns)) {
		snprintf(cmd, sizeof(cmd), "cat /tmp/save_info.txt | awk '{print $2}' | sed -n %dp", row);
		exec_command(cmd, str, 256);
		pr_info("%s: row = %d, column(2) = %s\n", __func__, row, str);
		pr_info("%s: check len str: %d\n", __func__, strlen(str));

		memset(sname, 0, sizeof(sname));
		memset(utf8, 0, sizeof(utf8));
		memset(ssid, 0, sizeof(ssid));

		str[strlen(str)-1] = '\0';
		remove_escape_character(str, ssid);
		spec_char_convers(ssid, sname);
		get_encode_gbk_utf8(m_gbk_head, sname, utf8);
		pr_info("direct: convers str: %s, sname: %s, ori: %s\n", ssid, sname, utf8);
		strncpy(info->ssid, utf8, strlen(utf8));

		return 0;
	}

	snprintf(cmd, sizeof(cmd), "cat /tmp/save_info.txt | sed -n %dp", row);
	exec_command(cmd, str, 256);
	pr_info("%s: row(%d) = %s\n", __func__, row, str);

	memset(cmd, 0, sizeof(cmd));
	sprintf(cmd, "%d", info->id);
	start = strlen(cmd);

	if((bssid = strstr(str, info->bssid)) == NULL) {
		pr_err("%s: %s can't find bssid(%s)\n", __func__, str, info->bssid);
		return -1;
	}
	end = strlen(str) - strlen(bssid);

	memset(ssid, 0, sizeof(ssid));
	strncpy(ssid, str + start, end - start);
	RK_property_trim(ssid);

	memset(str, 0, sizeof(str));
	memset(sname, 0, sizeof(sname));
	memset(utf8, 0, sizeof(utf8));
	remove_escape_character(ssid, str);
	spec_char_convers(str, sname);
	get_encode_gbk_utf8(m_gbk_head, sname, utf8);
	pr_info("ndirect convers str: %s, sname: %s, ori: %s\n", str, sname, utf8);
	strncpy(info->ssid, utf8, strlen(utf8));
}

int get_bssid_from_list_network(RK_WIFI_SAVED_INFO_s *info, int row, int columns)
{
	char cmd[128], str[128];
	int bssid_column = columns;
	pr_info("%s: enter\n", __func__);

	if(!info)
		return -1;

	memset(info->bssid, 0, BSSID_BUF_LEN);
	memset(cmd, 0, 128);
	memset(str, 0, 128);

	if(strlen(info->state) > 0)
		bssid_column = columns - 1;

	snprintf(cmd, sizeof(cmd), "cat /tmp/save_info.txt | awk '{print $%d}' | sed -n %dp", bssid_column, row);
	exec_command(cmd, str, 128);
	pr_info("%s: row = %d, column(%d) = %s\n", __func__, row, bssid_column, str);

	strncpy(info->bssid, str, ((strlen(str) - 1) > BSSID_BUF_LEN) ? BSSID_BUF_LEN : (strlen(str) - 1));
	pr_info("%s: bssid: %s\n", __func__, info->bssid);
	return 0;
}

int get_id_from_list_network(int row)
{
	int network_id;
	char cmd[128], str[128];

	memset(cmd, 0, 128);
	memset(str, 0, 128);
	snprintf(cmd, sizeof(cmd), "cat /tmp/save_info.txt | awk '{print $1}' | sed -n %dp", row);
	exec_command(cmd, str, 128);
	network_id = atoi(str);

	pr_info("%s: row = %d, network_id = %d\n", __func__, row, network_id);
	return network_id;
}

int get_columns_from_list_network(int row)
{
	int columns;
	char cmd[128], str[128];

	memset(cmd, 0, 128);
	memset(str, 0, 128);

	snprintf(cmd, sizeof(cmd), "cat /tmp/save_info.txt | awk '{print NF}' | sed -n %dp", row);
	exec_command(cmd, str, 128);
	columns = atoi(str);

	pr_info("%s: row = %d, columns = %d\n", __func__, row, columns);
	return columns;
}

void get_flags_from_list_network(char *flags_buf, int buf_len, int row, int columns)
{
	char cmd[128], str[128];

	memset(flags_buf, 0, buf_len);
	memset(cmd, 0, 128);
	memset(str, 0, 128);
	pr_info("%s: enter\n", __func__);

	snprintf(cmd, sizeof(cmd), "cat /tmp/save_info.txt | awk '{print $%d}' | sed -n %dp", columns, row);
	exec_command(cmd, str, 128);
	if(!strncmp(str, "[CURRENT]", strlen("[CURRENT]"))
				|| !strncmp(str, "[DISABLED]", strlen("[DISABLED]"))
				|| !strncmp(str, "[TEMP-DISABLED]", strlen("[TEMP-DISABLED]"))) {
		strncpy(flags_buf, str, ((strlen(str) - 1) > buf_len) ? buf_len : (strlen(str) - 1));
		pr_info("%s: row = %d, column(%d) = %s\n", __func__, row, columns, flags_buf);
	}
}

int RK_wifi_getSavedInfo(RK_WIFI_SAVED_INFO_s **pInfo, int *ap_cnt)
{
	FILE *fp = NULL;
	int cnt, row, columns;
	char str[128];
	RK_WIFI_SAVED_INFO_s *pInfo_in;
	pr_info("%s: enter\n", __func__);

	exec_command_system("rm -rf /tmp/save_info.txt");
	usleep(1 * 1000);
	exec_command_system("wpa_cli -i wlan0 list_network > /tmp/save_info.txt");
	usleep(1 * 1000);

	memset(str, 0, 128);
	exec_command("cat /tmp/save_info.txt | wc -l", str, 128);
	cnt = atoi(str) - 1;

	pr_info("ap cnt: %p, &cnt: %p\n", ap_cnt, &cnt);

	if (cnt <= 0)
		return -1;

	*ap_cnt = cnt;

	pInfo_in = (RK_WIFI_SAVED_INFO_s *)malloc(sizeof(RK_WIFI_SAVED_INFO_s) * cnt);
	pr_info("wifi cnt: %d(%s)(%p)\n", cnt, str, pInfo_in);

	for (int i = 0; i < cnt; i++) {
		row = i+2;

		columns = get_columns_from_list_network(row);
		pInfo_in[i].id = get_id_from_list_network(row);
		get_flags_from_list_network(pInfo_in[i].state, STATE_BUF_LEN, row, columns);
		get_bssid_from_list_network(&pInfo_in[i], row, columns);
		get_ssid_from_list_network(&pInfo_in[i], row, columns);
	}

	for (int i = 0; i < cnt; i++) {
		pr_info("id: %d, name: %s, bssid: %s, state: %s\n", pInfo_in[i].id, pInfo_in[i].ssid, pInfo_in[i].bssid,
					pInfo_in[i].state);
	}

	*pInfo = pInfo_in;

	/*
	for (int i = 0; i < cnt; i++) {
		pr_info("id: %d, name: %s, bssid: %s, state: %s\n", pInfo[i]->id, pInfo[i]->ssid, pInfo[i]->bssid,
					pInfo[i]->state);
	}
	*/

	return 0;
}

static int _get_ssid_from_list_network(RK_WIFI_SAVED_INFO_s *info, int row, int columns)
{
	int start = 0, end = 0;
	char cmd[256], str[256];
	char ssid[256], sname[256], utf8[256];
	char *bssid;
	pr_info("%s: enter\n", __func__);

	if(!info)
		return -1;

	memset(info->ssid, 0, SSID_BUF_LEN);
	memset(cmd, 0, sizeof(cmd));
	memset(str, 0, sizeof(str));

	if(get_ssid_directly(info->state, row, columns)) {
		snprintf(cmd, sizeof(cmd), "cat /tmp/save_network.txt | awk '{print $2}' | sed -n %dp", row);
		exec_command(cmd, str, 256);
		pr_info("%s: row = %d, column(2) = %s\n", __func__, row, str);
		pr_info("%s: check len str: %d\n", __func__, strlen(str));

		memset(sname, 0, sizeof(sname));
		memset(utf8, 0, sizeof(utf8));
		memset(ssid, 0, sizeof(ssid));

		str[strlen(str)-1] = '\0';
		remove_escape_character(str, ssid);
		spec_char_convers(ssid, sname);
		get_encode_gbk_utf8(m_gbk_head, sname, utf8);
		pr_info("direct: convers str: %s, sname: %s, ori: %s\n", ssid, sname, utf8);
		strncpy(info->ssid, utf8, strlen(utf8));

		return 0;
	}

	snprintf(cmd, sizeof(cmd), "cat /tmp/save_network.txt | sed -n %dp", row);
	exec_command(cmd, str, 256);
	pr_info("%s: row(%d) = %s\n", __func__, row, str);

	memset(cmd, 0, sizeof(cmd));
	sprintf(cmd, "%d", info->id);
	start = strlen(cmd);

	if((bssid = strstr(str, info->bssid)) == NULL) {
		pr_err("%s: %s can't find bssid(%s)\n", __func__, str, info->bssid);
		return -1;
	}
	end = strlen(str) - strlen(bssid);

	memset(ssid, 0, sizeof(ssid));
	strncpy(ssid, str + start, end - start);
	RK_property_trim(ssid);

	memset(str, 0, sizeof(str));
	memset(sname, 0, sizeof(sname));
	memset(utf8, 0, sizeof(utf8));
	remove_escape_character(ssid, str);
	spec_char_convers(str, sname);
	get_encode_gbk_utf8(m_gbk_head, sname, utf8);
	pr_info("ndirect convers str: %s, sname: %s, ori: %s\n", str, sname, utf8);
	strncpy(info->ssid, utf8, strlen(utf8));
}

int _get_bssid_from_list_network(RK_WIFI_SAVED_INFO_s *info, int row, int columns)
{
	char cmd[128], str[128];
	int bssid_column = columns;
	pr_info("%s: enter\n", __func__);

	if(!info)
		return -1;

	memset(info->bssid, 0, BSSID_BUF_LEN);
	memset(cmd, 0, 128);
	memset(str, 0, 128);

	if(strlen(info->state) > 0)
		bssid_column = columns - 1;

	snprintf(cmd, sizeof(cmd), "cat /tmp/save_network.txt | awk '{print $%d}' | sed -n %dp", bssid_column, row);
	exec_command(cmd, str, 128);
	pr_info("%s: row = %d, column(%d) = %s\n", __func__, row, bssid_column, str);

	strncpy(info->bssid, str, ((strlen(str) - 1) > BSSID_BUF_LEN) ? BSSID_BUF_LEN : (strlen(str) - 1));
	return 0;
}

int _get_id_from_list_network(int row)
{
	int network_id;
	char cmd[128], str[128];

	memset(cmd, 0, 128);
	memset(str, 0, 128);
	snprintf(cmd, sizeof(cmd), "cat /tmp/save_network.txt | awk '{print $1}' | sed -n %dp", row);
	exec_command(cmd, str, 128);
	network_id = atoi(str);

	pr_info("%s: row = %d, network_id = %d\n", __func__, row, network_id);
	return network_id;
}

int _get_columns_from_list_network(int row)
{
	int columns;
	char cmd[128], str[128];

	memset(cmd, 0, 128);
	memset(str, 0, 128);

	snprintf(cmd, sizeof(cmd), "cat /tmp/save_network.txt | awk '{print NF}' | sed -n %dp", row);
	exec_command(cmd, str, 128);
	columns = atoi(str);

	pr_info("%s: row = %d, columns = %d\n", __func__, row, columns);
	return columns;
}

void _get_flags_from_list_network(char *flags_buf, int buf_len, int row, int columns)
{
	char cmd[128], str[128];

	memset(flags_buf, 0, buf_len);
	memset(cmd, 0, 128);
	memset(str, 0, 128);
	pr_info("%s: enter\n", __func__);

	snprintf(cmd, sizeof(cmd), "cat /tmp/save_network.txt | awk '{print $%d}' | sed -n %dp", columns, row);
	exec_command(cmd, str, 128);
	if(!strncmp(str, "[CURRENT]", strlen("[CURRENT]"))
				|| !strncmp(str, "[DISABLED]", strlen("[DISABLED]"))
				|| !strncmp(str, "[TEMP-DISABLED]", strlen("[TEMP-DISABLED]"))) {
		strncpy(flags_buf, str, ((strlen(str) - 1) > buf_len) ? buf_len : (strlen(str) - 1));
		pr_info("%s: row = %d, column(%d) = %s\n", __func__, row, columns, flags_buf);
	}
}

static int _RK_wifi_getSavedInfo(RK_WIFI_SAVED_INFO_s **pInfo, int *ap_cnt)
{
	FILE *fp = NULL;
	int cnt, row, columns;
	char str[128];
	RK_WIFI_SAVED_INFO_s *pInfo_in;
	pr_info("%s: enter\n", __func__);

	exec_command_system("rm /tmp/save_network.txt");
	usleep(1 * 1000);
	exec_command_system("wpa_cli -i wlan0 list_network > /tmp/save_network.txt");
	usleep(3 * 1000);

	memset(str, 0, 128);
	exec_command("cat /tmp/save_network.txt | wc -l", str, 128);
	cnt = atoi(str) - 1;

	pr_info("ap cnt: %p, &cnt: %p\n", ap_cnt, &cnt);

	if (cnt <= 0)
		return -1;

	*ap_cnt = cnt;

	pInfo_in = (RK_WIFI_SAVED_INFO_s *)malloc(sizeof(RK_WIFI_SAVED_INFO_s) * cnt);
	pr_info("wifi cnt: %d(%s)(%p)\n", cnt, str, pInfo_in);

	for (int i = 0; i < cnt; i++) {
		row = i+2;

		columns = _get_columns_from_list_network(row);
		pInfo_in[i].id = _get_id_from_list_network(row);
		_get_flags_from_list_network(pInfo_in[i].state, STATE_BUF_LEN, row, columns);
		_get_bssid_from_list_network(&pInfo_in[i], row, columns);
		_get_ssid_from_list_network(&pInfo_in[i], row, columns);
	}

	for (int i = 0; i < cnt; i++) {
		pr_info("id: %d, name: %s, bssid: %s, state: %s\n", pInfo_in[i].id, pInfo_in[i].ssid, pInfo_in[i].bssid,
					pInfo_in[i].state);
	}

	*pInfo = pInfo_in;

	/*
	for (int i = 0; i < cnt; i++) {
		pr_info("id: %d, name: %s, bssid: %s, state: %s\n", pInfo[i]->id, pInfo[i]->ssid, pInfo[i]->bssid,
					pInfo[i]->state);
	}
	*/

	return 0;
}

int RK_wifi_running_getState(RK_WIFI_RUNNING_State_e* pState)
{
	int ret = 0;
	char str[128];

	if(!pState)
		return -1;

	// check wpa is running first
	exec_command("pidof wpa_supplicant", str, 128);
	if (0 == strlen(str)) {
		*pState = RK_WIFI_State_IDLE;
		return ret;
	}

	// check whether wifi connected
	exec_command("wpa_cli -iwlan0 status | grep wpa_state | awk -F '=' '{printf $2}'", str, 128);
	if (0 == strncmp(str, "COMPLETED", 9)) {
		*pState = RK_WIFI_State_CONNECTED;
		return ret;
	} else {
		*pState = RK_WIFI_State_DISCONNECTED;
		return ret;
	}
}

static int _RK_wifi_running_getConnectionInfo(RK_WIFI_INFO_Connection_s* pInfo)
{
	FILE *fp = NULL;
	char line[512];
	char *value, *orgs;
	pr_info("%s: enter\n", __func__);

	if (pInfo == NULL)
		return -1;

	if (remove("/tmp/wifi_status.tmp"))
		pr_err("remove /tmp/wifi_status.tmp failed!\n");
	exec_command_system("wpa_cli -iwlan0 status > /tmp/wifi_status.tmp");

	// check wpa is running first
	memset(line, 0, sizeof(line));
	exec_command("cat /tmp/wifi_status.tmp", line, 512);
	pr_info("wifi_status.tmp: %s\n", line);

	memset(line, 0, sizeof(line));
	exec_command("wpa_cli -iwlan0 status", line, 512);
	pr_info("wpa_cli status: %s\n", line);

	fp = fopen("/tmp/wifi_status.tmp", "r");
	if (!fp) {
		pr_err("fopen /tmp/status.tmp failed!\n");
		return -1;
	}

	memset(pInfo, 0, sizeof(RK_WIFI_INFO_Connection_s));
	memset(line, 0, sizeof(line));
	while (fgets(line, sizeof(line) - 1, fp)) {
		if (line[strlen(line) - 1] == '\n')
			line[strlen(line) - 1] = '\0';

		if (0 == strncmp(line, "bssid", 5)) {
			value = strchr(line, '=');
			if (value && strlen(value) > 0) {
				strncpy(pInfo->bssid, value + 1, sizeof(pInfo->bssid));
			}
		} else if (0 == strncmp(line, "freq", 4)) {
			value = strchr(line, '=');
			if (value && strlen(value) > 1) {
				pInfo->freq = atoi(value + 1);
			}
		} else if (0 == strncmp(line, "ssid", 4)) {
			value = strchr(line, '=');
			pr_info("%s: check len value: %d\n", __func__, strlen(value));
			if (value && strlen(value) > 0) {
				char sname[256];
				char sname1[256];
				char utf8[256];
				memset(sname, 0, sizeof(sname));
				memset(sname1, 0, sizeof(sname));
				memset(utf8, 0, sizeof(utf8));
				spec_char_convers(value + 1, sname);
				remove_escape_character(sname, sname1);
				get_encode_gbk_utf8(m_gbk_head, sname1, utf8);
				orgs = value + 1;
				pr_info("[convers str: %s, sname: %s, ori: %s]\n", value + 1, sname1, utf8);
				pr_info("%d:%d\n", strlen(orgs), strlen(utf8));
				strncpy(pInfo->ssid,  utf8, strlen(utf8));
			}
		} else if (0 == strncmp(line, "id", 2)) {
			value = strchr(line, '=');
			if (value && strlen(value) > 1) {
				pInfo->id = atoi(value + 1);
			}
		} else if (0 == strncmp(line, "mode", 4)) {
			value = strchr(line, '=');
			if (value && strlen(value) > 0) {
				strncpy(pInfo->mode, value + 1, sizeof(pInfo->mode));
			}
		} else if (0 == strncmp(line, "wpa_state", 9)) {
			value = strchr(line, '=');
			if (value && strlen(value) > 0) {
				strncpy(pInfo->wpa_state, value + 1, sizeof(pInfo->wpa_state));
			}
		} else if (0 == strncmp(line, "ip_address", 10)) {
			value = strchr(line, '=');
			if (value && strlen(value) > 0) {
				strncpy(pInfo->ip_address, value + 1, sizeof(pInfo->ip_address));
			}
		} else if (0 == strncmp(line, "address", 7)) {
			value = strchr(line, '=');
			if (value && strlen(value) > 0) {
				strncpy(pInfo->mac_address, value + 1, sizeof(pInfo->mac_address));
			}
		}
	}
	fclose(fp);
	return 0;
}

int RK_wifi_running_getConnectionInfo(RK_WIFI_INFO_Connection_s* pInfo)
{
	FILE *fp = NULL;
	char line[512];
	char *value, *orgs;
	pr_info("%s: enter\n", __func__);

	if (pInfo == NULL)
		return -1;

	if (remove("/tmp/status.tmp"))
		pr_err("remove /tmp/status.tmp failed!\n");
	exec_command_system("wpa_cli -iwlan0 status > /tmp/status.tmp");

	// check wpa is running first
	memset(line, 0, sizeof(line));
	exec_command("cat /tmp/status.tmp", line, 512);
	pr_info("status.tmp: %s\n", line);

	memset(line, 0, sizeof(line));
	exec_command("wpa_cli -iwlan0 status", line, 512);
	pr_info("wpa_cli status: %s\n", line);

	fp = fopen("/tmp/status.tmp", "r");
	if (!fp) {
		pr_err("fopen /tmp/status.tmp failed!\n");
		return -1;
	}

	memset(pInfo, 0, sizeof(RK_WIFI_INFO_Connection_s));
	memset(line, 0, sizeof(line));
	while (fgets(line, sizeof(line) - 1, fp)) {
		if (line[strlen(line) - 1] == '\n')
			line[strlen(line) - 1] = '\0';

		if (0 == strncmp(line, "bssid", 5)) {
			value = strchr(line, '=');
			if (value && strlen(value) > 0) {
				strncpy(pInfo->bssid, value + 1, sizeof(pInfo->bssid));
			}
		} else if (0 == strncmp(line, "freq", 4)) {
			value = strchr(line, '=');
			if (value && strlen(value) > 1) {
				pInfo->freq = atoi(value + 1);
			}
		} else if (0 == strncmp(line, "ssid", 4)) {
			value = strchr(line, '=');
			pr_info("%s: check len value: %d\n", __func__, strlen(value));
			if (value && strlen(value) > 0) {
				char sname[256];
				char sname1[256];
				char utf8[256];
				memset(sname, 0, sizeof(sname));
				memset(sname1, 0, sizeof(sname));
				memset(utf8, 0, sizeof(utf8));
				spec_char_convers(value + 1, sname);
				remove_escape_character(sname, sname1);
				get_encode_gbk_utf8(m_gbk_head, sname1, utf8);
				orgs = value + 1;
				pr_info("[convers str: %s, sname: %s, ori: %s]\n", value + 1, sname1, utf8);
				pr_info("%d:%d\n", strlen(orgs), strlen(utf8));
				strncpy(pInfo->ssid,  utf8, strlen(utf8));
			}
		} else if (0 == strncmp(line, "id", 2)) {
			value = strchr(line, '=');
			if (value && strlen(value) > 1) {
				pInfo->id = atoi(value + 1);
			}
		} else if (0 == strncmp(line, "mode", 4)) {
			value = strchr(line, '=');
			if (value && strlen(value) > 0) {
				strncpy(pInfo->mode, value + 1, sizeof(pInfo->mode));
			}
		} else if (0 == strncmp(line, "wpa_state", 9)) {
			value = strchr(line, '=');
			if (value && strlen(value) > 0) {
				strncpy(pInfo->wpa_state, value + 1, sizeof(pInfo->wpa_state));
			}
		} else if (0 == strncmp(line, "ip_address", 10)) {
			value = strchr(line, '=');
			if (value && strlen(value) > 0) {
				strncpy(pInfo->ip_address, value + 1, sizeof(pInfo->ip_address));
			}
		} else if (0 == strncmp(line, "address", 7)) {
			value = strchr(line, '=');
			if (value && strlen(value) > 0) {
				strncpy(pInfo->mac_address, value + 1, sizeof(pInfo->mac_address));
			}
		}
	}
	fclose(fp);
	return 0;
}

static int is_wifi_enable()
{
	int ret = 0;

	if (gstate == RK_WIFI_State_OPEN) {
		if (get_pid("wpa_supplicant") > 0)
			ret = 1;
		else
			pr_info("BUG: wifi open but wpa_supplicant noexist!!!\n");
	}

	return ret;
}

static void wifi_close_sockets();
int RK_wifi_enable(int enable)
{
	static pthread_t start_wifi_monitor_threadId = 0;
	int wpa_exit_cnt = 50;
	int s;

	pr_info("[RKWIFI] start_wpa_supplicant wpa_pid: %d, monitor_id: 0x%lx\n",
			get_pid("wpa_supplicant"), start_wifi_monitor_threadId);

	pr_info("+++++ wifi version: V1.352 [%s]+++++\n", enable ? "open":"close");

	if (enable) {
		if (!is_wifi_enable()) {
			wifi_onoff_flag = true;
			//exec_command_system("ifconfig wlan0 down");
			exec_command_system("ifconfig wlan0 up");
			exec_command_system("ifconfig wlan0 0.0.0.0");
			exec_command_system("killall dhcpcd");
			if (get_pid("wpa_supplicant") > 0) {
				exec_command_system("killall -15 wpa_supplicant");
				usleep(600000);
			}
			if (get_pid("wpa_supplicant") > 0) {
				exec_command_system("killall -9 wpa_supplicant");
				usleep(600000);
			}
			usleep(200000);
			exec_command_system("wpa_supplicant -B -i wlan0 -c /data/cfg/wpa_supplicant.conf -d");
			usleep(500000);
			//exec_command_system("udhcpc -i wlan0 -t 5 &");
			exec_command_system("dhcpcd wlan0 -AL -t 0 &");

			gstate = RK_WIFI_State_OPEN;
			wifi_state_send(gstate, NULL);

			s = pthread_create(&start_wifi_monitor_threadId, NULL, RK_wifi_start_monitor, NULL);
			if (s != 0) {
				errno = s;
				perror("RK_wifi_enable enable failed!");
				pr_info("RK_wifi_enable failed!\n");
				gstate = RK_WIFI_State_OFF;
				wifi_onoff_flag = false;
				wifi_state_send(gstate, NULL);
				return -1;
			}
			pthread_detach(start_wifi_monitor_threadId);

			pr_info("RK_wifi_enable enable ok!\n");
		}
	} else {
		if (is_wifi_enable()) {
			exec_command_system("wpa_cli -i wlan0 enable_network all");
			exec_command_system("wpa_cli -i wlan0 save_config");
			wifi_onoff_flag = false;
			usleep(200000);
			//wifi_close_sockets();
			while ((wpa_exit == false) && (wpa_exit_cnt--)) {
				usleep(200000);
				pr_info("rkwifi turning off... wpa_exit: %d, cnt: %d\n", wpa_exit, wpa_exit_cnt);
			}
			pr_info("rkwifi turning off... wpa_exit: %d, cnt: %d\n", wpa_exit, wpa_exit_cnt);
			exec_command_system("ifconfig wlan0 down");
			usleep(300000);
			exec_command_system("killall -15 wpa_supplicant");
			usleep(300000);
			exec_command_system("killall dhcpcd");
			//exec_command_system("killall udhcpc");
			usleep(200000);
			if (start_wifi_monitor_threadId > 0) {
				//pthread_cancel(start_wifi_monitor_threadId);
				//pthread_join(start_wifi_monitor_threadId, NULL);
			}
			start_wifi_monitor_threadId = 0;

			gstate = RK_WIFI_State_OFF;
			wifi_state_send(gstate, NULL);
			if (get_pid("wpa_supplicant") > 0) {
				exec_command_system("killall -9 wpa_supplicant");
				usleep(200000);
			}
			pr_info("RK_wifi_enable disable ok!\n");
		}
	}

	return 0;
}

int RK_wifi_scan(void)
{
	int ret;
	char str[32];
	pr_info("%s: enter\n", __func__);

	memset(str, 0, sizeof(str));
	exec_command("wpa_cli -iwlan0 scan", str, 32);

	if (0 != strncmp(str, "OK", 2) &&  0 != strncmp(str, "ok", 2)) {
		pr_info("scan error: %s\n", str);
		return -2;
	}

	return 0;
}

char* RK_wifi_scan_r(void)
{
	return RK_wifi_scan_r_sec(0x1F);
}

static char* RK_wifi_scan_softap(const unsigned int cols)
{
	char line[256], utf[256];
	char item[384];
	char col[128];
	char *scan_r, *p_strtok;
	size_t size = 0, index = 0;
	static size_t UNIT_SIZE = 512;
	FILE *fp = NULL;
	int is_utf8;
	int is_nonpsk;
	pr_info("%s: enter\n", __func__);

	if (!(cols & 0x1F)) {
		scan_r = (char*) malloc(3 * sizeof(char));
		memset(scan_r, 0, 3);
		strcpy(scan_r, "[]");
		return scan_r;
	}

	remove("/tmp/scan_r.tmp");
	exec_command_system("wpa_cli -iwlan0 scan_r > /tmp/scan_r.tmp");

	fp = fopen("/tmp/scan_r.tmp", "r");
	if (!fp)
		return NULL;

	memset(line, 0, sizeof(line));
	fgets(line, sizeof(line), fp);

	size += UNIT_SIZE;
	scan_r = (char*) malloc(size * sizeof(char));
	memset(scan_r, 0, size);
	strcat(scan_r, "[");

	m_gbk_head = encode_gbk_reset(m_gbk_head);
	m_nonpsk_head = encode_gbk_reset(m_nonpsk_head);
	while (fgets(line, sizeof(line) - 1, fp)) {
		index = 0;
		is_nonpsk = 0;
		p_strtok = strtok(line, "\t");
		memset(item, 0, sizeof(item));
		strcat(item, "{");
		while (p_strtok) {
			if (p_strtok[strlen(p_strtok) - 1] == '\n')
				p_strtok[strlen(p_strtok) - 1] = '\0';
			if ((cols & (1 << index)) || 3 == index) {
				memset(col, 0, sizeof(col));
				if (0 == index) {
					snprintf(col, sizeof(col), "\"bssid\":\"%s\",", p_strtok);
				} else if (1 == index) {
					snprintf(col, sizeof(col), "\"frequency\":%d,", atoi(p_strtok));
				} else if (2 == index) {
					snprintf(col, sizeof(col), "\"signalLevel\":%d,", atoi(p_strtok));
				} else if (3 == index) {
					if (cols & (1 << index)) {
						snprintf(col, sizeof(col), "\"flags\":\"%s\",", p_strtok);
					}
					if (!strstr(p_strtok, "WPA") && !strstr(p_strtok, "WEP")) {
						is_nonpsk = 1;
					}
				} else if (4 == index) {
					char utf8[strlen(p_strtok) + 1];
					memset(utf8, 0, sizeof(utf8));

					if (strlen(p_strtok) > 0) {
						char dst[strlen(p_strtok) + 1];
						memset(dst, 0, sizeof(dst));
						spec_char_convers(p_strtok, dst);

						// Strings that will send should retain escape characters
						// Strings whether GBK or UTF8 that need save local should remove escape characters
						// The ssid can't contains escape character while do connect
						is_utf8 = RK_encode_is_utf8(dst, strlen(dst));
						char utf8_noescape[sizeof(utf8)];
						char dst_noescape[sizeof(utf8)];
						memset(utf8_noescape, 0, sizeof(utf8_noescape));
						memset(dst_noescape, 0, sizeof(dst_noescape));
						if (!is_utf8) {
							RK_encode_gbk_to_utf8(dst, strlen(dst), utf8);
							remove_escape_character(dst, dst_noescape);
							remove_escape_character(utf8, utf8_noescape);
							m_gbk_head = encode_gbk_insert(m_gbk_head, dst_noescape, utf8_noescape);

							// if convert gbk to utf8 failed, ignore it
							if (!RK_encode_is_utf8(utf8, strlen(utf8))) {
								continue;
							}
						} else {
							strncpy(utf8, dst, strlen(dst));
							remove_escape_character(dst, dst_noescape);
							remove_escape_character(utf8, utf8_noescape);
						}

						// Decide whether encrypted or not
						if (is_nonpsk) {
							m_nonpsk_head = encode_gbk_insert(m_nonpsk_head, dst_noescape, utf8_noescape);
						}
					}
					snprintf(col, sizeof(col), "\"ssid\":\"%s\",", utf8);
				}
				strcat(item, col);
			}
			p_strtok = strtok(NULL, "\t");
			index++;
		}
		if (item[strlen(item) - 1] == ',') {
			item[strlen(item) - 1] = '\0';
		}
		strcat(item, "},");

		if (size <= (strlen(scan_r) + strlen(item)) + 3) {
			size += UNIT_SIZE;
			scan_r = (char*) realloc(scan_r, sizeof(char) * size);
		}
		strcat(scan_r, item);
	}
	if (scan_r[strlen(scan_r) - 1] == ',') {
		scan_r[strlen(scan_r) - 1] = '\0';
	}
	strcat(scan_r, "]");
	fclose(fp);
	return scan_r;
}

char *RK_wifi_scan_for_softap(void)
{
	return RK_wifi_scan_softap(0x1F);
}

char* RK_wifi_scan_r_sec(const unsigned int cols)
{
	char line[256], utf[256];
	char item[384];
	char col[128];
	char *scan_r, *p_strtok;
	size_t size = 0, index = 0;
	static size_t UNIT_SIZE = 512;
	FILE *fp = NULL;
	int is_utf8;
	int is_nonpsk;
	pr_info("%s: enter\n", __func__);

	if (!(cols & 0x1F)) {
		scan_r = (char*) malloc(3 * sizeof(char));
		memset(scan_r, 0, 3);
		strcpy(scan_r, "[]");
		return scan_r;
	}

	remove("/tmp/scan_r.tmp");
	exec_command_system("wpa_cli -iwlan0 scan_r > /tmp/scan_r.tmp");

	fp = fopen("/tmp/scan_r.tmp", "r");
	if (!fp)
		return NULL;

	memset(line, 0, sizeof(line));
	fgets(line, sizeof(line), fp);

	size += UNIT_SIZE;
	scan_r = (char*) malloc(size * sizeof(char));
	memset(scan_r, 0, size);
	strcat(scan_r, "[");

	m_gbk_head = encode_gbk_reset(m_gbk_head);
	m_nonpsk_head = encode_gbk_reset(m_nonpsk_head);
	while (fgets(line, sizeof(line) - 1, fp)) {
		index = 0;
		is_nonpsk = 0;
		p_strtok = strtok(line, "\t");
		memset(item, 0, sizeof(item));
		strcat(item, "{");
		while (p_strtok) {
			if (p_strtok[strlen(p_strtok) - 1] == '\n')
				p_strtok[strlen(p_strtok) - 1] = '\0';
			if ((cols & (1 << index)) || 3 == index) {
				memset(col, 0, sizeof(col));
				if (0 == index) {
					snprintf(col, sizeof(col), "\"bssid\":\"%s\",", p_strtok);
				} else if (1 == index) {
					snprintf(col, sizeof(col), "\"frequency\":%d,", atoi(p_strtok));
				} else if (2 == index) {
					snprintf(col, sizeof(col), "\"rssi\":%d,", atoi(p_strtok));
				} else if (3 == index) {
					if (cols & (1 << index)) {
						snprintf(col, sizeof(col), "\"flags\":\"%s\",", p_strtok);
					}
					if (!strstr(p_strtok, "WPA") && !strstr(p_strtok, "WEP")) {
						is_nonpsk = 1;
					}
				} else if (4 == index) {
					char utf8[strlen(p_strtok) + 1];
					memset(utf8, 0, sizeof(utf8));

					if (strlen(p_strtok) > 0) {
						char dst[strlen(p_strtok) + 1];
						memset(dst, 0, sizeof(dst));
						spec_char_convers(p_strtok, dst);

						// Strings that will send should retain escape characters
						// Strings whether GBK or UTF8 that need save local should remove escape characters
						// The ssid can't contains escape character while do connect
						is_utf8 = RK_encode_is_utf8(dst, strlen(dst));
						char utf8_noescape[sizeof(utf8)];
						char dst_noescape[sizeof(utf8)];
						memset(utf8_noescape, 0, sizeof(utf8_noescape));
						memset(dst_noescape, 0, sizeof(dst_noescape));
						if (!is_utf8) {
							RK_encode_gbk_to_utf8(dst, strlen(dst), utf8);
							remove_escape_character(dst, dst_noescape);
							remove_escape_character(utf8, utf8_noescape);
							m_gbk_head = encode_gbk_insert(m_gbk_head, dst_noescape, utf8_noescape);

							// if convert gbk to utf8 failed, ignore it
							if (!RK_encode_is_utf8(utf8, strlen(utf8))) {
								continue;
							}
						} else {
							strncpy(utf8, dst, strlen(dst));
							remove_escape_character(dst, dst_noescape);
							remove_escape_character(utf8, utf8_noescape);
						}

						// Decide whether encrypted or not
						if (is_nonpsk) {
							m_nonpsk_head = encode_gbk_insert(m_nonpsk_head, dst_noescape, utf8_noescape);
						}
					}
					snprintf(col, sizeof(col), "\"ssid\":\"%s\",", utf8);
				}
				strcat(item, col);
			}
			p_strtok = strtok(NULL, "\t");
			index++;
		}
		if (item[strlen(item) - 1] == ',') {
			item[strlen(item) - 1] = '\0';
		}
		strcat(item, "},");

		if (size <= (strlen(scan_r) + strlen(item)) + 3) {
			size += UNIT_SIZE;
			scan_r = (char*) realloc(scan_r, sizeof(char) * size);
		}
		strcat(scan_r, item);
	}
	if (scan_r[strlen(scan_r) - 1] == ',') {
		scan_r[strlen(scan_r) - 1] = '\0';
	}
	strcat(scan_r, "]");
	fclose(fp);
	return scan_r;
}

static int add_network()
{
	char ret[8];

	memset(ret, 0, sizeof(ret));
	exec_command("wpa_cli -iwlan0 add_network", ret, 8);

	if (0 == strlen(ret))
		return -1;

	return atoi(ret);
}

static int set_network(const int id, const char* ssid, const char* psk, const RK_WIFI_CONNECTION_Encryp_e encryp)
{
	int ret;
	char str[8];
	char cmd[512];
	char wifi_ssid[512];
	char wifi_psk[512];

	strcpy(wifi_ssid, ssid);
	strcpy(wifi_psk, psk);

	// 1. set network ssid
	memset(str, 0, sizeof(str));
	memset(cmd, 0, sizeof(cmd));
	format_wifiinfo(0, wifi_ssid);
	snprintf(cmd, sizeof(cmd), "wpa_cli -iwlan0 set_network %d ssid %s", id, wifi_ssid);
	exec_command(cmd, str, 8);
	if (0 == strlen(str) || 0 != strncmp(str, "OK", 2))
		return -1;

	// 2. set network psk
	memset(str, 0, sizeof(str));
	memset(cmd, 0, sizeof(cmd));
	if (strlen(psk) == 0 && encryp == NONE) {
		snprintf(cmd, sizeof(cmd), "wpa_cli -iwlan0 set_network %d key_mgmt NONE", id);
		exec_command(cmd, str, 8);
		if (0 == strlen(str) || 0 != strncmp(str, "OK", 2))
			return -2;
	}  else if (encryp == WEP) {
		snprintf(cmd, sizeof(cmd), "wpa_cli -iwlan0 set_network %d key_mgmt NONE", id);
		exec_command(cmd, str, 8);
		if (0 == strlen(str) || 0 != strncmp(str, "OK", 2))
			return -41;

		memset(str, 0, sizeof(str));
		memset(cmd, 0, sizeof(cmd));
		wep_id = id;

		if ((sizeof(psk) == 5) || (sizeof(psk) == 13) || (sizeof(psk) == 16))
			snprintf(cmd, sizeof(cmd), "wpa_cli -iwlan0 set_network %d wep_key0 \\\"%s\\\"", id, psk);
		else
			snprintf(cmd, sizeof(cmd), "wpa_cli -iwlan0 set_network %d wep_key0 %s", id, psk);
		exec_command(cmd, str, 8);
		if (0 == strlen(str) || 0 != strncmp(str, "OK", 2))
			return -42;

		memset(str, 0, sizeof(str));
		memset(cmd, 0, sizeof(cmd));
		snprintf(cmd, sizeof(cmd), "wpa_cli -iwlan0 set_network %d auth_alg SHARED", id);
		exec_command(cmd, str, 8);
		if (0 == strlen(str) || 0 != strncmp(str, "OK", 2))
			return -42;
	} else if (strlen(psk) || encryp == WPA) {
		format_wifiinfo(1, wifi_psk);
		snprintf(cmd, sizeof(cmd), "wpa_cli -iwlan0 set_network %d psk \\\"%s\\\"", id, wifi_psk);
		exec_command(cmd, str, 8);
		if (0 == strlen(str) || 0 != strncmp(str, "OK", 2))
			return -3;
	}

	return 0;
}

static int set_hide_network(const int id)
{
	int ret;
	char str[8];
	char cmd[128];

	memset(str, 0, sizeof(str));
	memset(cmd, 0, sizeof(cmd));
	snprintf(cmd, sizeof(cmd), "wpa_cli -iwlan0 set_network %d scan_ssid %d", id, 1);
	exec_command(cmd, str, 8);

	if (0 == strlen(str) || 0 != strncmp(str, "OK", 2))
		return -1;

	return 0;
}

static int clear_bssid_network(const int id)
{
	int ret;
	char str[8];
	char cmd[128];

	memset(str, 0, sizeof(str));
	memset(cmd, 0, sizeof(cmd));
	snprintf(cmd, sizeof(cmd), "wpa_cli -iwlan0 bssid %d 00:00:00:00:00:00", id);
	exec_command(cmd, str, 8);

	if (0 == strlen(str) || 0 != strncmp(str, "OK", 2)) {
		pr_err("clear_bssid_network fail!\n");
		return -1;
	}

	return 0;
}

static int select_network(const int id)
{
	int ret;
	char str[8];
	char cmd[128];

	clear_bssid_network(id);

	memset(str, 0, sizeof(str));
	memset(cmd, 0, sizeof(cmd));
	memset(retry_connect_cmd, 0, sizeof(retry_connect_cmd));
	snprintf(cmd, sizeof(cmd), "wpa_cli -iwlan0 select_network %d", id);
	snprintf(retry_connect_cmd, sizeof(retry_connect_cmd), "wpa_cli -iwlan0 select_network %d", id);
	exec_command(cmd, str, 8);

	if (0 == strlen(str) || 0 != strncmp(str, "OK", 2))
		return -1;

	return 0;
}

static int enable_network(const int id)
{
	int ret;
	char str[8];
	char cmd[128];

	memset(str, 0, sizeof(str));
	memset(cmd, 0, sizeof(cmd));
	snprintf(cmd, sizeof(cmd), "wpa_cli -iwlan0 enable_network %d", id);
	exec_command(cmd, str, 8);

	if (0 == strlen(str) || 0 != strncmp(str, "OK", 2))
		return -1;

	return 0;
}

static void rkwifi_check_ip(void)
{
	int i;
	RK_WIFI_INFO_Connection_s wifiinfo;
	RK_WIFI_RUNNING_State_e state = -1;
	pr_info("rkwifi_check_ip.\n");

	for (int i = 0; i < 30; i++) {
		usleep(500 * 1000);
		memset(&wifiinfo, 0, sizeof(RK_WIFI_INFO_Connection_s));
		_RK_wifi_running_getConnectionInfo(&wifiinfo);
		if (strncmp(wifiinfo.wpa_state, "COMPLETED", 9) == 0) {
			if ((strlen(wifiinfo.ip_address) != 0) &&
				strncmp(wifiinfo.ip_address, "127.0.0.1", 9) != 0) {
				pr_info("wifi got ip.\n");
				state = RK_WIFI_State_DHCP_OK;
				wifi_state_send(state, &wifiinfo);
				break;
			}
		}

		if (i > 13) {
			exec_command_system("killall dhcpcd");
			usleep(100000);
			exec_command_system("dhcpcd wlan0 -AL -t 0 &");
		}
	}

	pr_info("rkwifi_check_ip exit.\n");
}

#define WIFI_CONNECT_RETRY 50
static bool check_wifi_isconnected(void) {

	pr_info("check_wifi_isconnected\n");
	bool isWifiConnected = false;
	int connect_retry_count = WIFI_CONNECT_RETRY;
	RK_WIFI_INFO_Connection_s wifiinfo;
	int flag = 1;

	for (int i = 0; i < connect_retry_count; i++) {
		sleep(1);
		memset(&wifiinfo, 0, sizeof(RK_WIFI_INFO_Connection_s));
		_RK_wifi_running_getConnectionInfo(&wifiinfo);
		if (strncmp(wifiinfo.wpa_state, "COMPLETED", 9) == 0) {
			if ((strlen(wifiinfo.ip_address) != 0) &&
				strncmp(wifiinfo.ip_address, "127.0.0.1", 9) != 0) {
				isWifiConnected = true;
				pr_info("wifi is connected.\n");
				break;
			} else {
				if ((!(i%30)) || flag) {
					flag = 0;
					//exec_command_system("killall udhcpc");
					//usleep(300000);
					//exec_command_system("udhcpc -i wlan0 -t 10 &");
					exec_command_system("killall dhcpcd");
					usleep(300000);
					exec_command_system("dhcpcd wlan0 -AL -t 0 &");
				}
			}
		} else if (i == 20) {
			pr_info("check_wifi_isconnected is still not COMPLETED! break \n");
			break;
		}

		pr_info("Check wifi state with none state. try more %d/%d, \n", i + 1, WIFI_CONNECT_RETRY);

		if (wifi_onoff_flag == false) {
			pr_info("check_wifi_isconnected is wifi_onoff_flag false break.\n");
			break;
		}

		if (wifi_wrong_key == true) {
			pr_info("check_wifi_isconnected is wifi_wrong_key break.\n");
			break;
		}

		if (wpa_exit == true) {
			pr_info("check_wifi_isconnected is wpa_exit break.\n");
			break;
		}

		if (wifi_cancel == true) {
			pr_info("check_wifi_isconnected wifi_cancel be called so break.\n");
			//exec_command_system("wpa_cli flush");
			//exec_command_system("wpa_cli reconfigure");
			//exec_command_system("wpa_cli -iwlan0 disable_network all");
			//wifi_cancel = false;
			break;
		}
	}

	if (!isWifiConnected)
		pr_info("wifi is not connected.\n");

	return isWifiConnected;
}

static void format_wifiinfo(int flag, char *info)
{
	char temp[1024];
	int j = 0;

	if (flag == 0) {
		for (int i = 0; i < strlen(info); i++) {
			sprintf(temp+2*i, "%02x", info[i]);
		}
		temp[strlen(info)*2] = '\0';
		strcpy(info, temp);
		pr_info("format_wifiinfo ssid: %s\n", info);
    } else if (flag == 1) {
		for (int i = 0; i < strlen(info); i++) {
		temp[j++] = '\\';
		temp[j++] = info[i];
		}
		temp[j] = '\0';
		strcpy(info, temp);
		pr_info("format_wifiinfo password: %s\n", info);
	}
}

static int set_priority_network(const int id, int priority)
{
	int ret;
	char str[8];
	char cmd[128];

	memset(str, 0, sizeof(str));
	memset(cmd, 0, sizeof(cmd));
	snprintf(cmd, sizeof(cmd), "wpa_cli -iwlan0 set_network %d priority %d", id, priority);
	exec_command(cmd, str, 8);

	if (0 == strlen(str) || 0 != strncmp(str, "OK", 2))
		return -1;

	return 0;
}

static void set_network_highest_priority(const int id)
{
	char str[128];
	int cnt;
	int network_id;
	char cmd[128];

	exec_command("wpa_cli -i wlan0 list_network | wc -l", str, 128);
	cnt = atoi(str) - 1;
	pr_info("wifi cnt: %d(%s)\n", cnt, str);

	for (int i = 0; i < cnt; i++) {
		snprintf(cmd, sizeof(cmd), "wpa_cli -i wlan0 list_network | awk '{print $1}' | sed -n %dp", i+2);
		exec_command(cmd, str, 128);
		network_id = atoi(str);

		if (network_id == id)
			set_priority_network(network_id, cnt);
		else
			set_priority_network(network_id, 1);
	}
}

static int disable_no_connected_ssid(void)
{

	RK_WIFI_INFO_Connection_s info;
	char str[128];
	int cnt;
	int network_id;
	char cmd[128];

	pr_info("### %s ###\n", __func__);
	if (_RK_wifi_running_getConnectionInfo(&info) < 0)
		return -1;

	memset(str, 0, 128);
	exec_command("wpa_cli -i wlan0 list_network | wc -l", str, 128);
	cnt = atoi(str) - 1;
	pr_info("save_configuration wifi cnt: %d(%s)\n", cnt, str);

	for (int i = 0; i < cnt; i++) {
		memset(cmd, 0, 128);
		snprintf(cmd, sizeof(cmd), "wpa_cli -i wlan0 list_network | awk '{print $1}' | sed -n %dp", i+2);
		exec_command(cmd, str, 128);
		network_id = atoi(str);

		if (network_id != info.id) {
			memset(cmd, 0, 128);
			snprintf(cmd, sizeof(cmd), "wpa_cli -i wlan0 disable_network %d", network_id);
			exec_command_system(cmd);
		}
	}

	return 0;
}

static int save_configuration()
{
	//exec_command_system("wpa_cli -iwlan0 enable_network all");
	exec_command_system("wpa_cli -iwlan0 save_config");
	exec_command_system("sync");

	return 0;
}

static void check_ping_test()
{
	char line[1024];
	int ping_retry = 1;
	int dns_retry = 5;

	memset(line, 0, sizeof(line));
	pr_info("check dns\n");
	while (dns_retry--) {
		exec_command("cat /etc/resolv.conf", line, 1024);
		if (strstr(line, "nameserver"))
			break;
		sleep(1);
	}
	pr_info("dns ok: %s\n", line);

#if 0
	while (ping_retry--) {
		dns_retry = 5;
		memset(line, 0, sizeof(line));
		pr_info("check dns\n");
		while (dns_retry--) {
			exec_command("cat /etc/resolv.conf", line, 1024);
			if (strstr(line, "nameserver"))
				break;
			sleep(1);
		}
		pr_info("dns ok: %s\n", line);
		pr_info("to ping\n");
		sync();
		sleep(1);
		memset(line, 0, sizeof(line));
		exec_command("ping www.baidu.com -c 1", line, 1024);
		//usleep(100000);
		pr_info("line: %s\n", line);
		//if (strstr(line, "PING www.baidu.com") && strstr(line, "bytes from")) {
		//if (strstr(line, "PING 8.8.8.8") && strstr(line, "bytes from")) {
		if (strstr(line, "bytes from")) {
			pr_info("ping ok\n");
			break;
		}
		usleep(200000);
	}
#endif
}

static void wifi_connectfail_process(int id)
{
	char str[128];
	char cmd1[128];
	char cmd2[128];

	pr_info("### %s ###\n", __func__);

	memset(str, 0, sizeof(str));
	memset(cmd1, 0, sizeof(cmd1));

	snprintf(cmd1, sizeof(cmd1), "wpa_cli -iwlan0 disable_network %d", id);
	snprintf(cmd2, sizeof(cmd2), "wpa_cli -iwlan0 remove_network %d", id);

	if (wifi_is_exist == true) {
		exec_command(cmd1, str, 128);
	} else {
		exec_command(cmd2, str, 128);
	}

	exec_command_system("wpa_cli -i wlan0 save_config");
	//exec_command_system("wpa_cli flush");
	//exec_command_system("wpa_cli reconfigure");
	//exec_command_system("wpa_cli reconnect");
}

static void* wifi_connect_state_check(void *arg)
{
	RK_WIFI_RUNNING_State_e state = 0;
	bool isconnected;
	RK_WIFI_INFO_Connection_s cndinfo;
	int id = *((int *)arg);

	prctl(PR_SET_NAME,"wifi_connect_state_check");
	pr_info("[%s]\n", __func__);

	isconnected = check_wifi_isconnected();
	pr_info("[RKWIFI]: %s: %d : %d\n", __func__, isconnected, wifi_wrong_key);

	if (isconnected == 1) {
		char cmd[128];
		char str[8];
		RK_WIFI_SAVED_INFO_s *wsi = NULL;
		int ap_cnt = 0;

		//_RK_wifi_running_getConnectionInfo(&cndinfo);
		//snprintf(cmd, sizeof(cmd), "wpa_cli -iwlan0 bssid %d %s", cndinfo.id, cndinfo.bssid);
		//exec(cmd, str);
		//pr_info("set bssid: %s\n", cmd);

		_RK_wifi_getSavedInfo(&wsi, &ap_cnt);
		if (wsi != NULL)
			free(wsi);

		save_configuration();
		check_ping_test();
		state = RK_WIFI_State_DHCP_OK;
	} else {
		if (wifi_wrong_key == false)
			state = RK_WIFI_State_CONNECTFAILED;
		wifi_connectfail_process(id);
	}

	if (state == 0)
		goto end;

	wifi_state_send(state, NULL);

end:
	wifi_is_exist = false;
	wifi_connect_lock = false;
	is_wep = false;
	wifi_cancel = false;
	pr_info("[%s exit]\n", __func__);

	if (isconnected == false) {
		exec_command_system("wpa_cli -i wlan0 enable_network all");
		exec_command_system("wpa_cli -i wlan0 reconnect");
	}

	return NULL;
}

void save_connect_info(char* ssid, char *bssid)
{
	int len;

	memset(&connect_info, 0, sizeof(RK_WIFI_CONNECT_INFO));

	if(ssid) {
		len = SSID_BUF_LEN > strlen(ssid) ? strlen(ssid) : SSID_BUF_LEN;
		strncpy(connect_info.ssid, ssid, len);
	}

	if(bssid) {
		len = BSSID_BUF_LEN > strlen(bssid) ? strlen(bssid) : BSSID_BUF_LEN;
		strncpy(connect_info.bssid, bssid, len);
	}
}

int RK_wifi_connect_wep(char* ssid, const char* psk)
{
	int ret = 0;

	if(!ssid) {
		pr_err("%s: invalid ssid\n", __func__);
		return -1;
	}

	if (wifi_connect_lock == true) {
		pr_err("RK_wifi_connect to %s but prev connecting! now return\n", ssid);
		return -1;
	}

	wifi_connect_lock = true;
	is_wep = true;
	ret = RK_wifi_connect1(ssid, psk, WEP, 0);

	return ret;
}

int RK_wifi_connect(char* ssid, const char* psk)
{
	int ret = 0;

	if(!ssid) {
		pr_err("%s: invalid ssid\n", __func__);
		return -1;
	}

	if (wifi_connect_lock == true) {
		pr_err("RK_wifi_connect to %s but prev connecting! now return\n", ssid);
		return -1;
	}

	wifi_connect_lock = true;
	ret = RK_wifi_connect1(ssid, psk, WPA, 0);

	return ret;
}

int RK_wifi_connect1(char* ssid, const char* psk, const RK_WIFI_CONNECTION_Encryp_e encryp, const int hide)
{
	int id, ret;
	char ori[strlen(ssid) + 1];

	if(!ssid) {
		pr_err("%s: invalid ssid\n", __func__);
		return -1;
	}
	pr_info("[%s] ssid: %s, psk: %s\n", __func__, ssid, psk);

	save_connect_info(ssid, NULL);
	wifi_state_send(RK_WIFI_State_CONNECTING, NULL);

	exec_command_system("wpa_cli -iwlan0 disable_network all");
	wifi_wrong_key = false;
	usleep(60000);

	if (save_last_ap) {
		exec_command_system("cp /data/cfg/wpa_supplicant.conf /data/cfg/wpa_supplicant.conf.bak");
		exec_command_system("wpa_cli flush");
		sleep(100000);
		exec_command_system("wpa_cli save_config");
	}

	if ((id = RK_wifi_search_with_ssid(ssid)) < 0) {
		id = add_network();
		if (id < 0) {
			pr_err("add_network id: %d failed!\n", id);
			goto fail;
		}
	}

	connecting_id = id;

	memset(ori, 0, sizeof(ori));
	if ((psk == NULL) || is_non_psk(ssid)) {
		pr_info("%s: is none psk, ssid:\"%s\" ssid_len:%lu\n", __func__, ssid, strlen(ssid));
		get_encode_gbk_ori(m_nonpsk_head, ssid, ori);

		ret = set_network(id, ori, "", NONE);
		if (0 != ret) {
			pr_info("%s: set_network failed. ssid:\"%s\"\n", __func__, ssid);
			goto fail;
		}
	} else {
		pr_info("%s: ssid:\"%s\" ssid_len:%lu; psk:\"%s\", encryp: %d.\n", __func__, ssid, strlen(ssid), psk, encryp);
		get_encode_gbk_ori(m_gbk_head, ssid, ori);

		ret = set_network(id, ori, psk, encryp);
		if (0 != ret) {
			pr_info("%s: set_network failed. ssid:\"%s\", psk:\"%s\"\n", __func__, ssid, psk);
			goto fail;
		}
	}
	pr_info("%s: ori:\"%s\" ori_len:%lu\n", __func__, ori, strlen(ori));

	set_network_highest_priority(id);

	ret = set_hide_network(id);
	if (0 != ret) {
		pr_err("%s: set_hide_network id: %d failed!\n", __func__, id);
		goto fail;
	}

	ret = select_network(id);
	if (0 != ret) {
		pr_err("%s: select_network id: %d failed!\n", __func__, id);
		goto fail;
	}

	ret = enable_network(id);
	if (0 != ret) {
		pr_err("%s: enable_network id: %d failed!\n", __func__, id);
		goto fail;
	}

	pthread_t pth;
	pthread_create(&pth, NULL, wifi_connect_state_check, &connecting_id);
	pthread_detach(pth);

	return 0;

fail:
	wifi_state_send(RK_WIFI_State_CONNECTFAILED, NULL);
	wifi_connect_lock = false;
	is_wep = false;
	return -1;
}

int RK_wifi_forget_with_ssid(char *ssid)
{
	int id, ret;
	char cmd[64];
	char str[8];

	pr_info("[%s]: ssid %s\n", __func__, ssid);

	if(!ssid) {
		pr_err("%s: ssid is null\n", __func__);
		return -1;
	}

	id = RK_wifi_search_with_ssid(ssid);
	if (id < 0) {
		pr_err("RK_wifi_forget_with_ssid [%s] not found!\n", ssid);
		return -1;
	}

	snprintf(cmd, sizeof(cmd), "wpa_cli -iwlan0 remove_network %d", id);
	exec_command(cmd, str, 8);
	if (0 == strlen(str) || 0 != strncmp(str, "OK", 2))
		return -1;

	exec_command_system("wpa_cli -iwlan0 save");

	return 0;
}

int RK_wifi_forget_with_bssid(const char *bssid)
{
	int id, ret;
	char cmd[64];
	char str[8];

	if(!bssid) {
		pr_err("%s: bssid is null\n", __func__);
		return -1;
	}

	if(strlen(bssid) < 17) {
		pr_err("%s: invalid bssid %s\n", __func__, bssid);
		return -1;
	}

	id = RK_wifi_search_with_bssid(bssid);
	if (id < 0) {
		pr_err("RK_wifi_forget_with_bssid %d not found!\n", id);
		return -1;
	}
	
	snprintf(cmd, sizeof(cmd), "wpa_cli -iwlan0 remove_network %d", id);
	exec_command(cmd, str, 8);

	if (0 == strlen(str) || 0 != strncmp(str, "OK", 2))
		return -1;

	exec_command_system("wpa_cli -iwlan0 save");
	exec_command_system("sync");

	return 0;
}

int RK_wifi_cancel(void)
{
	int timeout = 8;

	if (wifi_connect_lock == false) {
		pr_info("wifi dont connecting!");
		return -1;
	}

	wifi_cancel = true;

	while (timeout--) {
		if (wifi_cancel == false)
			break;
		sleep(1);
	}

	if (wifi_cancel == false)
		return 0;
	else
		return -1;
}

int RK_wifi_connect_with_ssid(char *ssid)
{
	int id, ret;

	if (wifi_connect_lock == true) {
		pr_err("RK_wifi_connect_with_ssid to %s but prev connecting! now return\n", ssid);
		return -1;
	}

	wifi_connect_lock = true;
	wifi_wrong_key = false;
	wifi_is_exist = true;

	pr_err("%s: %s\n", __func__, ssid);

	if(!ssid) {
		pr_err("%s: ssid is null\n", __func__);
		goto fail;
	}

	id = RK_wifi_search_with_ssid(ssid);
	if (id < 0) {
		pr_err("RK_wifi_connect_with_bssid %d not found!\n", id);
		goto fail;
	}

	connecting_id = id;

	save_connect_info(NULL, ssid);
	wifi_state_send(RK_WIFI_State_CONNECTING, NULL);

	exec_command_system("wpa_cli -iwlan0 disable_network all");

	ret = select_network(id);
	if (0 != ret) {
		pr_err("select_network id: %d failed!\n", id);
		goto fail;
	}

	set_network_highest_priority(id);

	ret = enable_network(id);
	if (0 != ret) {
		pr_err("enable_network id: %d failed!\n", id);
		goto fail;
	}

	pthread_t pth;
	pthread_create(&pth, NULL, wifi_connect_state_check, &connecting_id);
	pthread_detach(pth);

	return 0;

fail:
	wifi_state_send(RK_WIFI_State_CONNECTFAILED, NULL);
	wifi_is_exist = false;
	wifi_connect_lock = false;
	return -1;
}

int RK_wifi_connect_with_bssid(const char *bssid)
{
	int id, ret;

	wifi_wrong_key = false;

	pr_err("%s: %s\n", __func__, bssid);

	if(!bssid) {
		pr_err("%s: bssid is null\n", __func__);
		return -1;
	}

	if(strlen(bssid) < 17) {
		pr_err("%s: invalid bssid %s\n", __func__, bssid);
		return -1;
	}

	id = RK_wifi_search_with_bssid(bssid);
	if (id < 0) {
		pr_err("RK_wifi_connect_with_bssid %d not found!\n", id);
		return -1;
	}

	connecting_id = id;

	save_connect_info(NULL, bssid);
	wifi_state_send(RK_WIFI_State_CONNECTING, NULL);

	exec_command_system("wpa_cli -iwlan0 disable_network all");

	ret = select_network(id);
	if (0 != ret) {
		pr_err("select_network id: %d failed!\n", id);
		goto fail;
	}

	set_network_highest_priority(id);

	ret = enable_network(id);
	if (0 != ret) {
		pr_err("enable_network id: %d failed!\n", id);
		goto fail;
	}

	pthread_t pth;
	pthread_create(&pth, NULL, wifi_connect_state_check, &connecting_id);
	pthread_detach(pth);

	return 0;

fail:
	wifi_state_send(RK_WIFI_State_CONNECTFAILED, NULL);
	return -1;
}

int RK_wifi_disconnect_network(void)
{
	exec_command_system("wpa_cli -iwlan0 disconnect");
	return 0;
}

int RK_wifi_restart_network(void)
{
	return 0;
}

int RK_wifi_set_hostname(const char* name)
{
	if(!name) {
		pr_err("%s: name is null\n", __func__);
		return -1;
	}

	sethostname(name, strlen(name));
	return 0;
}

int RK_wifi_get_hostname(char* name, int len)
{
	if (name)
		gethostname(name, len);

	return 0;
}

int RK_wifi_reset(void)
{
	if (get_pid("wpa_supplicant")) {
		exec_command_system("wpa_cli -i wlan0 flush");
		exec_command_system("wpa_cli -i wlan0 save");
	} else {
		exec_command_system("rm /data/cfg/wpa_supplicant.conf");
		exec_command_system("cp /etc/wpa_supplicant.conf /data/cfg/wpa_supplicant.conf");
	}
	exec_command_system("sync");

	return 1;
}

int RK_wifi_recovery(void)
{
	if (save_last_ap) {
		exec_command_system("cp /data/cfg/wpa_supplicant.conf.bak /data/cfg/wpa_supplicant.conf");
	}

	exec_command_system("wpa_cli -i wlan0 flush");
	exec_command_system("wpa_cli -i wlan0 reconfigure");
	exec_command_system("wpa_cli -i wlan0 reconnect");

	return 1;
}

int RK_wifi_get_mac(char *wifi_mac)
{
	int sock_mac;
	struct ifreq ifr_mac;
	char mac_addr[18] = {0};

	if(!wifi_mac) {
		pr_err("%s: wifi_mac is null\n", __func__);
		return -1;
	}

	sock_mac = socket(AF_INET, SOCK_STREAM, 0);

	if (sock_mac == -1) {
		pr_info("create mac socket failed.");
		return -1;
	}

	memset(&ifr_mac, 0, sizeof(ifr_mac));
	strncpy(ifr_mac.ifr_name, "wlan0", sizeof(ifr_mac.ifr_name) - 1);

	if ((ioctl(sock_mac, SIOCGIFHWADDR, &ifr_mac)) < 0) {
		pr_info("Mac socket ioctl failed.");
		return -1;
	}

	sprintf(mac_addr, "%02X:%02X:%02X:%02X:%02X:%02X",
			(unsigned char)ifr_mac.ifr_hwaddr.sa_data[0],
			(unsigned char)ifr_mac.ifr_hwaddr.sa_data[1],
			(unsigned char)ifr_mac.ifr_hwaddr.sa_data[2],
			(unsigned char)ifr_mac.ifr_hwaddr.sa_data[3],
			(unsigned char)ifr_mac.ifr_hwaddr.sa_data[4],
			(unsigned char)ifr_mac.ifr_hwaddr.sa_data[5]);

	close(sock_mac);
	strncpy(wifi_mac, mac_addr, 18);
	pr_info("the wifi mac : %s\r\n", wifi_mac);

	return 0;
}

int RK_wifi_has_config()
{
	FILE *fd;
	fd = fopen("/data/cfg/wpa_supplicant.conf", "r");
	if (fd == NULL)
		return 0;

	fseek(fd, 0L, SEEK_END);
	int len = ftell(fd);
	char *buf = (char *)malloc(len + 1);
	fseek(fd, 0L, SEEK_SET);
	fread(buf, 1, len, fd);
	fclose(fd);

       buf[len] = '\0';
	if (strstr(buf, "network") && strstr(buf, "ssid")) {
		free(buf);
		return 1;
	}

	free(buf);
	return 0;
}

int RK_wifi_ping(char *address)
{
	//return rk_ping(address);
	return 0;
}

#include <linux/if.h>
#include <linux/if_packet.h>
#include <arpa/inet.h>

#define WLC_GET_RSSI			127
/* Linux network driver ioctl encoding */
typedef struct wl_ioctl {
	uint cmd;	/**< common ioctl definition */
	void *buf;	/**< pointer to user buffer */
	uint len;	/**< length of user buffer */
	unsigned char set;	/**< 1=set IOCTL; 0=query IOCTL */
	uint used;	/**< bytes read or written (optional) */
	uint needed;	/**< bytes needed (optional) */
} wl_ioctl_t;

int RK_wifi_get_connected_ap_rssi(void)
{
	wl_ioctl_t ioc;
	int ret = 0;
	int s;
	struct ifreq ifr;
	int rssi = 0;

	sprintf(ifr.ifr_name, "%s", "wlan0");

	s = socket(AF_INET, SOCK_DGRAM, 0);
	if (s < 0)
	{
		printf("create socket error = %d\n", s);
		return -1;
	}

	ioc.cmd = WLC_GET_RSSI;
	ioc.buf = &rssi;
	ioc.len = 4;
	ioc.set = false;
	ifr.ifr_data = (caddr_t)&ioc;

	ret = ioctl(s, SIOCDEVPRIVATE, &ifr);
	if (ret < 0)
	{
		printf("ioctl err = %d\n", ret);
	}

	printf("ioctl rssi = %d\n", rssi);

	close(s);

	return rssi;
}

#define EVENT_BUF_SIZE 1024
#define PROPERTY_VALUE_MAX 32
#define PROPERTY_KEY_MAX 32
#include <poll.h>
#include <wpa_ctrl.h>
static const char WPA_EVENT_IGNORE[]    = "CTRL-EVENT-IGNORE ";
static const char IFNAME[]              = "IFNAME=";
static const char IFACE_DIR[]           = "/var/run/wpa_supplicant";
#define WIFI_CHIP_TYPE_PATH				"/sys/class/rkwifi/chip"
#define WIFI_DRIVER_INF         		"/sys/class/rkwifi/driver"
#define IFNAMELEN                       (sizeof(IFNAME) - 1)
static struct wpa_ctrl *ctrl_conn;
static struct wpa_ctrl *monitor_conn;
#define DBG_NETWORK 1

static int exit_sockets[2];
static char primary_iface[PROPERTY_VALUE_MAX] = "wlan0";

#define HOSTAPD "hostapd"
#define WPA_SUPPLICANT "wpa_supplicant"
#define DNSMASQ "dnsmasq"
#define SIMPLE_CONFIG "simple_config"
#define SMART_CONFIG "smart_config"
#define UDHCPC "udhcpc"

static int get_pid(const char Name[]) {
    int len;
    char name[32] = {0};
    len = strlen(Name);
    strncpy(name,Name,len);
    name[31] ='\0';
    char cmdresult[256] = {0};
    char cmd[64] = {0};
    FILE *pFile = NULL;
    int  pid = 0;

    sprintf(cmd, "pidof %s", name);
    pFile = popen(cmd, "r");
    if (pFile != NULL)  {
        while (fgets(cmdresult, sizeof(cmdresult), pFile)) {
            pid = atoi(cmdresult);
            break;
        }
        pclose(pFile);
    }
    return pid;
}

static void wifi_close_sockets() {
	pr_info("########### %s ###############\n", __func__);
	if (ctrl_conn != NULL) {
		wpa_ctrl_close(ctrl_conn);
		ctrl_conn = NULL;
	}

	if (monitor_conn != NULL) {
		wpa_ctrl_close(monitor_conn);
		monitor_conn = NULL;
	}

	if (exit_sockets[0] >= 0) {
		close(exit_sockets[0]);
		exit_sockets[0] = -1;
	}

	if (exit_sockets[1] >= 0) {
		close(exit_sockets[1]);
		exit_sockets[1] = -1;
	}
}

static int str_starts_with(char * str, char * search_str)
{
	if ((str == NULL) || (search_str == NULL))
		return 0;
	return (strstr(str, search_str) == str);
}

static void get_wifi_info_by_event(char *event, RK_WIFI_RUNNING_State_e state, RK_WIFI_INFO_Connection_s *info)
{
	int len = 0;
	char buf[10];
	char *start_tag = NULL, *end_tag = NULL, *id_tag = NULL, *reason_tag = NULL;

	if(event == NULL)
		return;

	memset(info, 0, sizeof(RK_WIFI_INFO_Connection_s));
	_RK_wifi_running_getConnectionInfo(info);

	switch(state) {
	case RK_WIFI_State_DISCONNECTED:
		start_tag = strstr(event, "bssid=");
		if(start_tag)
			strncpy(info->bssid, start_tag + strlen("bssid="), 17);

		//strncpy(info->ssid, connect_info.ssid, SSID_BUF_LEN);
		reason_tag =  strstr(event, "reason=");
		if(reason_tag) {
			memset(buf, 0, sizeof(buf));
			strncpy(buf, reason_tag + strlen("reason="), 2);
			info->reason = atoi(buf);
		}

		break;

	case RK_WIFI_State_CONNECTFAILED_WRONG_KEY:
		start_tag = strstr(event, "ssid=\"");
		if(start_tag) {
			end_tag = strstr(event, "\" auth_failures");
			if(!end_tag) {
				pr_err("%s: don't find end tag\n", __func__);
				break;
			}
			len = strlen(start_tag) - strlen(end_tag) - strlen("ssid=\"");
			char value[256] = {0};
			char sname[256];
			char sname1[256];
			char utf8[256];
			memset(sname, 0, sizeof(sname));
			memset(sname1, 0, sizeof(sname));
			memset(utf8, 0, sizeof(utf8));
			strncpy(value, start_tag + strlen("ssid=\""), len);
			pr_info("%s: check len value: %d\n", __func__, strlen(value));
			spec_char_convers(value, sname);
			remove_escape_character(sname, sname1);
			get_encode_gbk_utf8(m_gbk_head, sname1, utf8);
			pr_info("convers str: %s, sname: %s, ori: %s\n", value, sname1, utf8);
			strncpy(info->ssid,  utf8, strlen(utf8));
		}

		id_tag =  strstr(event, "id=");
		if(id_tag) {
			len = strlen(id_tag) - strlen("id=") - strlen(start_tag) - 1;
			memset(buf, 0, sizeof(buf));
			strncpy(buf, id_tag + strlen("id="), len);
			info->id = atoi(buf);

			//memset(cmd, 0, 128);
			//snprintf(cmd, sizeof(cmd), "wpa_cli -i wlan0 remove_network %d", info->id);
			//exec_command_system(cmd);
			//exec_command_system("wpa_cli -i wlan0 save_config");
		}

		strncpy(info->bssid, connect_info.bssid, BSSID_BUF_LEN);
		break;
	}
}

static void get_valid_connect_info(RK_WIFI_INFO_Connection_s *info)
{
	int count = 10;

	while(count--) {
		_RK_wifi_running_getConnectionInfo(info);
		if(!info->id && !strlen(info->ssid)
				&& !strlen(info->bssid) && !info->freq
				&& !strlen(info->mode) && !strlen(info->ip_address)
				&& !strlen(info->mac_address) && !strlen(info->wpa_state)) {
			pr_info("wait to get valid connect info\n");
			usleep(100000);
		} else {
			break;
		}
	}
}

static int dispatch_event(char* event)
{
	RK_WIFI_INFO_Connection_s info;

	if (strstr(event, "CTRL-EVENT-BSS") || strstr(event, "CTRL-EVENT-TERMINATING"))
		return 0;

	pr_info("%s: %s\n", __func__, event);

	if (str_starts_with(event, (char *)WPA_EVENT_DISCONNECTED)) {
		pr_info("%s: wifi is disconnect\n", __FUNCTION__);
		exec_command_system("ip addr flush dev wlan0");
		get_wifi_info_by_event(event, RK_WIFI_State_DISCONNECTED, &info);
		wifi_state_send(RK_WIFI_State_DISCONNECTED, &info);
		if (wifi_connect_lock == false) {
			exec_command_system("wpa_cli -i wlan0 enable_network all");
			exec_command_system("wpa_cli -i wlan0 reconnect");
		}
	} else if (str_starts_with(event, (char *)WPA_EVENT_CONNECTED)) {
		pr_info("%s: wifi is connected\n", __func__);
		get_valid_connect_info(&info);
		wifi_state_send(RK_WIFI_State_CONNECTED, &info);
		disable_no_connected_ssid();
		if (wifi_connect_lock == false) {
			rkwifi_check_ip();
		}
	} else if (str_starts_with(event, (char *)WPA_EVENT_SCAN_RESULTS)) {
		pr_info("%s: wifi event results\n", __func__);
		exec_command_system("echo 1 > /tmp/scan_r");
		wifi_state_send(RK_WIFI_State_SCAN_RESULTS, NULL);
	} else if (strstr(event, "reason=WRONG_KEY")) {
		wifi_wrong_key = true;
		pr_info("%s: wifi reason=WRONG_KEY \n", __func__);
		get_wifi_info_by_event(event, RK_WIFI_State_CONNECTFAILED_WRONG_KEY, &info);
		wifi_state_send(RK_WIFI_State_CONNECTFAILED_WRONG_KEY, &info);
	} else if (str_starts_with(event, (char *)WPA_EVENT_TERMINATING)) {
		pr_info("%s: wifi is WPA_EVENT_TERMINATING!\n", __func__);
		wifi_close_sockets();
		return -1;
	}

	if (is_wep && strstr(event, "CTRL-EVENT-ASSOC-REJECT") && strstr(event, "status_code=13")) {
		char cmd[128];
		memset(cmd, 0, 128);
		snprintf(cmd, sizeof(cmd), "wpa_cli -i wlan0 set_network %d auth_alg OPEN", wep_id);
		exec_command_system(cmd);
		memset(cmd, 0, 128);
		snprintf(cmd, sizeof(cmd), "wpa_cli -i wlan0 select_network %d", wep_id);
		exec_command_system(cmd);
	}

	return 0;
}

static int check_wpa_supplicant_state() {
	int count = 5;
	int wpa_supplicant_pid = 0;
	wpa_supplicant_pid = get_pid(WPA_SUPPLICANT);
	//pr_info("%s: wpa_supplicant_pid = %d\n",__FUNCTION__,wpa_supplicant_pid);
	if(wpa_supplicant_pid > 0) {
		return 1;
	}

	pr_info("%s: wpa abort exit!!!\n",__FUNCTION__);
	return 0;
}

static int wifi_ctrl_recv(char *reply, size_t *reply_len)
{
	int res;
	int ctrlfd = wpa_ctrl_get_fd(monitor_conn);
	struct pollfd rfds[2];

	memset(rfds, 0, 2 * sizeof(struct pollfd));
	rfds[0].fd = ctrlfd;
	rfds[0].events |= POLLIN;
	rfds[1].fd = exit_sockets[1];
	rfds[1].events |= (POLLIN|POLLERR);
	do {
		res = poll(rfds, 2, 1000);
		if (res < 0) {
			pr_info("Error poll = %d\n", res);
			return res;
		} else if (res == 0) {
			/* timed out, check if supplicant is activeor not .. */
			res = check_wpa_supplicant_state();
			if (res < 0)
				return -2;
		}

		if (wifi_onoff_flag == false) {
			pr_info("------  exit wifi_ctrl_recv ------------\n");
			wpa_exit = true;
			return -4;
		}
	} while (res == 0);

	if (rfds[0].revents & POLLIN) {
		return wpa_ctrl_recv(monitor_conn, reply, reply_len);
	}

	if (rfds[1].revents) {
		pr_info("------    0x%x ignore------------\n", rfds[1].revents);
		//wpa_exit = true;
		//return -3;
	}

	return -2;
}

static int wifi_wait_on_socket(char *buf, size_t buflen)
{
	size_t nread = buflen - 1;
	int result;
	char *match, *match2;

	if (monitor_conn == NULL) {
		return snprintf(buf, buflen, "IFNAME=%s %s - connection closed",
			primary_iface, WPA_EVENT_TERMINATING);
	}

	result = wifi_ctrl_recv(buf, &nread);

	/* Terminate reception on exit socket */
	if (result == -2) {
		return snprintf(buf, buflen, "IFNAME=%s %s - connection closed",
			primary_iface, WPA_EVENT_TERMINATING);
	}

	if (result < 0) {
		//pr_info("wifi_ctrl_recv failed: %s\n", strerror(errno));
		//return snprintf(buf, buflen, "IFNAME=%s %s - recv error",
		//	primary_iface, WPA_EVENT_TERMINATING);
	}

	buf[nread] = '\0';

	/* Check for EOF on the socket */
	if (result == 0 && nread == 0) {
		/* Fabricate an event to pass up */
		pr_info("Received EOF on supplicant socket\n");
		return snprintf(buf, buflen, "IFNAME=%s %s - signal 0 received",
			primary_iface, WPA_EVENT_TERMINATING);
	}

	if (strncmp(buf, IFNAME, IFNAMELEN) == 0) {
		match = strchr(buf, ' ');
		if (match != NULL) {
			if (match[1] == '<') {
				match2 = strchr(match + 2, '>');
					if (match2 != NULL) {
						nread -= (match2 - match);
						memmove(match + 1, match2 + 1, nread - (match - buf) + 1);
					}
			}
		} else {
			return snprintf(buf, buflen, "%s", WPA_EVENT_IGNORE);
		}
	} else if (buf[0] == '<') {
		match = strchr(buf, '>');
		if (match != NULL) {
			nread -= (match + 1 - buf);
			memmove(buf, match + 1, nread + 1);
			if (0)
				pr_info("supplicant generated event without interface - %s\n", buf);
		}
	} else {
		if (0)
			pr_info("supplicant generated event without interface and without message level - %s\n", buf);
	}

	return nread;
}

static int wifi_connect_on_socket_path(const char *path)
{
	char supp_status[PROPERTY_VALUE_MAX] = {'\0'};

	if(!check_wpa_supplicant_state()) {
		pr_info("%s: wpa_supplicant is not ready\n",__FUNCTION__);
		return -1;
	}

	ctrl_conn = wpa_ctrl_open(path);
	if (ctrl_conn == NULL) {
		pr_info("Unable to open connection to supplicant on \"%s\": %s\n",
		path, strerror(errno));
		return -1;
	}
	monitor_conn = wpa_ctrl_open(path);
	if (monitor_conn == NULL) {
		wpa_ctrl_close(ctrl_conn);
		ctrl_conn = NULL;
		return -1;
	}
	if (wpa_ctrl_attach(monitor_conn) != 0) {
		wpa_ctrl_close(monitor_conn);
		wpa_ctrl_close(ctrl_conn);
		ctrl_conn = monitor_conn = NULL;
		return -1;
	}

	if (socketpair(AF_UNIX, SOCK_STREAM, 0, exit_sockets) == -1) {
		wpa_ctrl_close(monitor_conn);
		wpa_ctrl_close(ctrl_conn);
		ctrl_conn = monitor_conn = NULL;
		return -1;
	}
	return 0;
}

/* Establishes the control and monitor socket connections on the interface */
static int wifi_connect_to_supplicant()
{
	static char path[1024];
	int count = 10;

	pr_info("%s \n", __FUNCTION__);
	while(count-- > 0) {
		if (access(IFACE_DIR, F_OK) == 0)
			break;
		sleep(1);
	}

	snprintf(path, sizeof(path), "%s/%s", IFACE_DIR, primary_iface);

	return wifi_connect_on_socket_path(path);
}

static void *RK_wifi_start_monitor(void *arg)
{
	char eventStr[EVENT_BUF_SIZE];
	int ret;
	pr_info("------ enter RK_wifi_start_monitor ------$\n");

	prctl(PR_SET_NAME,"RK_wifi_start_monitor");
	wpa_exit = false;

	if ((ret = wifi_connect_to_supplicant()) != 0) {
		pr_info("%s, connect to supplicant fail.\n", __FUNCTION__);
		return;
	}

	for (;;) {
		if (wpa_exit == true) {
			pr_info("------ wpa_exit for() ------\n");
			break;
		}

		memset(eventStr, 0, EVENT_BUF_SIZE);
		if (!wifi_wait_on_socket(eventStr, EVENT_BUF_SIZE))
			continue;

		if (dispatch_event(eventStr)) {
			pr_info("disconnecting from the supplicant, no more events\n");
			break;
		}
	}
	wifi_close_sockets();
	pr_info("------ exit RK_wifi_start_monitor ------$\n");
}