lib/liblynq-wifi6/libwifi6.c

/**@File lib_wifi6.c
*  @Brief :about function test
*  @details :
*  @Author : you.chen
*  @Date : 2022-4-6
*  @Version : V1.0
*  @copy ritght : Copyright (c) MobileTek
*/
#include <log/log.h>
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include "libwifi6.h"
#include <wpa_ctrl.h>
#include <string.h>
#include <time.h>
#include <pthread.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <ifaddrs.h>

#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
}
#endif

#define MAX_CMD 128
#define MAX_RET 4096
#define MODE_LEN 10
#define CTRL_STA 0
#define CTRL_AP 1
#define AP_NETWORK_0 0

pthread_t g_ap_watcher_pid = 0;
volatile int g_ap_watcher_stop_flag = 0;
volatile int g_ap_watcher_started_flag = 0;

pthread_t g_sta_watcher_pid = 0;
volatile int g_sta_watcher_stop_flag = 0;
volatile int g_sta_scan_finish_flag = 1;
volatile int g_sta_watcher_started_flag = 0;

void * g_ap_callback_priv = NULL;
AP_CALLBACK_FUNC_PTR g_ap_callback_func = NULL;
void * g_sta_callback_priv = NULL;
STA_CALLBACK_FUNC_PTR g_sta_callback_func = NULL;

//const char * CTRL_PATH="/var/run/wpa_supplicant";
const char * CTRL_PATH[2] = {"/var/run/wpa_supplicant/wlan0", "/var/run/wpa_supplicant/ap0"};
//const char * CTRL_PATH[2] = {"/var/run/wpa_supplicant/wlan0", "/var/run/wpa_supplicant/wlan0"};
const char * cmd_list_networks = "LIST_NETWORKS";
const char * cmd_save_config = "SAVE_CONFIG";
const char * cmd_disconnect = "DISCONNECT";
const char * cmd_remove_all = "REMOVE_NETWORK all";
const char * state_scan_result = "CTRL-EVENT-SCAN-RESULTS";
const char * STATE_COMPLETED = "COMPLETED";

static struct wpa_ctrl * g_lynq_wpa_ctrl[2] = {0};


typedef struct __curr_status_info {
    ap_info_s *ap;
    char * state;
    int net_no;
}curr_status_info;

#define PRINT_AND_RETURN_VALUE(str,value) \
{\
    perror((str));\
    return (value);\
}

#define CHECK_IDX(idx, type) do { \
        if ( (idx == LYNQ_WIFI_INTERFACE_0 && type != CTRL_STA) || (idx == LYNQ_WIFI_INTERFACE_1 && type != CTRL_AP) \
                || idx < LYNQ_WIFI_INTERFACE_0 || idx > LYNQ_WIFI_INTERFACE_1 ) { \
            printf("not support create [%s] on interface [%d]\n", (type == CTRL_STA ? "station" : "ap"), idx); \
            return -1; \
        } \
    }while (0)

#define CHECK_WPA_CTRL(index) int ret = 0;\
    size_t reply_len = MAX_RET; \
    char cmd_reply[MAX_RET]={0}; \
    struct wpa_ctrl *lynq_wpa_ctrl = NULL; \
    do{ \
        if (NULL == g_lynq_wpa_ctrl[index]) { \
            g_lynq_wpa_ctrl[index] = wpa_ctrl_open(CTRL_PATH[index]); \
            if (NULL == g_lynq_wpa_ctrl[index]) { \
                printf("wpa_ctrl_open fail\n"); \
                return -1; \
            } \
        } \
        lynq_wpa_ctrl = g_lynq_wpa_ctrl[index]; \
    }while(0)

#define DO_REQUEST(cmd_str) do { \
        reply_len = MAX_RET;\
        cmd_reply[0] = '\0'; \
        printf("to call [%s]\n", cmd_str);  \
        ret = wpa_ctrl_request(lynq_wpa_ctrl, cmd_str, strlen(cmd_str), cmd_reply, &reply_len, NULL); \
        if (ret != 0) { \
            printf("call "#cmd_str" fail %d\n", ret); \
            return ret; \
        } \
        cmd_reply[reply_len+1] = '\0'; \
        printf("cmd replay [ %s ]\n", cmd_reply); \
    }while(0)

#define DO_OK_FAIL_REQUEST(cmd_str) do { \
        DO_REQUEST(cmd_str); \
        if (reply_len >=4 && memcmp(cmd_reply, "FAIL", 4) == 0 ) {\
            printf("cmd "#cmd_str" return FAIL\n"); \
            return -1; \
        } else if (reply_len >=2 && memcmp(cmd_reply, "OK", 2) != 0) { \
            printf("cmd "#cmd_str" return not OK|FAIL\n"); \
            return -1; \
        } \
    }while (0)



static void APWatcherThreadProc() {
    size_t len = MAX_RET;
    char msg_notify[MAX_RET];

    struct wpa_ctrl *lynq_wpa_ctrl = NULL;
    g_ap_watcher_stop_flag = 0;

    while (g_ap_watcher_stop_flag == 0) {
        if (lynq_wpa_ctrl == NULL) {
            lynq_wpa_ctrl = wpa_ctrl_open(CTRL_PATH[CTRL_AP]); //@todo temp change
            if (lynq_wpa_ctrl == NULL) {
                usleep(100*1000);
                continue;
            }

            wpa_ctrl_attach(lynq_wpa_ctrl);
            g_ap_watcher_started_flag = 1;
        }

        if ( 0 == wpa_ctrl_pending(lynq_wpa_ctrl)) {
            usleep(100*1000);
            continue;
        }
        memset(msg_notify, 0, MAX_RET);
        len = MAX_RET;
        if (!wpa_ctrl_recv(lynq_wpa_ctrl, msg_notify, &len)) {
            msg_notify[len+1] = '\0';
            printf("ap------> %s\n", msg_notify);
            if (g_ap_callback_func == NULL) {
                continue;
            }
            if (strstr(msg_notify, "AP-STA-DISCONNECTED") != NULL) {
                g_ap_callback_func(g_ap_callback_priv, LYNQ_WIFI_STATUS_DISCONNECT);
            }
            else if (strstr(msg_notify, "AP-STA-CONNECTED") != NULL) {
                g_ap_callback_func(g_ap_callback_priv, LYNQ_WIFI_STATUS_CONNECT);
            }
        } // end if (!wpa_ctrl_recv(lynq_wpa_ctrl, msg_notify, &len))
    } // end while (g_ap_watcher_stop_flag == 0)
    if (lynq_wpa_ctrl != NULL) {
        wpa_ctrl_detach(lynq_wpa_ctrl);
        wpa_ctrl_close(lynq_wpa_ctrl);
    }
}

static void STAWatcherThreadProc() {
    size_t len = MAX_RET;
    char msg_notify[MAX_RET];
    char *pReason;
    error_number_s error;

    struct wpa_ctrl *lynq_wpa_ctrl = NULL;
    g_sta_watcher_stop_flag = 0;

    while (g_sta_watcher_stop_flag == 0) {
        if (lynq_wpa_ctrl == NULL) {
            lynq_wpa_ctrl = wpa_ctrl_open(CTRL_PATH[CTRL_STA]);
            if (lynq_wpa_ctrl == NULL) {
                usleep(100*1000);
                continue;
            }

            wpa_ctrl_attach(lynq_wpa_ctrl);
            g_sta_watcher_started_flag = 1;
        }

        if ( 0 == wpa_ctrl_pending(lynq_wpa_ctrl)) {
            usleep(100*1000);
            continue;
        }
        memset(msg_notify, 0, MAX_RET);
        len = MAX_RET;
        if (!wpa_ctrl_recv(lynq_wpa_ctrl, msg_notify, &len)) {
            msg_notify[len+1] = '\0';
            printf("sta ------> %s\n", msg_notify);
            if (strstr(msg_notify, state_scan_result) != NULL) {
                g_sta_scan_finish_flag = 1;
            }

            if (g_sta_callback_func == NULL) {
                continue;
            }
            error = -1;
            if (strstr(msg_notify, "CTRL-EVENT-SCAN-RESULTS") != NULL) {
                g_sta_callback_func(g_ap_callback_priv, LYNQ_WIFI_STA_STATUS_SCAN_RESULT, error);
            }
            else if (strstr(msg_notify, "CTRL-EVENT-CONNECTED") != NULL) {
                g_sta_callback_func(g_ap_callback_priv, LYNQ_WIFI_STA_STATUS_CONNECT, error);
            }
            else if (strstr(msg_notify, "CTRL-EVENT-SSID-TEMP-DISABLED") != NULL) {
                pReason = strstr(msg_notify, "reason=");
                if (pReason != NULL) {
                    pReason += strlen("reason=");
                    if (memcmp(pReason, "CONN_FAILED", 11) == 0) {
                        error = LYNQ_TIME_OUT;
                    }
                    else if (memcmp(pReason, "WRONG_KEY", 9) == 0) {
                        error = LYNQ_PSW_ERROR;
                    }
                    g_sta_callback_func(g_ap_callback_priv, LYNQ_WIFI_STA_STATUS_DISCONNECT, error);
                }
            }
            else if (strstr(msg_notify, "CTRL-EVENT-DISCONNECTED") != NULL) {
                g_sta_callback_func(g_ap_callback_priv, LYNQ_WIFI_STA_STATUS_DISCONNECT, error);
            }
            else if (strstr(msg_notify, "CTRL-EVENT-NETWORK-NOT-FOUND") != NULL) {
                g_sta_callback_func(g_ap_callback_priv, LYNQ_WIFI_STA_STATUS_DISCONNECT, LYNQ_NOT_FIND_AP);
            }
        }
    }
    if (lynq_wpa_ctrl != NULL) {
        wpa_ctrl_detach(lynq_wpa_ctrl);
        wpa_ctrl_close(lynq_wpa_ctrl);
    }
}

int lynq_wifi_enable(void)
{
    int ret = 0;
    int i;
    const char * cmd_check_service =
            "state=`systemctl is-active wg870_drv_insmod.service`\n"
            "[ \"\"$state == \"active\" ] && exit 0\n"
            "[ \"\"$state == \"inactive\" ] && systemctl start wg870_drv_insmod.service\n";
//    if (g_lynq_wpa_ctrl[0] != NULL && g_lynq_wpa_ctrl[1] != NULL) {
//        return 0;
//    }

    ret = system(cmd_check_service);
    if (ret != 0) {
        printf("service state %d\n", ret);
        return -1;
    }

    for (i=0; i<10; i++) {
        if (system("connmanctl technologies | grep -q \"/net/connman/technology/wifi\"") == 0) {
            break;
        }
        usleep(300*1000);
    }

    if (i >= 10) {
        return -1;
    }

    //@todo delete add temp check for socket avilable start (20220606)
    for (i=0; i<60; i++)
    {
        if (system("netstat -an | grep -q DGRAM") == 0) {
            break;
        }
        sleep(1);
    }

    if (i >= 60)
    {
        return -1;
    }
    //@todo delete add temp check for socket avilable end (20220606)

    if (0 != system("ifconfig | grep -q ap0")) {
        system("connmanctl enable wifi");
        usleep(300*1000);
        system("wpa_cli -iwpa_wlan0_cmd -p/var/run/ IFNAME=wlan0 disconnect");
        system("wpa_cli -iwpa_wlan0_cmd -p/var/run/ IFNAME=wlan0 DRIVER interface_create ap0");
        usleep(300*1000);
        system("connmanctl tether wifi on lynq 1qaz@WSX#$%^");
        usleep(300*1000);
        system("wpa_cli -iwpa_wlan0_cmd -p/var/run/ IFNAME=ap0 disconnect");
    }

    if (g_ap_watcher_pid == 0 ) {
        ret=pthread_create(&g_ap_watcher_pid,NULL,APWatcherThreadProc,NULL);
        if(ret<0){
            return -1;
        }
    }

    if (g_sta_watcher_pid == 0 ) {
        ret=pthread_create(&g_sta_watcher_pid,NULL,STAWatcherThreadProc,NULL);
        if(ret<0){
            return -1;
        }
    }

    for (i=0; i<10; i++) {
        usleep(300*1000);
        if (g_ap_watcher_started_flag == 1 && g_sta_watcher_started_flag == 1) {
            break;
        }
    }

    return ret;
}

int lynq_wifi_disable(void)
{
    g_ap_watcher_stop_flag = 1;
    g_sta_watcher_stop_flag = 1;
    if (g_ap_watcher_pid != 0)
        pthread_join(g_ap_watcher_pid, NULL);
    if (g_sta_watcher_pid != 0)
        pthread_join(g_sta_watcher_pid, NULL);
    if (g_lynq_wpa_ctrl[0] != NULL)
        wpa_ctrl_close(g_lynq_wpa_ctrl[0]);
    if (g_lynq_wpa_ctrl[1] != NULL)
        wpa_ctrl_close(g_lynq_wpa_ctrl[1]);
    g_ap_watcher_pid = 0;
    g_sta_watcher_pid = 0;
    g_lynq_wpa_ctrl[0] = NULL;
    g_lynq_wpa_ctrl[1] = NULL;
    system("systemctl stop wg870_drv_insmod.service");
	return 0;
}

static int inner_get_param(int interface, int net_no, char* param_name, char * out_put) {

    char lynq_cmd_get[128]={0};

    if (out_put == NULL) {
        printf("output ptr is null\n");
        return -1;
    }
    if (param_name == NULL) {
        printf("param ptr is null");
        return -1;
    }
    if (param_name[0] == '\0') {
        printf("param is empty");
        return -1;
    }

    sprintf(lynq_cmd_get, "GET_NETWORK %d %s", net_no, param_name);

    CHECK_WPA_CTRL(interface);

    DO_REQUEST(lynq_cmd_get);

    if (memcmp(cmd_reply, "FAIL", 4) == 0) {
        return -1;
    }

//    printf("reply len %d, %08x\n", reply_len, (int)out_put);
    memcpy(out_put, cmd_reply, reply_len + 1);
    return 0;
}

static int lynq_split(char * str, int len, char delimiter, char * results[]) {
    int ret = 0;
    char * end = str + len - 1;
    results[ret++] = str;
    while(str < end) {
        if (*str == delimiter) {
            *str++ = '\0';
            results[ret++] = str;
            continue;
        }
        str++;
    }
    if (*str == delimiter) {
        *str = '\0';
    }

    return ret;
}

static void trim_space(char * p, int count) {
    char * begin = p;
    p += count;
    printf("%C-%C||\n", *begin, *p);
    while (p >= begin ) {
        if (*p == ' ') {
            *p-- = '\0';
        }
        else {
            break;
        }
    }
}

static int get_ip_mac_list(char * mac_list[128], char * ip_list[128]) {
    FILE * fp;
    int len, ret;
    int count, count_words, index;
    int mac_start, mac_end;
    int ip_start, ip_end;
    char *split_lines[128] = {0};
    char *buff;
    const char * ip_header = "IP address";
    const char * mac_header = "HW address";
    const char * zero_mac = "00:00:00:00:00:00";

    fp = fopen("/proc/net/arp", "rb");
    if (NULL == fp) {
        printf("open file fail\n");
        return  -1;
    }

    buff = alloca(MAX_RET);
    fseek(fp, 0, SEEK_SET);
    len = fread(buff, 1, MAX_RET, fp);
    fclose(fp);
    if (len <= 0) {
        printf("read file fail\n");
        return -1;
    }
    printf("file : %s\n", buff);

    count = lynq_split(buff, len, '\n', split_lines);
    printf("----- %s\n", split_lines[0]);

    mac_end = 0;
    count_words = strlen(split_lines[0]);
    if (strstr(split_lines[0], mac_header) != NULL) {
        mac_start = strstr(split_lines[0], mac_header) - split_lines[0];
        mac_end = mac_start + strlen(mac_header) + 1;
        while (mac_end < count_words) {
            if (split_lines[0][mac_end] != ' ') {
                break;
            }
            mac_end++;
        }
    }

    ip_end = 0;
    if (strstr(split_lines[0], ip_header) != NULL) {
        ip_start = strstr(split_lines[0], ip_header) - split_lines[0];
        ip_end = ip_start + strlen(ip_header) + 1;
        while (ip_end < count_words) {
            if (split_lines[0][ip_end] != ' ') {
                break;
            }
            ip_end++;
        }
    }

    if (mac_end == 0 || ip_end == 0) {
        return 0;
    }

    ret = 0;
    for(index = 1;index < count; index++) {
        if (memcmp(split_lines[index] + mac_start, zero_mac, strlen(zero_mac)) == 0) {
            continue;
        }
        mac_list[ret] = malloc(mac_end - mac_start + 1);
        ip_list[ret] = malloc(ip_end - ip_start + 1);
        memcpy(mac_list[ret], split_lines[index] + mac_start, mac_end - mac_start);
        memcpy(ip_list[ret], split_lines[index] + ip_start, ip_end - ip_start);
        trim_space(mac_list[ret],  mac_end - mac_start - 1);
        trim_space(ip_list[ret],  ip_end - ip_start - 1);
        ret++;
    }

    return ret;
}

static void free_ip_mac_list_mem(char ** mac_list, int mac_cnt, char ** ip_list, int ip_cnt)
{
    int i;
    if (mac_list != NULL && mac_cnt > 0) {
        for(i = 0; i< mac_cnt; i++)
        {
            if (NULL != mac_list[i])
            {
                free(mac_list[i]);
                mac_list[i] = NULL;
            }
        }
    }
    if (ip_list != NULL && ip_cnt > 0) {
        for(i = 0; i< mac_cnt; i++)
        {
            if (NULL != ip_list[i])
            {
                free(ip_list[i]);
                ip_list[i] = NULL;
            }
        }
    }
}

static int get_hostname_by_ip(char *ip, char *hostname) {
    struct in_addr addr ={0};
    struct hostent *ht;

    if (ip == NULL || *ip == '\0' || hostname == NULL) {
        return -1;
    }

    if (inet_aton(ip, &addr) == 0) {
        printf("---inet_aton fail\n");
        return -1;
    }

    ht = gethostbyaddr(&addr, sizeof(struct in_addr), AF_INET);

    if (ht == NULL) {
        printf("---gethostbyaddr fail\n");
        herror(NULL);
        return -1;
    }

    strcpy(hostname, ht->h_name);

    return 0;
}

static int lynq_get_network_number_list(lynq_wifi_index_e idx, int ap_sta, int net_no_list[], char * ssid)
{
    int count, index, words_count;
    char * split_lines[128]= {0};
    char * split_words[128] = {0};
    const char *lynq_wifi_list_networks = "LIST_NETWORKS";

    CHECK_WPA_CTRL(ap_sta);

    DO_REQUEST(lynq_wifi_list_networks);

    count = lynq_split(cmd_reply, reply_len, '\n', split_lines);

    //@todo check ssid field to compatible

    ret = 0;
    for(index=1; index < count; index++) {
        words_count = lynq_split(split_lines[index], strlen(split_lines[index]), '\t', split_words);
        if (words_count > 2) {
            if (ssid == NULL || strcmp(split_words[1], ssid) == 0) {
                net_no_list[ret++] = atoi(split_words[0]);
            }
        }
    }

    return ret;
}

static int lynq_add_network(int ap_sta) {
    size_t i=0;
    CHECK_WPA_CTRL(ap_sta);
    const char *lynq_wifi_add_network = "ADD_NETWORK";

    DO_REQUEST(lynq_wifi_add_network);
    if (memcmp(cmd_reply, "FAIL", 4) == 0) {
        return -1;
    }

    for(i=0;i<reply_len;i++) {
        if(cmd_reply[i] == '\n') {
            cmd_reply[i] = '\0';
            break;
        }
    }
    return atoi(cmd_reply);
}

static int lynq_check_network_number(lynq_wifi_index_e idx, int ap_sta, int net_no)
{
    int count, index;
    int net_no_list[128];


    count = lynq_get_network_number_list(idx, ap_sta, net_no_list, NULL);
    for (index=0; index < count; index++) {
        if (net_no_list[index] == net_no) {
            return 0;
        }
    }

    if (count >= 1)
        index = net_no_list[count - 1];
    else
        index = -1;

    while (index < net_no ) {
        index = lynq_add_network(ap_sta);
        if (index >= net_no) { // required network no created
            return 0;
        }
        else if( index < 0) {
            printf("add network fail\n");
            return -1;
        }
    }

    if (index < 0)
        return -1;

    return 0;
}

static lynq_wifi_band_m convert_band_from_freq(int freq) { //@todo
    if (freq > 5000 && freq < 6000) {
        return LYNQ_WIFI_5G_band;
    }
    else if (freq > 2000 && freq <  3000) {
        return LYNQ_WIFI_2G_band;
    }
    return LYNQ_WIFI_2_and_5G_band;
}

static lynq_wifi_auth_s convert_auth_from_key_mgmt(char * key_mgmt) {
    if (key_mgmt != NULL) {
        if (memcmp( key_mgmt, "NONE", 4) == 0) {
            return LYNQ_WIFI_AUTH_OPEN;
        }
        else if (memcmp( key_mgmt, "WEP", 3) == 0){
            return LYNQ_WIFI_AUTH_WEP;
        }
        else if (memcmp( key_mgmt, "WPA-PSK", 7) == 0){
            return LYNQ_WIFI_AUTH_WPA_PSK;
        }
        else if (memcmp( key_mgmt, "WPA2-PSK", 8) == 0){
            return LYNQ_WIFI_AUTH_WPA2_PSK;
        }
    }

    return -1;
}

static lynq_wifi_auth_s convert_max_auth_from_flag(char * flag) {
    if (flag != NULL) {
        if (strstr( flag, "WPA2-PSK") != NULL){
            return LYNQ_WIFI_AUTH_WPA2_PSK;
        }
        else if (strstr( flag, "WPA-PSK") != NULL){
            return LYNQ_WIFI_AUTH_WPA_PSK;
        }
        else if (strstr( flag, "WEP") != NULL){
            return LYNQ_WIFI_AUTH_WEP;
        }
        else if (strstr( flag, "NONE") != NULL) {
            return LYNQ_WIFI_AUTH_OPEN;
        }
    }

    return -1;
}

static lynq_wifi_bandwidth_type_m convert_bandwidth_from_bw(int bw) {
    switch (bw) {
    case 10:
        return LYNQ_WIFI_BANDWIDTH_HT10;
        break;
    case 20:
        return LYNQ_WIFI_BANDWIDTH_HT20;
        break;
    case 40:
        return LYNQ_WIFI_BANDWIDTH_HT40;
        break;
    case 80:
        return LYNQ_WIFI_BANDWIDTH_HT80;
        break;
    default:
        break;
    }

    return -1;
}

static int inner_get_status_info(int interface, curr_status_info *curr_state) {
    int i, count;
    char *p;
    const char *lynq_status_cmd = "STATUS";
    const char * FLAG_SSID = "ssid=";
    const char * FLAG_SBSID = "bssid=";
    const char * FLAG_KEY_MGMT = "key_mgmt=";
    const char * FLAG_FREQ = "freq=";
    const char * FLAG_STATE = "wpa_state=";
    const char * FLAG_ID = "id=";
    char *split_lines[128] = {0};

    CHECK_WPA_CTRL(interface);

    if (curr_state == NULL) {
        return -1;
    }

    DO_REQUEST(lynq_status_cmd);

    count = lynq_split(cmd_reply, reply_len, '\n', split_lines);

    curr_state->net_no = -1;
    ret = -1;
    for(i=0; i < count; i++) {
        if (curr_state->ap != NULL) {
            p = strstr(split_lines[i], FLAG_SBSID);
            if (p != NULL) {
                strcpy(curr_state->ap->ap_mac, p + strlen(FLAG_SBSID));
                ret = 0;
                continue;
            }
            p = strstr(split_lines[i], FLAG_SSID);
            if (p != NULL) {
                strcpy(curr_state->ap->ap_ssid, p + strlen(FLAG_SSID));
                ret = 0;
                continue;
            }
            p = strstr(split_lines[i], FLAG_KEY_MGMT);
            if (p != NULL) {
                curr_state->ap->auth = convert_auth_from_key_mgmt(p + strlen(FLAG_KEY_MGMT));
                printf("key_mgmt %d, -- %s\n", curr_state->ap->auth, p);
                ret = 0;
                continue;
            }
            p = strstr(split_lines[i], FLAG_FREQ);
            if (p != NULL) {
                curr_state->ap->band = convert_band_from_freq(atoi( p + strlen(FLAG_FREQ)));
                ret = 0;
                continue;
            }
        } // end  if (ap != NULL)
        if (curr_state->state != NULL) {
            p = strstr(split_lines[i], FLAG_STATE);
            if (p != NULL) {
                strcpy(curr_state->state, p + strlen(FLAG_STATE));
                ret = 0;
                continue;
            }

        } //end else if (state != NULL)
        if ((p = strstr(split_lines[i], FLAG_ID)) == split_lines[i]) {
            ret = 0;
            curr_state->net_no = atoi(p + strlen(FLAG_ID));
            printf("net_no %d, -- %s\n", curr_state->net_no, p);
        }
    }

    return ret;
}


int lynq_wifi_ap_ssid_set(lynq_wifi_index_e idx,char *ap_ssid)
{
    char lynq_wifi_ssid_cmd[80]={0};

    if (ap_ssid == NULL) {
        printf("ap_ssid is null\n");
        return -1;
    }
    else {
        printf("idx:%d ap_ssid : %s\n", idx, ap_ssid);
    }

    if (lynq_check_network_number(idx, CTRL_AP, AP_NETWORK_0) != 0) {
        return -1;
    }

    CHECK_IDX(idx, CTRL_AP);

    CHECK_WPA_CTRL(CTRL_AP);

    sprintf(lynq_wifi_ssid_cmd,"SET_NETWORK %d ssid \"%s\"", AP_NETWORK_0, ap_ssid);

    DO_OK_FAIL_REQUEST(lynq_wifi_ssid_cmd);
    DO_OK_FAIL_REQUEST(cmd_save_config);

	return 0;

}

int lynq_wifi_ap_ssid_get(lynq_wifi_index_e idx, char* ap_ssid)
{
    int len;
    CHECK_IDX(idx, CTRL_AP);
    if (0 != inner_get_param(CTRL_AP, AP_NETWORK_0, "ssid", ap_ssid))
        return -1;
    len = strlen(ap_ssid);
    if (ap_ssid[0] == '\"') {
        memmove(ap_ssid, ap_ssid + 1, len - 1);
        len -= 1;
    }
    if (len > 0 && ap_ssid[len-1] == '\"') {
        ap_ssid[len-1] = '\0';
    }
    return 0;
}

int lynq_wifi_ap_frequency_set(lynq_wifi_index_e idx,int lynq_wifi_frequency)
{
	char lynq_wifi_frequency_cmd[128]={0};
	char lynq_cmd_mode[128]={0};
    char lynq_cmd_slect[128]={0};

    if((lynq_wifi_frequency != 2437) && (lynq_wifi_frequency != 5180)){
        PRINT_AND_RETURN_VALUE("set frequency not in range",-1);
    }

    if (lynq_check_network_number(idx, CTRL_AP, AP_NETWORK_0) != 0) {
        return -1;
    }

    CHECK_IDX(idx, CTRL_AP);

    CHECK_WPA_CTRL(CTRL_AP);

    sprintf(lynq_wifi_frequency_cmd,"SET_NETWORK %d frequency %d", AP_NETWORK_0, lynq_wifi_frequency);
    sprintf(lynq_cmd_mode, "SET_NETWORK %d mode 2", AP_NETWORK_0);
    sprintf(lynq_cmd_slect, "SELECT_NETWORK %d", AP_NETWORK_0);

    DO_OK_FAIL_REQUEST(cmd_disconnect);
    DO_OK_FAIL_REQUEST(lynq_wifi_frequency_cmd);
    DO_OK_FAIL_REQUEST(lynq_cmd_mode);
    DO_OK_FAIL_REQUEST(cmd_save_config);

	return 0;
}

int lynq_wifi_ap_frequency_get(lynq_wifi_index_e idx,int *lynq_wifi_frequency)
{
    char lynq_frequency_str[MAX_RET] = {0};

    CHECK_IDX(idx, CTRL_AP);

    if (inner_get_param(CTRL_AP, AP_NETWORK_0, "frequency", lynq_frequency_str) != 0) {
        return -1;
    }
    *lynq_wifi_frequency = atoi(lynq_frequency_str);

	return 0;
}

int lynq_wifi_ap_bandwidth_set(lynq_wifi_index_e idx,lynq_wifi_bandwidth_type_m bandwidth)
{
    CHECK_IDX(idx, CTRL_AP);
    switch(bandwidth){
		case LYNQ_WIFI_BANDWIDTH_HT10:
		{
            printf("bandwith  [%d] not support now\n", bandwidth);
			return -1;
		}
		case LYNQ_WIFI_BANDWIDTH_HT20:
        {
            char lynq_cmd_bandwith[MAX_CMD]="wl chanspec 6";
            system("wl down");
            if (system(lynq_cmd_bandwith) != 0 ){
                return -1;
            }
            system("wl up");
            break;
        }
        case LYNQ_WIFI_BANDWIDTH_HT40:
		{
            char lynq_cmd_bandwith[MAX_CMD]="wl chanspec 153u";
            sprintf(lynq_cmd_bandwith, "wl chanspec ");
            system("wl down");
            if (system(lynq_cmd_bandwith) != 0 ){
                return -1;
            }
            system("wl up");
            break;
		}
        case LYNQ_WIFI_BANDWIDTH_HT80:
		{
            char lynq_cmd_bandwith[MAX_CMD]="wl chanspec 36/80";
            system("wl down");
            if (system(lynq_cmd_bandwith) != 0 ){
                return -1;
            }
            system("wl up");
            break;
		}				
		default:
        {
            printf("auth type [%d] not support now\n", bandwidth);
			return -1;
        }
    }


    return 0;
}

int lynq_wifi_ap_bandwidth_get(lynq_wifi_index_e idx,lynq_wifi_bandwidth_type_m* bandwidth)
{
    int count = 0;
    int index = 0;
    char *split_words[128] = {0};
    const char *lynq_chanspec_cmd = "DRIVER chanspec\n";

    CHECK_IDX(idx, CTRL_AP);

    CHECK_WPA_CTRL(CTRL_AP);

    DO_REQUEST(lynq_chanspec_cmd);

    count = lynq_split(cmd_reply, reply_len, ' ', split_words);
    for(;index < count; index++) {
        if (strncmp(split_words[index], "bw", 2) != 0) {
            continue;
        }

        index++;
        if (index >= count) {
            return -1;
        }

        printf("bw %s\n", split_words[index]);
        *bandwidth = convert_bandwidth_from_bw(atoi(split_words[index]));
        return 0;
    }

    return -1;
}

int lynq_wifi_ap_channel_set( lynq_wifi_index_e idx,int channel)
{
    char lynq_cmd_channel[MAX_CMD]={0};

    CHECK_IDX(idx, CTRL_AP);

    sprintf(lynq_cmd_channel, "wl channel %d", channel);

    if (lynq_check_network_number(idx, CTRL_AP, AP_NETWORK_0) != 0) {
        return -1;
    }

    system("wl down");
    if (system(lynq_cmd_channel) != 0 ){
        return -1;
    }
    system("wl up");
    return 0;
}

int lynq_wifi_ap_channel_get( lynq_wifi_index_e idx,int* channel)
{
    int count = 0;
    int index = 0;
    char *split_words[128] = {0};
    char lynq_chanspec_cmd[]="DRIVER chanspec\n";

    CHECK_IDX(idx, CTRL_AP);

    CHECK_WPA_CTRL(CTRL_AP);

    DO_REQUEST(lynq_chanspec_cmd);

    count = lynq_split(cmd_reply, reply_len, ' ', split_words);
    for(;index < count; index++) {
        printf("---- %s\n",split_words[index]);
        if (strncmp(split_words[index], "channel", 2) != 0) {
            continue;
        }

        index++;
        if (index >= count) {
            return -1;
        }

        *channel = atoi(split_words[index]);
        return 0;
    }

    return -1;
}


int lynq_wifi_ap_auth_set(lynq_wifi_index_e idx, lynq_wifi_auth_s auth)
{
    char ssid[MAX_CMD] = {0};
    int freq = 0;
    char lynq_auth_cmd[64]={0};
    char lynq_auth_alg_cmd[64]={0};
    char lynq_psk_cmd[64]={0};
    char lynq_pairwise_cmd[64]={0};
    lynq_wifi_auth_s org_auth;
    CHECK_IDX(idx, CTRL_AP);

    CHECK_WPA_CTRL(CTRL_AP);

    if (lynq_check_network_number(idx, CTRL_AP, AP_NETWORK_0) != AP_NETWORK_0) {
        return -1;
    }

    if (0 == lynq_wifi_ap_auth_get(idx, &org_auth) && org_auth != -1) {
        if (org_auth == auth) {
            return 0;
        }
        else {
            if (0 != lynq_wifi_ap_ssid_get(idx, ssid)) {
                ssid[0] = '\0';
            }
            lynq_wifi_ap_frequency_get(idx, &freq);

            DO_OK_FAIL_REQUEST(cmd_disconnect);
            DO_OK_FAIL_REQUEST(cmd_remove_all);
            if (ssid[0] != '\0') {
                lynq_wifi_ap_ssid_set(idx, ssid);
            }
            if (freq != 0) {
                lynq_wifi_ap_frequency_set(idx, freq);
            }
        }
    }

	switch(auth){
		case LYNQ_WIFI_AUTH_OPEN:
        {
            sprintf(lynq_auth_cmd,"SET_NETWORK %d key_mgmt NONE", AP_NETWORK_0);
            sprintf(lynq_pairwise_cmd,"SET_NETWORK %d pairwise NONE", AP_NETWORK_0);

            DO_OK_FAIL_REQUEST(lynq_auth_cmd);
			break;
		}
        case LYNQ_WIFI_AUTH_WEP:
        {
            sprintf(lynq_auth_cmd,"SET_NETWORK %d key_mgmt NONE", AP_NETWORK_0);
            sprintf(lynq_pairwise_cmd,"SET_NETWORK %d pairwise NONE", AP_NETWORK_0);
            sprintf(lynq_auth_alg_cmd,"SET_NETWORK %d auth_alg  SHARED", AP_NETWORK_0);

            DO_OK_FAIL_REQUEST(lynq_auth_cmd);
            DO_OK_FAIL_REQUEST(lynq_auth_alg_cmd);
            break;
        }
		case LYNQ_WIFI_AUTH_WPA_PSK:
        case LYNQ_WIFI_AUTH_WPA2_PSK:
		{
            if (auth == LYNQ_WIFI_AUTH_WPA_PSK) {
                sprintf(lynq_auth_cmd,"SET_NETWORK %d proto WPA", AP_NETWORK_0);
                sprintf(lynq_psk_cmd,"SET_NETWORK %d key_mgmt WPA-PSK", AP_NETWORK_0);
            }
            else if (auth == LYNQ_WIFI_AUTH_WPA2_PSK) {
                sprintf(lynq_auth_cmd,"SET_NETWORK %d proto RSN", AP_NETWORK_0);
                sprintf(lynq_psk_cmd,"SET_NETWORK %d key_mgmt WPA-PSK", AP_NETWORK_0);
            }
//            sprintf(lynq_auth_cmd,"SET_NETWORK %d proto WPA2", AP_NETWORK_0);
//            sprintf(lynq_psk_cmd,"SET_NETWORK %d key_mgmt WPA-PSK", AP_NETWORK_0);
            sprintf(lynq_pairwise_cmd,"SET_NETWORK %d pairwise CCMP", AP_NETWORK_0);

            DO_OK_FAIL_REQUEST(lynq_auth_cmd);
            DO_OK_FAIL_REQUEST(lynq_psk_cmd);
            DO_OK_FAIL_REQUEST(lynq_pairwise_cmd);
			break;
		}		
		default:
        {
            printf("auth type [%d] not support now\n", auth);
			return -1;
        }
    }
    DO_OK_FAIL_REQUEST(cmd_save_config);

	return 0;
}

int lynq_wifi_ap_auth_get(lynq_wifi_index_e idx, lynq_wifi_auth_s *auth)
{
    char lynq_auth_str[MAX_RET] = {0};
    char lynq_auth_alg_str[MAX_RET] = {0};
    char lynq_proto_str[MAX_RET] = {0};

    CHECK_IDX(idx, CTRL_AP);

    if (inner_get_param(CTRL_AP, AP_NETWORK_0, "key_mgmt", lynq_auth_str) != 0) {
        return -1;
    }

    if (memcmp( lynq_auth_str, "NONE", 4) == 0) {
        if (inner_get_param(CTRL_AP, AP_NETWORK_0, "auth_alg", lynq_auth_alg_str) != 0) {
            *auth = LYNQ_WIFI_AUTH_OPEN;
        }
        else if (memcmp(lynq_auth_alg_str, "SHARED", 6) == 0){
            *auth = LYNQ_WIFI_AUTH_WEP;
        }
        else {
            *auth = LYNQ_WIFI_AUTH_OPEN;
        }
    }
    else if(strcmp( lynq_auth_str, "WPA-PSK") == 0 ) {
        if (inner_get_param(CTRL_AP, AP_NETWORK_0, "proto", lynq_proto_str) != 0) {
            *auth = -1;
        }
        else if (memcmp(lynq_proto_str, "RSN", 3) == 0) {
            *auth = LYNQ_WIFI_AUTH_WPA2_PSK;
        }
        else {
            *auth = LYNQ_WIFI_AUTH_WPA_PSK;
        }
    }
    else {
        *auth = -1;
    }

    return 0;
}


int lynq_wifi_ap_start(lynq_wifi_index_e idx)
{
    char LYNQ_WIFI_CMD[128]={0};
    //const char *lynq_remove_all_cmd = "REMOVE_NETWORK all";
    //const char *lynq_reconfig_cmd = "RECONFIGURE /data/wifi/wg870/wpa_supplicant.conf";

    CHECK_IDX(idx, CTRL_AP);

    CHECK_WPA_CTRL(CTRL_AP);

//    system("connmanctl enable wifi");
//    system("connmanctl tether wifi on cy-test 12345678");
//    system("ifconfig wlan0 down");
//    system("ifconfig wlan0 up");
//    system("ifconfig wlan0 up");

    //DO_OK_FAIL_REQUEST(lynq_remove_all_cmd);
    //DO_OK_FAIL_REQUEST(lynq_reconfig_cmd);

    sprintf(LYNQ_WIFI_CMD,"SELECT_NETWORK %d",AP_NETWORK_0);
    DO_OK_FAIL_REQUEST(LYNQ_WIFI_CMD);

	return 0;
}

int lynq_wifi_ap_restart(lynq_wifi_index_e idx)
{
    return lynq_wifi_ap_stop(idx) == 0 ? lynq_wifi_ap_start(idx)  : -1;
}

int lynq_wifi_ap_stop(lynq_wifi_index_e idx)
{
    char LYNQ_WIFI_CMD[128]={0};

    CHECK_IDX(idx, CTRL_AP);

    CHECK_WPA_CTRL(CTRL_AP);

    sprintf(LYNQ_WIFI_CMD,"DISABLE_NETWORK %d",AP_NETWORK_0);

    DO_OK_FAIL_REQUEST(LYNQ_WIFI_CMD);

//    system("connmanctl tether wifi off");
	
	return 0;
}

int lynq_wifi_ap_hide_ssid(lynq_wifi_index_e idx)
{
    char lynq_disable_cmd[128] = {0};
    char lynq_select_cmd[128] = {0};
    const char *lynq_hide_cmd = "SET HIDE_SSID 1";

    CHECK_IDX(idx, CTRL_AP);

    CHECK_WPA_CTRL(CTRL_AP);
	
    sprintf(lynq_disable_cmd,"DISABLE_NETWORK %d", AP_NETWORK_0);
    sprintf(lynq_select_cmd,"SELECT_NETWORK %d", AP_NETWORK_0);

    DO_OK_FAIL_REQUEST(lynq_disable_cmd);
    DO_OK_FAIL_REQUEST(lynq_hide_cmd);
    DO_OK_FAIL_REQUEST(lynq_select_cmd);

	return 0;
}

int lynq_wifi_ap_unhide_ssid(lynq_wifi_index_e idx)
{
    char lynq_disable_cmd[128] = {0};
    char lynq_select_cmd[128] = {0};
    const char *lynq_unhide_cmd = "SET HIDE_SSID 0";

    CHECK_IDX(idx, CTRL_AP);

    CHECK_WPA_CTRL(CTRL_AP);

    sprintf(lynq_disable_cmd,"DISABLE_NETWORK %d", AP_NETWORK_0);
    sprintf(lynq_select_cmd,"SELECT_NETWORK %d", AP_NETWORK_0);

    DO_OK_FAIL_REQUEST(lynq_disable_cmd);
    DO_OK_FAIL_REQUEST(lynq_unhide_cmd);
    DO_OK_FAIL_REQUEST(lynq_select_cmd);

	return 0;
}

int lynq_ap_password_set(lynq_wifi_index_e idx,char *password)
{
	int pass_len;
    char lynq_tmp_cmd[MAX_CMD] = {0};
    char lynq_wep_tx_keyidx_cmd[MAX_CMD] = {0};
    if( password == NULL ){
        return -1;
    }
    pass_len=strlen(password);
    lynq_wifi_auth_s auth = -1;
    if(pass_len < 8 || pass_len >= 64){
		return -1;
    }

    CHECK_IDX(idx, CTRL_AP);

    if (0 != lynq_wifi_ap_auth_get(idx, &auth)) {
        return -1;
    }
    else if (auth == LYNQ_WIFI_AUTH_OPEN) {
        return -1;
    }

    CHECK_WPA_CTRL(CTRL_AP);

    if (auth == LYNQ_WIFI_AUTH_WEP) {
        sprintf(lynq_tmp_cmd,"SET_NETWORK %d wep_key0 \"%s\"",AP_NETWORK_0, password);
        sprintf(lynq_wep_tx_keyidx_cmd,"SET_NETWORK %d wep_tx_keyidx 0",AP_NETWORK_0);
        DO_OK_FAIL_REQUEST(lynq_tmp_cmd);
        DO_OK_FAIL_REQUEST(lynq_wep_tx_keyidx_cmd);
    }
    else if (auth == LYNQ_WIFI_AUTH_WPA_PSK || auth == LYNQ_WIFI_AUTH_WPA2_PSK) {
        sprintf(lynq_tmp_cmd,"SET_NETWORK %d psk \"%s\"",AP_NETWORK_0, password);
        DO_OK_FAIL_REQUEST(lynq_tmp_cmd);
    }
    else {
        return -1;
    }

    DO_OK_FAIL_REQUEST(cmd_save_config);

	return 0;
}

int lynq_ap_password_get(lynq_wifi_index_e idx, char *password)
{
    FILE * fp;
    int len, ret;
    int count, index;
    char *split_lines[128] = {0};
    char *buff, *p;

    CHECK_IDX(idx, CTRL_AP);

    fp = fopen("/data/wifi/wg870/wpa_supplicant_ap.conf", "rb");
//    fp = fopen("/data/wifi/wg870/wpa_supplicant.conf", "rb");
    if (NULL == fp) {
        printf("open file fail\n");
        return  -1;
    }

    buff = alloca(MAX_RET);
    fseek(fp, 0, SEEK_SET);
    len = fread(buff, 1, MAX_RET, fp);
    fclose(fp);

    for(index=0; index < len; index ++) {
        if (memcmp(buff + index, "network={", 9) != 0) {
            continue;
        }
         p = buff + index + 9;
         for (; index < len; index ++ ) {
             if (buff[index] != '}') {
                 continue;
             }
             buff[index] = '\0';
             break;
         }
         len = buff + index - p;
    }

    count = lynq_split(p, len, '\n', split_lines);

    ret = -1;
    for(index=0; index < count; index++) {
        p = strstr(split_lines[index], "psk=");
        if (p != NULL) {
            p += 4;
            if (*p == '\"') {
                p++;
            }
        }
        else if (NULL != (p = strstr(split_lines[index], "wep_key0="))) {
            p += 9;
            if (*p == '\"') {
                p++;
            }
        }
        else {
            continue;
        }

        strcpy(password, p);

        while(*password != '\0') {
            if (*password == '\"') {
                *password = '\0';
                break;
            }
            password++;
        }
        ret = 0;
        break;
    } //end for(index=0; index < count; index++)

    return ret;
}

static int inner_get_network_auth(int interface, int net_no, lynq_wifi_auth_s *auth) {
    char lynq_auth_str[MAX_RET] = {0};
    char lynq_proto_str[MAX_RET] = {0};

    if (inner_get_param(interface, net_no, "key_mgmt", lynq_auth_str) != 0) {
        return -1;
    }

    *auth = convert_auth_from_key_mgmt(lynq_auth_str);

    if (*auth == LYNQ_WIFI_AUTH_WPA_PSK) {
        if (inner_get_param(interface, net_no, "proto", lynq_proto_str) == 0) {
            if (strcmp(lynq_proto_str, "RSN") == 0) {
                *auth = LYNQ_WIFI_AUTH_WPA2_PSK;
            }
        }
    }
    return 0;
}

int lynq_sta_ssid_password_set(lynq_wifi_index_e idx, ap_info_s *ap, char *password)
{
    int pass_len, net_no, count, index;
    char lynq_tmp_cmd[300]={0};
    int net_no_list[128];
    lynq_wifi_auth_s net_auth;
    pass_len=strlen(password);
    if(pass_len < 8 || pass_len >= 64){
        return -1;
    }

    CHECK_IDX(idx, CTRL_STA);

    net_no = -1;
    count = lynq_get_network_number_list(idx, CTRL_STA, net_no_list, ap->ap_ssid);

    for (index=0; index < count; index++) {
        net_auth = -1;
        if (0 == inner_get_network_auth(CTRL_STA, net_no_list[index], &net_auth) && net_auth == ap->auth) {
            net_no = net_no_list[index];
            break;
        }
    }

    if (net_no < 0) {
        return -1;
    }

    CHECK_WPA_CTRL(CTRL_STA);

    sprintf(lynq_tmp_cmd,"SET_NETWORK %d psk \"%s\"",net_no, password);

    DO_OK_FAIL_REQUEST(lynq_tmp_cmd);
    DO_OK_FAIL_REQUEST(cmd_save_config);

    return 0;
}

int lynq_sta_ssid_password_get(lynq_wifi_index_e idx, ap_info_s *ap, char *password) { // @todo

    FILE * fp;
    int len, ret, network_len;
    int count, index;
    char *split_lines[128] = {0};
    char *buff, *p;

    network_len = 0;
    p = NULL;

    CHECK_IDX(idx, CTRL_STA);

    if (NULL == password) {
        printf("bad param\n");
        return -1;
    }

    fp = fopen("/data/wifi/wg870/wpa_supplicant.conf", "rb");
    if (NULL == fp) {
        printf("open file fail\n");
        return  -1;
    }

    buff = alloca(MAX_RET);
    fseek(fp, 0, SEEK_SET);
    len = fread(buff, 1, MAX_RET, fp);
    fclose(fp);

    for(index=0; index < len; index ++) {
        for(; index < len; index ++) {
            if (memcmp(buff + index, "network={", 9) != 0) {
                continue;
            }
             p = buff + index + 9;
             for (; index < len; index ++ ) {
                 if (buff[index] != '}') {
                     continue;
                 }
                 buff[index] = '\0';
                 break;
             }
             network_len = buff + index - p;
             break;
        }

        if (strstr(p, ap->ap_ssid) != NULL) {
            break;
        }
    }

    if (index >= len || NULL == p || network_len <= 0) {
        return -1;
    }

    count = lynq_split(p, network_len, '\n', split_lines);

    ret = -1;
    for(index=0; index < count; index++) {
        p = strstr(split_lines[index], "psk=");
        if (p != NULL) {
            p += 4;
            if (*p == '\"') {
                p++;
            }
        }
        else if (NULL != (p = strstr(split_lines[index], "wep_key0="))) {
            p += 9;
            if (*p == '\"') {
                p++;
            }
        }
        else {
            continue;
        }

        strcpy(password, p);

        while(*password != '\0') {
            if (*password == '\"') {
                *password = '\0';
                break;
            }
            password++;
        }
        ret = 0;
        break;
    } //end for(index=0; index < count; index++)

    return ret;
}

static int inner_set_sta_ssid(int net_no, char *sta_ssid)
{
	char lynq_wifi_ssid_cmd[80]={0};

	if (sta_ssid == NULL) {
		printf("sta_ssid is null\n");
		return -1;
    }

	CHECK_WPA_CTRL(CTRL_STA);

    sprintf(lynq_wifi_ssid_cmd,"SET_NETWORK %d ssid \"%s\"", net_no, sta_ssid);

    DO_OK_FAIL_REQUEST(lynq_wifi_ssid_cmd);
//    DO_OK_FAIL_REQUEST(cmd_save_config);

	return 0;

}

static int inner_sta_start_stop(int net_no, int start_flag, int save)
{
    char lynq_disable_cmd[128]={0};
    char lynq_select_cmd[128]={0};

    CHECK_WPA_CTRL(CTRL_STA);

    if (save != 0) {
        if (start_flag != 0)
        {
            sprintf(lynq_select_cmd,"ENABLE_NETWORK %d", net_no);
            DO_OK_FAIL_REQUEST(lynq_select_cmd);
        }
        else
        {
            sprintf(lynq_select_cmd,"DISABLE_NETWORK %d", net_no);
            DO_OK_FAIL_REQUEST(lynq_select_cmd);
        }
        DO_OK_FAIL_REQUEST(cmd_save_config);
    }

    if (start_flag == 0) {
        sprintf(lynq_disable_cmd,"DISCONNECT");
        DO_OK_FAIL_REQUEST(lynq_disable_cmd);
    }
    else {
        sprintf(lynq_select_cmd,"SELECT_NETWORK %d", net_no);
        DO_OK_FAIL_REQUEST(lynq_select_cmd);
    }

    return 0;
}

int lynq_wifi_get_sta_ssid(lynq_wifi_index_e idx, char* sta_ssid)
{
    CHECK_IDX(idx, CTRL_STA);

    curr_status_info curr_state;
    ap_info_s ap_info;
    curr_state.ap = &ap_info;
    curr_state.state = NULL;

    if (0 == inner_get_status_info(CTRL_STA, &curr_state)) {
        strcpy(sta_ssid, ap_info.ap_ssid);
        return 0;
    }

    return -1;
}

int lynq_wifi_get_sta_available_ap(lynq_wifi_index_e idx, ap_detail_info_s *info)
{
    scan_info_s *scan_list = NULL;
    saved_ap_info_s *save_list = NULL;
    int scan_len=0;
    int save_len=0;
    int best_index = -1;
    int best_scan_index = -1;
    int best_rssi = 0;
    int i, j, ret;

    ret = -1;

    CHECK_IDX(idx, CTRL_STA);
    if (info == NULL) {
        return -1;
    }

    curr_status_info curr_state;
    ap_info_s ap_info;
    char status[64];

    memset(&ap_info, 0, sizeof (ap_info));
    memset(status, 0, sizeof (status));

    curr_state.ap = &ap_info;
    curr_state.state = status;

    if (0 == inner_get_status_info(CTRL_STA, &curr_state) && curr_state.net_no >= 0) {
        memcpy(&info->base_info, &ap_info, sizeof (ap_info_s));
        if (strcmp(status, STATE_COMPLETED) == 0)
        {
            info->status = LYNQ_WIFI_AP_STATUS_ENABLE;
        }
        else
        {
            info->status = LYNQ_WIFI_AP_STATUS_DISABLE;
        }
        lynq_get_connect_ap_rssi(idx, &info->rssi);
        lynq_sta_ssid_password_get(idx, & info->base_info, info->base_info.psw);
        return 0;
    }

    lynq_wifi_sta_start_scan(idx);

    if (0 != lynq_get_scan_list(0, &scan_list, &scan_len)) {
        if (NULL != scan_list)
        {
            free(scan_list);
        }
        return -1;
    }

    if (0 != lynq_get_sta_saved_ap(0, &save_list, &save_len)) {
        if (NULL != scan_list)
        {
            free(scan_list);
        }
        if (NULL != save_list)
        {
            free(save_list);
        }
        return -1;
    }

    for (i=0; i < save_len; i++) {
        for (j=0; j < scan_len; j++) {
            if (strcmp(save_list[i].base_info.ap_ssid, scan_list[j].ssid) == 0 //@todo not finished
                    && save_list[i].base_info.auth == scan_list[j].auth) {
                if (best_rssi == 0) {
                    best_index = i;
                    best_rssi = scan_list[j].rssi;
                }
                else if (best_rssi > scan_list[j].rssi) {
                    best_index = i;
                    best_scan_index = j;
                    best_rssi = scan_list[j].rssi;
                }
                break;
            }
        }
    }

    if (best_index >= 0) {
        memcpy(&info->base_info, &save_list[best_index].base_info, sizeof (ap_info_s));
        info->status = LYNQ_WIFI_AP_STATUS_DISABLE;
        info->rssi = best_rssi;
        ret = 0;
    }

    if (NULL != scan_list)
    {
        free(scan_list);
    }
    if (NULL != save_list)
    {
        free(save_list);
    }

    return ret;
}

static int inner_set_sta_auth_psw(int net_no, lynq_wifi_auth_s auth, char *password)
{
    char lynq_auth_cmd[64]={0};
    char lynq_ket_mgmt_cmd[64]={0};
    char lynq_pairwise_cmd[64]={0};
    char lynq_psk_cmd[64]={0};

    CHECK_WPA_CTRL(CTRL_STA);

	switch(auth){
		case LYNQ_WIFI_AUTH_OPEN:
        {
            sprintf(lynq_auth_cmd,"SET_NETWORK %d key_mgmt NONE", net_no);

            DO_OK_FAIL_REQUEST(lynq_auth_cmd);
//            DO_OK_FAIL_REQUEST(cmd_save_config);
			break;
		}
		case LYNQ_WIFI_AUTH_WPA_PSK:
        case LYNQ_WIFI_AUTH_WPA2_PSK:
		{
            if (auth == LYNQ_WIFI_AUTH_WPA_PSK) {
                sprintf(lynq_auth_cmd,"SET_NETWORK %d proto WPA", net_no);
            }
            else if (auth == LYNQ_WIFI_AUTH_WPA2_PSK) {
                sprintf(lynq_auth_cmd,"SET_NETWORK %d proto RSN", net_no);
            }
            sprintf(lynq_ket_mgmt_cmd,"SET_NETWORK %d key_mgmt WPA-PSK", net_no);
            sprintf(lynq_pairwise_cmd,"SET_NETWORK %d pairwise CCMP", net_no);

            DO_OK_FAIL_REQUEST(lynq_auth_cmd);
            DO_OK_FAIL_REQUEST(lynq_ket_mgmt_cmd);
            DO_OK_FAIL_REQUEST(lynq_pairwise_cmd);

            if (password != NULL) {
                sprintf(lynq_psk_cmd, "SET_NETWORK %d psk \"%s\"", net_no, password);
                DO_OK_FAIL_REQUEST(lynq_psk_cmd);
            }

//            DO_OK_FAIL_REQUEST(cmd_save_config);
			break;
		}		
		default:
			return -1;
    }

	return 0;
}

static int inner_get_curr_net_no(int interface) {
    curr_status_info curr_state;
    curr_state.ap = NULL;
    curr_state.state = NULL;

    if (0 != inner_get_status_info(interface, &curr_state)) {
        return -1;
    }

    return curr_state.net_no;
}

int lynq_wifi_get_sta_auth(lynq_wifi_index_e idx, lynq_wifi_auth_s *auth)
{
    int net_no;
    CHECK_IDX(idx, CTRL_STA);

    net_no = inner_get_curr_net_no(CTRL_STA);

    if (net_no < 0) {
        return -1;
    }

    return inner_get_network_auth(CTRL_STA, net_no, auth);
}

int lynq_wifi_sta_connect(lynq_wifi_index_e idx, char *ssid, lynq_wifi_auth_s auth, char *psw)
{
    int count, net_no, index;
    int net_no_list[128];
    lynq_wifi_auth_s net_auth;

    if (ssid == NULL || *ssid == '\0') {
        printf("bad ssid\n");
        return -1;
    }

    if (LYNQ_WIFI_AUTH_OPEN != auth) {
        if (psw == NULL || strlen(psw) < 8 || strlen(psw) >= 64) {
            printf("bad password\n");
            return -1;
        }
    }

    CHECK_IDX(idx, CTRL_STA);

    net_no = -1;
    count = lynq_get_network_number_list(idx, CTRL_STA, net_no_list, ssid);

    for (index=0; index < count; index++) {
        net_auth = -1;
        if (0 == inner_get_network_auth(CTRL_STA, net_no_list[index], &net_auth) && net_auth == auth) {
            net_no = net_no_list[index];
            break;
        }
    }

    if (net_no < 0) {
        net_no = lynq_add_network(CTRL_STA);
        if (net_no == -1) {
            return -1;
        }

        printf("net no is %d\n", net_no);
        if (0 != inner_set_sta_ssid(net_no, ssid)) {
            return -1;
        }
    }

    if (0 != inner_set_sta_auth_psw(net_no, auth, psw)) {
        return -1;
    }

    return inner_sta_start_stop(net_no, 1, 1);
}

int lynq_wifi_sta_disconnect(lynq_wifi_index_e idx, char *ssid)
{
    ap_info_s ap;
    curr_status_info curr_state;
    ap.ap_ssid[0] = '\0';

    if (ssid == NULL || *ssid == '\0') {
        return -1;
    }

    CHECK_IDX(idx, CTRL_STA);

    curr_state.ap = &ap;
    curr_state.state = NULL;

    if (inner_get_status_info(CTRL_STA, &curr_state) != 0) {
        return 0;
    }

    if (strcmp(ap.ap_ssid, ssid) != 0) {
        return 0;
    }

    return inner_sta_start_stop(curr_state.net_no, 0, 0);
}

int lynq_wifi_sta_start(lynq_wifi_index_e idx)
{
    const char *lynq_reconfigure_cmd = "wpa_cli -iwpa_wlan0_cmd -p/var/run/ IFNAME=wlan0 RECONFIGURE /data/wifi/wg870/wpa_supplicant.conf";
    const char *lynq_reconnect_cmd = "RECONNECT";

    CHECK_IDX(idx, CTRL_STA);
    CHECK_WPA_CTRL(CTRL_STA);

    system("connmanctl enable wifi");

    if (system("ifconfig | grep -q wlan0") != 0) {
        return -1;
    }

    DO_OK_FAIL_REQUEST(cmd_remove_all);
    system(lynq_reconfigure_cmd);
    DO_OK_FAIL_REQUEST(lynq_reconnect_cmd);

    return 0;
}

int lynq_wifi_sta_stop(lynq_wifi_index_e idx)
{
    char lynq_disable_network_cmd[MAX_CMD];
    curr_status_info curr_state;
    ap_info_s ap_info;

    CHECK_IDX(idx, CTRL_STA);
    CHECK_WPA_CTRL(CTRL_STA);

    curr_state.ap = &ap_info;
    curr_state.state = NULL;

    if (0 != inner_get_status_info(CTRL_STA, &curr_state) || curr_state.net_no < 0) {
        return 0;
    }

    sprintf(lynq_disable_network_cmd, "DISABLE_NETWORK %d", curr_state.net_no);
    DO_OK_FAIL_REQUEST(lynq_disable_network_cmd);

    DO_OK_FAIL_REQUEST(cmd_save_config);

    return 0;
//    return system("connmanctl disable wifi");
}

//static int inner_get_sta_info(lynq_wifi_index_e idx, const char * bssid, device_info_s *dev) {
//    int i, count;
//    char *p;
//    const char * FLAG_SSID = "ssid=";
//    const char * FLAG_SBSID = "bssid=";
//    const char * FLAG_KEY_MGMT = "key_mgmt=";
//    const char * FLAG_FREQ = "freq=";
//    char lynq_sta_cmd[MAX_CMD];
//    char *split_lines[128] = {0};

//    CHECK_WPA_CTRL(CTRL_AP);

//    sprintf(lynq_sta_cmd, "STA %s", bssid);

//    DO_REQUEST(lynq_sta_cmd);

//    count = lynq_split(cmd_reply, reply_len, '\n', split_lines);

//    for(i=0; i < count; i++) {
//        p = strstr(split_lines[i], FLAG_SSID);
//        if (p != NULL) {
//            strcpy(ap->ap_ssid, p + strlen(FLAG_SSID));
//            continue;
//        }
//    }

//    lynq_get_interface_ip(idx, ap->ap_ip);
//    lynq_ap_password_set(idx, ap->psw);

//    return 0;
//}

static int inner_get_status_info_ap (int interface, ap_info_s *ap) {
    curr_status_info curr_state;
    curr_state.ap = ap;
    curr_state.state = NULL;
    return inner_get_status_info(interface, &curr_state);
}

int lynq_get_ap_device_list(lynq_wifi_index_e idx, ap_info_s **ap, device_info_s ** list,int * len)
{
    int ip_count, index, i, line_count;
    const char *lynq_first_sta_cmd = "STA-FIRST";
    char lynq_next_sta_cmd[MAX_CMD];
    char *bssid[1024] = {0};
    char *mac_list[128] = {0};
    char *ip_list[128] = {0};
    char *split_lines[128] = {0};

    CHECK_IDX(idx, CTRL_AP);

    CHECK_WPA_CTRL(CTRL_AP);

//    ap_info_s * tmp_ap;
//    device_info_s * tmp_list;
    if (ap == NULL || list == NULL || len == NULL) {
        printf("bad input param");
        return -1;
    }

//    ap = &tmp_ap;
//    list = &tmp_list;
    *ap = malloc(sizeof (ap_info_s));

    if (inner_get_status_info_ap (CTRL_AP, *ap) != 0) {
        return -1;
    }

    lynq_get_interface_ip(idx, (*ap)->ap_ip);
    lynq_ap_password_get(idx, (*ap)->psw);

    ip_count = get_ip_mac_list(mac_list, ip_list);
    printf("get count %d\n", ip_count);

    DO_REQUEST(lynq_first_sta_cmd);

    index = 0;
    while (reply_len > 0) {
        if (memcmp(cmd_reply, "FAIL", 4) == 0) {
            break;
        }
        line_count = lynq_split(cmd_reply, reply_len, '\n', split_lines);
        bssid[index] = malloc(strlen(split_lines[0]) + 1);
        strcpy(bssid[index], split_lines[0]);
        index++;
        sprintf(lynq_next_sta_cmd, "STA-NEXT %s", split_lines[0]);
        reply_len = MAX_RET;
        cmd_reply[0] = '\0';
        ret = wpa_ctrl_request(lynq_wpa_ctrl, lynq_next_sta_cmd, strlen(lynq_next_sta_cmd), cmd_reply, &reply_len, NULL);
        if (ret != 0 || memcmp(cmd_reply, "FAIL", 4) == 0) {
            printf("run %s fail \n", lynq_next_sta_cmd);
            break;
        }
    }

    *len = index;

    *list = malloc(sizeof(device_info_s) * (*len));
    for (index=0; index < *len; index++) {
        strcpy((*list)[index].sta_mac, bssid[index]);
        for(i=0;i < ip_count; i++ ) {
            if (strcmp(bssid[index], mac_list[i]) == 0) {
                strcpy((*list)[index].sta_ip, ip_list[i]);
                break;
            }
        }
        get_hostname_by_ip((*list)[index].sta_ip, list[index]->hostname);
        (*list)[index].status = LYNQ_WIFI_STATUS_CONNECT;
        free(bssid[index]);
    }

    free_ip_mac_list_mem(mac_list, 128, ip_list, 128);

    return 0;
}

int lynq_get_scan_list(lynq_wifi_index_e idx, scan_info_s ** list,int * len)
{
    int i, count, index, count_words;
    const char *lynq_scan_result_cmd = "SCAN_RESULTS";
    char *split_lines[128] = {0};
    char *split_words[128] = {0};
    scan_info_s * p;

    if (list == NULL || len == NULL) {
        return -1;
    }

    for (i =0; i < 50 && g_sta_scan_finish_flag == 0; i++)
    {
        usleep(100 * 1000);
    }

    CHECK_IDX(idx, CTRL_STA);

    CHECK_WPA_CTRL(CTRL_STA);

    DO_REQUEST(lynq_scan_result_cmd);

    count = lynq_split(cmd_reply, reply_len, '\n', split_lines);
    *len = count - 1;
    *list = malloc(sizeof (scan_info_s) * *len);

    count_words = lynq_split(split_lines[0], strlen(split_lines[0]), '/', split_words); //@todo get with header
    for (index=0; index <count_words; index++) {
        printf("----header: %s\n", split_words[index]);
    }

    for(index = 1;index < count; index++) {
        printf("---- %s\n",split_lines[index]);
        count_words = lynq_split(split_lines[index], strlen(split_lines[index]), '\t', split_words);
        if (count_words < 4)
            continue;
        printf("count: %d, %s\n", count_words, split_words[0]);
        //bssid / frequency / signal level / flags / ssid
        p = (*list) + index - 1;
        strcpy(p->mac, split_words[0]);
        p->band = convert_band_from_freq(atoi(split_words[1]));
        p->rssi = -1 * atoi( split_words[2]);
        p->auth = convert_max_auth_from_flag(split_words[3]);
        strcpy(p->ssid, split_words[4]);
    }

    return 0;
}

int lynq_sta_forget_ap(lynq_wifi_index_e idx, char *ssid, lynq_wifi_auth_s auth)
{
    int count, net_no, index;
    int net_no_list[128];
    lynq_wifi_auth_s net_auth;
    char lynq_remove_cmd[MAX_CMD];

    if (ssid == NULL || *ssid == '\0') {
        printf("bad ssid\n");
        return -1;
    }

    CHECK_IDX(idx, CTRL_STA);

    CHECK_WPA_CTRL(CTRL_STA);

    net_no = -1;
    count = lynq_get_network_number_list(idx, CTRL_STA, net_no_list, ssid);

    for (index=0; index < count; index++) {
        net_auth = -1;
        if (0 == inner_get_network_auth(CTRL_STA, net_no_list[index], &net_auth) && net_auth == auth) {
            net_no = net_no_list[index];
            break;
        }
    }

    if (net_no < 0) {
        return 0;
    }

    sprintf(lynq_remove_cmd, "REMOVE_NETWORK %d", net_no);

    DO_OK_FAIL_REQUEST(lynq_remove_cmd);
    DO_OK_FAIL_REQUEST(cmd_save_config);

    return 0;
}

int lynq_get_sta_saved_ap(lynq_wifi_index_e idx, saved_ap_info_s ** list, int * len)
{    
    int count, index, ssid_len;
    int net_no_list[128];
    char freq[16];
    char *ssid_ptr;

    if (list == NULL || len == NULL) {
        printf("bad param\n");
        return -1;
    }

    CHECK_IDX(idx, CTRL_STA);

//    CHECK_WPA_CTRL(CTRL_STA);

    count = lynq_get_network_number_list(idx, CTRL_STA, net_no_list, NULL);
    printf("count is %d\n", count);

    *list = malloc(sizeof (saved_ap_info_s) * count);
    memset(*list, 0, sizeof (saved_ap_info_s) * count);
    *len = count;

    for (index=0; index < count; index++) {
        printf("to get ssid %d\n", index);
        inner_get_param(CTRL_STA, net_no_list[index], "ssid", (*list)[index].base_info.ap_ssid);

        ssid_ptr = (*list)[index].base_info.ap_ssid;
        ssid_len = strlen(ssid_ptr);
        if (ssid_ptr[0] == '\"') {
            memmove(ssid_ptr, ssid_ptr + 1, ssid_len - 1);
            ssid_len -= 1;
        }
        if (ssid_len > 0 && ssid_ptr[ssid_len - 1] == '\"') {
            ssid_ptr[ssid_len - 1] = '\0';
        }

        inner_get_param(CTRL_STA, net_no_list[index], "bssid", (*list)[index].base_info.ap_mac);
        inner_get_network_auth(CTRL_STA, net_no_list[index], &(*list)[index].base_info.auth);
        if (inner_get_param(CTRL_STA, net_no_list[index], "frequency", freq) == 0) {
            (*list)[index].base_info.band = convert_band_from_freq(atoi(freq));
        }
        else {
            (*list)[index].base_info.band = -1;
        }

        lynq_sta_ssid_password_get(idx, & (*list)[index].base_info, (*list)[index].base_info.psw);
    }

    return 0;
}

int lynq_wifi_sta_start_scan(lynq_wifi_index_e idx)
{
    const char *lynq_scan_cmd = "SCAN";

    CHECK_IDX(idx, CTRL_STA);

    CHECK_WPA_CTRL(CTRL_STA);

    DO_OK_FAIL_REQUEST(lynq_scan_cmd);
    g_sta_scan_finish_flag = 0;

    return 0;
}

int lynq_reg_ap_event_callback(void * priv, AP_CALLBACK_FUNC_PTR cb) {
    if (cb == NULL) {
        return -1;
    }

    g_ap_callback_priv = priv;
    g_ap_callback_func = cb;

    return 0;
}

int lynq_unreg_ap_event_callback(void * priv) {
    if (g_ap_callback_priv == priv) {
        g_ap_callback_func = NULL;
        g_ap_callback_priv = NULL;
        return 0;
    }
    return -1;
}

int lynq_reg_sta_event_callback(void * priv, STA_CALLBACK_FUNC_PTR cb){
    if (cb == NULL) {
        return -1;
    }

    g_sta_callback_priv = priv;
    g_sta_callback_func = cb;

    return 0;
}

int lynq_unreg_sta_event_callback(void * priv) {
    if (g_sta_callback_priv == priv) {
        g_sta_callback_func = NULL;
        g_sta_callback_priv = NULL;
        return 0;
    }
    return -1;
}


static int inner_get_status_info_state (int interface, char *state) {
    curr_status_info curr_state;
    curr_state.ap = NULL;
    curr_state.state = state;
    return inner_get_status_info(interface, &curr_state);
}

int lynq_get_ap_status(lynq_wifi_index_e idx, lynq_wifi_ap_run_status_s * ap_status)
{
    char state[MAX_CMD];
    CHECK_IDX(idx, CTRL_AP);

    if (inner_get_status_info_state(CTRL_AP, state) != 0) {
        *ap_status = LYNQ_WIFI_AP_STATUS_DISABLE;
        return 0;
    }

    if (memcmp(state, STATE_COMPLETED, strlen (STATE_COMPLETED)) == 0) {
        *ap_status = LYNQ_WIFI_AP_STATUS_ENABLE;
    }
    else {
        *ap_status = LYNQ_WIFI_AP_STATUS_DISABLE;
    }

    return 0;
}

int lynq_get_sta_status(lynq_wifi_index_e idx, lynq_wifi_sta_run_status_s * sta_status) {
    char state[MAX_CMD];
    CHECK_IDX(idx, CTRL_STA);

    if (inner_get_status_info_state(CTRL_STA, state) != 0) {
        *sta_status = LYNQ_WIFI_STA_STATUS_DISABLE;
        return 0;
    }

    if (memcmp(state, STATE_COMPLETED, strlen (STATE_COMPLETED)) == 0) {
        *sta_status = LYNQ_WIFI_STA_STATUS_ENABLE;
    }
    else {
        *sta_status = LYNQ_WIFI_STA_STATUS_DISABLE;
    }

    return 0;
}

int lynq_get_country_code(lynq_wifi_index_e idx, char * country_code) {
//    CHECK_IDX(idx, CTRL_AP);
//    int ret = 0;
//    size_t reply_len = MAX_RET;
//    char cmd_reply[MAX_RET]={0};
//    const char * cmd_str = "GET country";
//    struct wpa_ctrl *s_lynq_wpa_ctrl = NULL;
//    do{
//        if (NULL == s_lynq_wpa_ctrl) {
//            s_lynq_wpa_ctrl = wpa_ctrl_open("/var/run/wpa_wlan0_cmd");
//            if (NULL == s_lynq_wpa_ctrl ) {
//                printf("wpa_ctrl_open fail\n");
//                return -1;
//            }
//        }
//    }while(0);

//    do {
//        reply_len = MAX_RET;
//        cmd_reply[0] = '\0';
//        printf("to call [%s]\n", cmd_str);
//        ret = wpa_ctrl_request(s_lynq_wpa_ctrl, cmd_str, strlen(cmd_str), cmd_reply, &reply_len, NULL);
//        if (ret != 0) {
//            printf("call ##cmd_str fail %d\n", ret);
//            return ret;
//        }
//        cmd_reply[reply_len+1] = '\0';
//        printf("cmd replay [ %s ]\n", cmd_reply);
//    }while(0);

    FILE *fp;
    size_t i = 0;
    char lynq_cmd_ret[MAX_RET]={0};

//    CHECK_IDX(idx, CTRL_AP);

    if((fp=popen("wl country","r"))==NULL)
        {
            perror("popen error!");
            return -1;
        }
    if((fread(lynq_cmd_ret,sizeof(lynq_cmd_ret),1,fp))<0)
    {
        perror("fread fail!");
        return -1;
    }

    for(i=0; i < strlen(lynq_cmd_ret); i++) {
        if (lynq_cmd_ret[i] == ' ') {
            lynq_cmd_ret[i] = '\0';
            break;
        }
    }

    strcpy(country_code,lynq_cmd_ret);
    printf("---country code %s\n", country_code);

    int ret=pclose(fp);
    if(ret==-1)
    {
        perror("close file faild");
    }

    return 0;
}

int lynq_set_country_code(lynq_wifi_index_e idx, char * country_code) {
//    const char * cmd_str = "GET country";
//    CHECK_IDX(idx, CTRL_AP);
//    CHECK_WPA_CTRL(CTRL_STA);

//    DO_REQUEST(cmd_str);
//    printf("result %s\n", cmd_reply);

    if (country_code == NULL || *country_code == '\0') {
        printf("bad country code\n");
        return -1;
    }

    char lynq_country_cmd[MAX_CMD];
    sprintf(lynq_country_cmd, "wl country %s", country_code);
    if (system(lynq_country_cmd) == 0) {
        return 0;
    }

    return -1;
}

int lynq_get_connect_ap_mac(lynq_wifi_index_e idx,char *mac)
{
    if (mac == NULL) {
        return -1;
    }

    CHECK_IDX(idx, CTRL_STA);
    ap_info_s ap;
    ap.ap_mac[0] = '\0';

    if (inner_get_status_info_ap(CTRL_STA, &ap) != 0) {
        return -1;
    }
    strcpy(mac, ap.ap_mac);

    return 0;
}

int lynq_get_interface_ip(lynq_wifi_index_e idx, char *ip)
{
    struct ifaddrs *ifaddr_header, *ifaddr;
    struct in_addr * ifa;
    const char * ifaName = "wlan0";
    if (ip == NULL)
    {
       return -1;
    }

    if (idx == 1) {
       ifaName = "tether";
    }
    else if (idx != 0) {
       return -1;
    }

    if (getifaddrs(&ifaddr_header) == -1)
    {
       perror("getifaddrs");
       return -1;
       //exit(EXIT_FAILURE);
    }


    for (ifaddr = ifaddr_header; ifaddr != NULL; ifaddr = ifaddr->ifa_next)
    {
        if (ifaddr->ifa_addr == NULL)
           continue;
        if((strcmp(ifaddr->ifa_name,ifaName)==0))
        {
            if (ifaddr->ifa_addr->sa_family==AF_INET) // check it is IP4
            {
               // is a valid IP4 Address
               ifa=&((struct sockaddr_in *)ifaddr->ifa_addr)->sin_addr;
               inet_ntop(AF_INET, ifa, ip, INET_ADDRSTRLEN);
               printf("%s IP Address %s/n", ifaddr->ifa_name, ip);
               freeifaddrs(ifaddr_header);
               printf("ip %s\n", ip);
               return 0;
            }
        }
    }
    return -1;
}

int lynq_get_interface_mac(lynq_wifi_index_e idx,char *mac)
{
    int count;
    size_t i;
    char *split_words[128] = {0};
    const char *lynq_get_mac_cmd = "DRIVER MACADDR";

    CHECK_WPA_CTRL(idx);

    DO_REQUEST(lynq_get_mac_cmd);

    if (memcmp(cmd_reply, "FAIL", 4) == 0) {
        return -1;
    }

    count = lynq_split(cmd_reply, reply_len, '=', split_words);

    if (count < 2) {
        return -1;
    }

    for (i=0; i < strlen(split_words[1]); i++ ) {
        if (split_words[1][i] != ' ') {
            break;
        }
    }

    strcpy(mac, split_words[1] + i);

    return 0;
}

int lynq_get_connect_ap_rssi(lynq_wifi_index_e idx,int * rssi)
{
//    int count;
//    char *split_words[128] = {0};
//    const char *lynq_get_rssi_cmd = "DRIVER RSSI";

//    if (rssi == NULL) {
//        return -1;
//    }

//    CHECK_IDX(idx, CTRL_STA);

//    CHECK_WPA_CTRL(CTRL_STA);

//    DO_REQUEST(lynq_get_rssi_cmd);

//    if (memcmp(cmd_reply, "FAIL", 4) == 0) {
//        return -1;
//    }

//    count = lynq_split(cmd_reply, reply_len, ' ', split_words);

//    if (count < 2) {
//        return -1;
//    }

//    *rssi = atoi(split_words[1]) * -1;

    FILE *fp;
    size_t i = 0;
    char lynq_cmd_ret[MAX_RET]={0};

//    CHECK_IDX(idx, CTRL_AP);
/*******change other cmd to get rssi*******
 *
 *wl rssi ---> wl -i wlan0 rssi
 *
 ***** change by qs.xiong 20221011*******/
    if((fp=popen("wl -i wlan0 rssi","r"))==NULL)
        {
            perror("popen error!");
            return -1;
        }
    if((fread(lynq_cmd_ret,sizeof(lynq_cmd_ret),1,fp))<0)
    {
        perror("fread fail!");
        return -1;
    }
    *rssi = atoi(lynq_cmd_ret) * -1;
/****** if got rssi is 0,means sta didn't connected any device****/
    if(*rssi == 0)
    {
        printf("sta didn't connected any ap device,please check connection\n");
    }

    return 0;
}

int lynq_get_connect_ap_band(lynq_wifi_index_e idx, lynq_wifi_band_m * band)
{
    if (band == NULL) {
        return -1;
    }

    CHECK_IDX(idx, CTRL_STA);
    ap_info_s ap;
    ap.band = -1;

    if (inner_get_status_info_ap(CTRL_STA, &ap) != 0) {
        return -1;
    }
    *band = ap.band;

    return 0;
}

int lynq_get_connect_ap_ip(lynq_wifi_index_e idx, char *ip)
{
    int index;
    int ip_count = 0;
    char bssid[1024] = {0};
    char *mac_list[128] = {0};
    char *ip_list[128] = {0};

    if (ip == NULL)
    {
        printf("invalid param");
        return -1;
    }

    CHECK_IDX(idx, CTRL_STA);

    if (lynq_get_connect_ap_mac(idx, bssid) != 0)
    {
        return -1;
    }

    ip_count = get_ip_mac_list(mac_list, ip_list);

    for (index=0; index < ip_count; index++)
    {
        if (strcmp(bssid, mac_list[index]) == 0)
        {
            strcpy(ip, ip_list[index]);

            free_ip_mac_list_mem(mac_list, 128, ip_list, 128);

            return 0;
        }
    }

    printf("not found\n");
    free_ip_mac_list_mem(mac_list, 128, ip_list, 128);

    return -1;
}

int lynq_ap_connect_num(int sta_number)
{
    char lynq_limit_cmd[32]={0};
    int ret;
    if((sta_number < 1 ) && (sta_number > 15)){
        printf("sta_number: not in range\n",sta_number);
        return -1;
    }
    sprintf(lynq_limit_cmd,"wl maxassoc  %d", sta_number);
    ret = system(lynq_limit_cmd);
    if(ret != 0){
        printf("cmd of limit ap devices number error\n");
    }
    return 0;
}