| /* |
| * If not stated otherwise in this file or this component's LICENSE file the |
| * following copyright and licenses apply: |
| * |
| * Copyright 2019 RDK Management |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <string.h> |
| #include <fcntl.h> |
| #include <stdbool.h> |
| #include "wifi_hal.h" |
| #include "client_wifi_hal.h" |
| |
| #include <ev.h> |
| #include <wpa_ctrl.h> |
| #include <errno.h> |
| #include <net/if.h> |
| #define CTRL_INTERFACE "/var/run/wpa_supplicant" |
| |
| /* Helper wpa_supplicant events */ |
| #ifndef container_of |
| #define offsetof(st, m) ((size_t)&(((st *)0)->m)) |
| #define container_of(ptr, type, member) \ |
| ((type *)((char *)ptr - offsetof(type, member))) |
| #endif /* container_of */ |
| static int _syscmd(char *cmd, char *retBuf, int retBufSize) |
| { |
| FILE *f; |
| char *ptr = retBuf; |
| int bufSize=retBufSize, bufbytes=0, readbytes=0, cmd_ret=0; |
| |
| if((f = popen(cmd, "r")) == NULL) { |
| fprintf(stderr,"\npopen %s error\n", cmd); |
| return RETURN_ERR; |
| } |
| |
| while(!feof(f)) |
| { |
| *ptr = 0; |
| if(bufSize>=128) { |
| bufbytes=128; |
| } else { |
| bufbytes=bufSize-1; |
| } |
| |
| fgets(ptr,bufbytes,f); |
| readbytes=strlen(ptr); |
| |
| if(!readbytes) |
| break; |
| |
| bufSize-=readbytes; |
| ptr += readbytes; |
| } |
| cmd_ret = pclose(f); |
| retBuf[retBufSize-1]=0; |
| |
| return cmd_ret >> 8; |
| } |
| |
| struct ctrl { |
| char sockpath[128]; |
| char sockdir[128]; |
| char bss[IFNAMSIZ]; |
| int ssid_index; |
| void (*cb)(struct ctrl *ctrl, int level, const char *buf, size_t len); |
| void (*overrun)(struct ctrl *ctrl); |
| void (*closed)(struct ctrl *ctrl); |
| struct wpa_ctrl *wpa; |
| unsigned int ovfl; |
| int initialized; |
| ev_timer retry; |
| ev_stat stat; |
| ev_io io; |
| char reply[4096]; |
| size_t reply_len; |
| ev_timer watchdog; |
| }; |
| static wifi_client_event_callback clients_connect_cb; |
| static struct ctrl wpa_ctrl[2]; |
| static int client_initialized; |
| |
| static void ctrl_close(struct ctrl *ctrl) |
| { |
| if (ctrl->io.cb) |
| ev_io_stop(EV_DEFAULT_ &ctrl->io); |
| if (ctrl->retry.cb) |
| ev_timer_stop(EV_DEFAULT_ &ctrl->retry); |
| if (ctrl->watchdog.cb) |
| ev_timer_stop(EV_DEFAULT_ &ctrl->watchdog); |
| if (!ctrl->wpa) |
| return; |
| |
| wpa_ctrl_detach(ctrl->wpa); |
| wpa_ctrl_close(ctrl->wpa); |
| ctrl->wpa = NULL; |
| |
| if (ctrl->closed) |
| ctrl->closed(ctrl); |
| } |
| |
| static void ctrl_process(struct ctrl *ctrl) |
| { |
| char *str; |
| size_t len; |
| char buf[1024]; |
| int drops; |
| int level; |
| int err; |
| char * k; |
| char * v; |
| char *kv; |
| wifi_client_associated_dev_t ap; |
| memset(&ap, 0, sizeof(ap)); |
| |
| /* Example events: |
| * |
| * CTRL-EVENT-CONNECTED - Connection to 00:1d:73:73:88:ea completed [id=0 id_str=] |
| * CTRL-EVENT-DISCONNECTED bssid=00:1d:73:73:88:ea reason=3 locally_generated=1 |
| */ |
| if (!(str = index(ctrl->reply, '>'))) |
| return; |
| if (sscanf(ctrl->reply, "<%d>", &level) != 1) |
| return; |
| |
| str++; |
| |
| if (strncmp("CTRL-EVENT-CONNECTED ", str, 21) == 0) { |
| strsep(&str, " "); /* "-" */ |
| strsep(&str, " "); /* "Connection" */ |
| strsep(&str, " "); /* "to" */ |
| |
| sscanf(str, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", |
| &ap.MACAddress[0], &ap.MACAddress[1], &ap.MACAddress[2], |
| &ap.MACAddress[3], &ap.MACAddress[4], &ap.MACAddress[5]); |
| strsep(&str, " [id="); // completed |
| ap.NetworkID = atoi(str); |
| |
| ap.connected = true; |
| |
| (clients_connect_cb)(ctrl->ssid_index, &ap); |
| goto handled; |
| } |
| if (strncmp("CTRL-EVENT-DISCONNECTED ", str, 24) == 0) { |
| while ((kv = strsep(&str, " "))) { |
| if ((k = strsep(&kv, "=")) && |
| (v = strsep(&kv, ""))) { |
| if (!strcmp(k, "bssid")) |
| sscanf(v, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", |
| &ap.MACAddress[0], &ap.MACAddress[1], &ap.MACAddress[2], |
| &ap.MACAddress[3], &ap.MACAddress[4], &ap.MACAddress[5]); |
| |
| else if (!strcmp(k, "reason")) |
| ap.reason = atoi(v); |
| else if (!strcmp(k, "locally_generated")) |
| ap.locally_generated = atoi(v); |
| } |
| } |
| ap.connected = false; |
| (clients_connect_cb)(ctrl->ssid_index, &ap); |
| goto handled; |
| } |
| |
| handled: |
| |
| return; |
| |
| } |
| |
| static void ctrl_ev_cb(EV_P_ struct ev_io *io, int events) { |
| struct ctrl *ctrl = container_of(io, struct ctrl, io); |
| int err; |
| |
| ctrl->reply_len = sizeof(ctrl->reply) - 1; |
| err = wpa_ctrl_recv(ctrl->wpa, ctrl->reply, &ctrl->reply_len); |
| ctrl->reply[ctrl->reply_len] = 0; |
| if (err < 0) { |
| if (errno == EAGAIN || errno == EWOULDBLOCK) |
| return; |
| ctrl_close(ctrl); |
| ev_timer_again(EV_A_ &ctrl->retry); |
| return; |
| } |
| |
| ctrl_process(ctrl); |
| } |
| |
| static int ctrl_open(struct ctrl *ctrl) |
| { |
| int fd; |
| |
| if (ctrl->wpa) |
| return 0; |
| |
| ctrl->wpa = wpa_ctrl_open(ctrl->sockpath); |
| if (!ctrl->wpa) |
| goto err; |
| |
| if (wpa_ctrl_attach(ctrl->wpa) < 0) |
| goto err_close; |
| |
| fd = wpa_ctrl_get_fd(ctrl->wpa); |
| if (fd < 0) |
| goto err_detach; |
| ev_io_init(&ctrl->io, ctrl_ev_cb, fd, EV_READ); |
| ev_io_start(EV_DEFAULT_ &ctrl->io); |
| |
| ev_timer_again(EV_DEFAULT_ &ctrl->watchdog); |
| |
| return 0; |
| |
| err_detach: |
| wpa_ctrl_detach(ctrl->wpa); |
| err_close: |
| wpa_ctrl_close(ctrl->wpa); |
| err: |
| ctrl->wpa = NULL; |
| return -1; |
| } |
| |
| static void ctrl_msg_cb(char *buf, size_t len) |
| { |
| struct ctrl *ctrl = container_of(buf, struct ctrl, reply); |
| ctrl_process(ctrl); |
| } |
| |
| static int ctrl_request(struct ctrl *ctrl, const char *cmd, size_t cmd_len, char *reply, size_t *reply_len) |
| { |
| int err; |
| |
| if (!ctrl->wpa) |
| return -1; |
| if (*reply_len < 2) |
| return -1; |
| |
| (*reply_len)--; |
| ctrl->reply_len = sizeof(ctrl->reply); |
| err = wpa_ctrl_request(ctrl->wpa, cmd, cmd_len, ctrl->reply, &ctrl->reply_len, ctrl_msg_cb); |
| if (err < 0) |
| return err; |
| |
| if (ctrl->reply_len > *reply_len) |
| ctrl->reply_len = *reply_len; |
| |
| *reply_len = ctrl->reply_len; |
| memcpy(reply, ctrl->reply, *reply_len); |
| reply[*reply_len] = 0; |
| return 0; |
| } |
| |
| static void |
| ctrl_watchdog_cb(EV_P_ ev_timer *timer, int events) |
| { |
| struct ctrl *ctrl = container_of(timer, struct ctrl, watchdog); |
| const char *pong = "PONG"; |
| const char *ping = "PING"; |
| char reply[1024]; |
| size_t len = sizeof(reply); |
| int err; |
| err = ctrl_request(ctrl, ping, strlen(ping), reply, &len); |
| if (err == 0 && len > strlen(pong) && !strncmp(reply, pong, strlen(pong))) { |
| return; |
| } |
| ctrl_close(ctrl); |
| ev_timer_again(EV_A_ &ctrl->retry); |
| } |
| |
| |
| static void ctrl_stat_cb(EV_P_ ev_stat *stat, int events) |
| { |
| struct ctrl *ctrl = container_of(stat, struct ctrl, stat); |
| |
| printf("%s: file state changed", ctrl->bss); |
| ctrl_open(ctrl); |
| } |
| |
| static void ctrl_retry_cb(EV_P_ ev_timer *timer, int events) |
| { |
| struct ctrl *ctrl = container_of(timer, struct ctrl, retry); |
| |
| printf("CTRL %s: retrying", ctrl->bss); |
| if (ctrl_open(ctrl) < 0) |
| ev_timer_again(EV_DEFAULT_ &ctrl->retry); |
| } |
| |
| static int ctrl_enable(struct ctrl *ctrl) |
| { |
| if (ctrl->wpa) |
| return 0; |
| |
| if (!ctrl->stat.cb) { |
| ev_stat_init(&ctrl->stat, ctrl_stat_cb, ctrl->sockpath, 0.); |
| ev_stat_start(EV_DEFAULT_ &ctrl->stat); |
| } |
| |
| if (!ctrl->retry.cb) |
| ev_timer_init(&ctrl->retry, ctrl_retry_cb, 0., 5.); |
| |
| if (!ctrl->watchdog.cb) |
| ev_timer_init(&ctrl->watchdog, ctrl_watchdog_cb, 0., 30.); |
| |
| |
| return ctrl_open(ctrl); |
| } |
| |
| /* client API */ |
| INT wifi_getSTANumberOfEntries(ULONG *output) //Tr181 |
| { |
| char cmd[128] = {0}; |
| char buf[16] = {0}; |
| |
| if (NULL == output) |
| return RETURN_ERR; |
| |
| snprintf(cmd, sizeof(cmd), "wpa_cli -g%s-global status | grep ^ifname | wc -l", CTRL_INTERFACE); |
| _syscmd(cmd, buf, sizeof(buf)); |
| // *output = 2; |
| *output = strtoll(buf, NULL, 10); |
| return RETURN_OK; |
| } |
| |
| INT wifi_getSTAName(INT apIndex, CHAR *output_string) |
| { |
| int radioIndex = 0; |
| int staIndex = 0; |
| |
| if (NULL == output_string || apIndex < 0) |
| return RETURN_ERR; |
| |
| wifi_getSTARadioIndex(apIndex, &radioIndex); |
| staIndex = apIndex % radioIndex; |
| snprintf(output_string, 33, "radio%d-sta%d", radioIndex, staIndex); |
| |
| return RETURN_OK; |
| } |
| |
| INT wifi_getSTARadioIndex(INT ssidIndex, INT *radioIndex) |
| { |
| if (NULL == radioIndex) |
| return RETURN_ERR; |
| *radioIndex = ssidIndex%MAX_NUM_RADIOS; |
| return RETURN_OK; |
| } |
| |
| INT wifi_getSTAMAC(INT ssidIndex, CHAR *output_string) |
| { |
| char cmd[128] = {0}; |
| int ret = 0; |
| char ssid_ifname[128]; |
| |
| if (NULL == output_string) |
| return RETURN_ERR; |
| |
| ret = wifi_getSTAName(ssidIndex, ssid_ifname); |
| if (ret != RETURN_OK) |
| { |
| return RETURN_ERR; |
| } |
| |
| sprintf(cmd, "wpa_cli -i%s status |grep '^address' | cut -f 2 -d =", ssid_ifname); |
| _syscmd(cmd, output_string, 64); |
| |
| return RETURN_OK; |
| } |
| |
| INT wifi_getSTABSSID(INT ssidIndex, CHAR *output_string) |
| { |
| char cmd[128] = {0}; |
| int ret = 0; |
| char ssid_ifname[128]; |
| |
| if (NULL == output_string) |
| return RETURN_ERR; |
| |
| ret = wifi_getSTAName(ssidIndex, ssid_ifname); |
| if (ret != RETURN_OK) |
| { |
| return RETURN_ERR; |
| } |
| |
| sprintf(cmd, "wpa_cli -i%s status |grep bssid | cut -f 2 -d =", ssid_ifname); |
| _syscmd(cmd, output_string, 64); |
| |
| return RETURN_OK; |
| } |
| |
| INT wifi_setSTABSSID(INT ssidIndex, CHAR *input_string) |
| { |
| char cmd[128] = {0}; |
| int ret = 0; |
| char ssid_ifname[128]; |
| char buf[128] = {0}; |
| |
| ret = wifi_getSTAName(ssidIndex, ssid_ifname); |
| if (ret != RETURN_OK) |
| return RETURN_ERR; |
| |
| snprintf(cmd, sizeof(cmd), "ip link set dev %s address %s", ssid_ifname, input_string); |
| _syscmd(cmd, buf, sizeof(buf)); |
| |
| return RETURN_OK; |
| } |
| |
| INT wifi_getSTASSID(INT ssidIndex, CHAR *output_string) |
| { |
| char cmd[128] = {0}; |
| int ret = 0; |
| char ssid_ifname[128]; |
| |
| if (NULL == output_string) |
| return RETURN_ERR; |
| |
| ret = wifi_getSTAName(ssidIndex, ssid_ifname); |
| if (ret != RETURN_OK) |
| { |
| return RETURN_ERR; |
| } |
| |
| sprintf(cmd, "wpa_cli -i%s status |grep ^ssid | cut -f 2 -d = | tr -d '\n'", ssid_ifname); |
| _syscmd(cmd, output_string, 64); |
| |
| return RETURN_OK; |
| } |
| |
| INT wifi_getSTACredentials(INT ssidIndex, CHAR *output_string) |
| { |
| char cmd[128] = {0}; |
| int ret = 0; |
| char ssid_ifname[128]; |
| |
| if (NULL == output_string) |
| return RETURN_ERR; |
| |
| ret = wifi_getSTAName(ssidIndex, ssid_ifname); |
| if (ret != RETURN_OK) |
| { |
| return RETURN_ERR; |
| } |
| |
| sprintf(cmd, "wpa_cli -i%s status |grep ssid | cut -f 2 -d =", ssid_ifname); |
| _syscmd(cmd, output_string, 64); |
| |
| return RETURN_OK; |
| } |
| |
| static int init_client_wpa() |
| { |
| int ret = 0, i = 0; |
| ULONG s, snum; |
| char * sock_path; |
| char ssid_ifname[128]; |
| |
| ret = wifi_getSTANumberOfEntries(&snum); |
| if (ret != RETURN_OK) { |
| printf("%s: failed to get SSID count", __func__); |
| return RETURN_ERR; |
| } |
| |
| for (s = 0; s < snum; s++) { |
| ret = wifi_getSTAName(s, ssid_ifname); |
| if (ret != RETURN_OK) |
| { |
| return RETURN_ERR; |
| } |
| sprintf(wpa_ctrl[s].sockpath, "%s/%s", CTRL_INTERFACE, ssid_ifname); |
| wpa_ctrl[s].ssid_index = s; |
| printf("Opening ctrl for %s\n", ssid_ifname); |
| if (ctrl_enable(&wpa_ctrl[s])) |
| { |
| return RETURN_ERR; |
| } |
| } |
| |
| client_initialized = 1; |
| |
| return RETURN_OK; |
| } |
| |
| void wifi_client_event_callback_register(wifi_client_event_callback callback_proc) |
| { |
| clients_connect_cb = callback_proc; |
| printf("Registering callback STA\n"); |
| if (!client_initialized) |
| init_client_wpa(); |
| } |
| |
| INT wifi_getSTANetworks(INT apIndex, wifi_sta_network_t **out_staNetworks_array, INT out_array_size, BOOL *out_scan_cur_freq) |
| { |
| FILE *fd = NULL; |
| char fname[100]; |
| char * line = NULL; |
| char * pos = NULL; |
| size_t len = 0; |
| ssize_t read = 0; |
| int id = 0; |
| int ret = 0; |
| char * k; |
| char * v; |
| char *kv; |
| wifi_sta_network_t * staNetwork; |
| |
| if(out_array_size <= 0 ) |
| return RETURN_ERR; |
| |
| char ssid_ifname[128]; |
| |
| ret = wifi_getSTAName(apIndex, ssid_ifname); |
| if (ret != RETURN_OK) |
| return RETURN_ERR; |
| |
| snprintf(fname, sizeof(fname), "/nvram/%s.conf", ssid_ifname); |
| fd = fopen(fname, "r"); |
| if (!fd) |
| return RETURN_ERR; |
| |
| staNetwork= *out_staNetworks_array; |
| while ((read = getline(&line, &len, fd)) != -1) { |
| if(!strncmp(line, "network={",strlen("network={"))) { |
| read = getline(&line, &len, fd) ; |
| staNetwork->id = id; |
| while (strncmp(line,"}",1)) { |
| if ((k = strsep(&line, "=")) && |
| (v = strsep(&line, ""))) { |
| if (!strcmp(k, "\tssid")) |
| { |
| v++; //skip quote |
| v = strsep(&v, "\""); |
| strncpy(staNetwork->ssid, v,32); |
| } |
| else if (!strcmp(k, "\tpsk")) |
| { |
| v++; //skip quote |
| v = strsep(&v, "\""); |
| strncpy(staNetwork->psk, v,128); |
| } |
| else if (!strcmp(k, "\tpairwise")) |
| strncpy(staNetwork->pairwise, v,64); |
| else if (!strcmp(k, "\tkey_mgmt")) |
| strncpy(staNetwork->key_mgmt, v,64); |
| else if (!strcmp(k, "\tproto")) |
| { |
| v = strsep(&v, "\n"); |
| strncpy(staNetwork->proto, v,64); |
| } |
| else if (!strcmp(k, "\tbssid")) |
| sscanf(v, "%02x:%02x:%02x:%02x:%02x:%02x", |
| (unsigned int *)&staNetwork->bssid[0], |
| (unsigned int *)&staNetwork->bssid[1], |
| (unsigned int *)&staNetwork->bssid[2], |
| (unsigned int *)&staNetwork->bssid[3], |
| (unsigned int *)&staNetwork->bssid[4], |
| (unsigned int *)&staNetwork->bssid[5]); |
| else if (!strcmp(k, "multi_ap_backhaul_sta")) |
| staNetwork->multi_ap = atoi(v); |
| } |
| if((read = getline(&line, &len, fd)) == -1) |
| break; |
| } |
| id++; |
| if(id >= out_array_size) |
| goto close; |
| staNetwork++; |
| } |
| } |
| close: |
| fclose(fd); |
| return RETURN_OK; |
| |
| |
| } |
| |
| INT wifi_setSTANetworks(INT apIndex, wifi_sta_network_t **staNetworks_array, INT array_size, BOOL scan_cur_freq) |
| { |
| FILE *fd = NULL; |
| char fname[100] = {0}; |
| char cmd[128] = {0}; |
| char out[64] = {0}; |
| int ret = 0; |
| char zero[8] = {0}; |
| bool enable_current = FALSE; |
| |
| wifi_sta_network_t *sta = NULL; |
| if(array_size < 0) |
| return RETURN_ERR; |
| char ssid_ifname[128]; |
| |
| ret = wifi_getSTAName(apIndex, ssid_ifname); |
| if (ret != RETURN_OK) |
| return RETURN_ERR; |
| snprintf(fname, sizeof(fname), "/nvram/%s.conf", ssid_ifname); |
| sprintf(cmd, "touch %s && cp %s /nvram/%s.old", fname, fname, ssid_ifname); |
| _syscmd(cmd, out, 64); |
| |
| fd = fopen(fname, "w"); |
| if (!fd) { |
| return RETURN_ERR; |
| } |
| fprintf(fd, "ctrl_interface=%s\n", CTRL_INTERFACE); |
| fprintf(fd, "scan_cur_freq=%d\n", scan_cur_freq ? 1 : 0); |
| |
| sta = *staNetworks_array; |
| for(int i=0; i<array_size; ++i, sta++) { |
| fprintf(fd, "network={\n"); |
| fprintf(fd, "\tscan_ssid=1\n"); |
| fprintf(fd, "\tbgscan=\"\"\n"); |
| fprintf(fd, "\tssid=\"%s\"\n", sta->ssid); |
| if (sta->psk_len > 7 && sta->psk_len < 128) |
| fprintf(fd, "\tpsk=\"%s\"\n", sta->psk); |
| fprintf(fd, "\tkey_mgmt=%s\n", sta->key_mgmt); |
| if (!strncmp(sta->key_mgmt, "SAE", 3) || !strncmp(sta->key_mgmt, "OWE", 3)) { // wpa3-personal must use with ieee80211w |
| fprintf(fd, "\tieee80211w=2\n"); |
| } |
| fprintf(fd, "\tpairwise=%s\n", sta->pairwise); |
| if (memcmp(sta->bssid, zero, sizeof(sta->bssid)) != 0) // Not 00:00:00:00:00:00 means need to specify ap mac address. |
| fprintf(fd, "bssid=%02x:%02x:%02x:%02x:%02x:%02x\n", sta->bssid[0],sta->bssid[1],sta->bssid[2],sta->bssid[3],sta->bssid[4],sta->bssid[5]); |
| fprintf(fd, "}\n"); |
| } |
| fclose(fd); |
| |
| wifi_getSTAEnabled(apIndex, &enable_current); |
| sprintf(cmd, "diff -q /nvram/%s.conf /nvram/%s.old", ssid_ifname, ssid_ifname); |
| if (enable_current && _syscmd(cmd, out, 64)) |
| { |
| sprintf(cmd, "wpa_cli -B -i%s reconfigure", ssid_ifname); |
| _syscmd(cmd, out, 64); |
| } |
| sprintf(cmd, "rm /nvram/%s.old", ssid_ifname); |
| _syscmd(cmd, out, 64); |
| |
| return RETURN_OK; |
| |
| } |
| |
| INT wifi_getSTAEnabled(INT ssidIndex, BOOL *enabled) |
| { |
| char ssid_ifname[128]; |
| char cmd[128] = {0}; |
| char out[64] = {0}; |
| int ret = 0; |
| |
| ret = wifi_getSTAName(ssidIndex, ssid_ifname); |
| if (ret != RETURN_OK) |
| { |
| return RETURN_ERR; |
| } |
| |
| sprintf(cmd, "wpa_cli -g/var/run/wpa_supplicant-global -i global status | grep %s", ssid_ifname); |
| ret = _syscmd(cmd, out, 64); |
| *enabled = ret == 0 ? true : false; |
| |
| return RETURN_OK; |
| } |
| |
| INT wifi_setSTAEnabled(INT ssidIndex, BOOL enable) |
| { |
| char ssid_ifname[128]; |
| char cmd[256] = {0}; |
| char out[64] = {0}; |
| int ret = 0; |
| int radioIndex = 0; |
| |
| BOOL en; |
| wifi_getSTAEnabled(ssidIndex,&en); |
| if (enable == en) |
| return RETURN_OK; |
| |
| ret = wifi_getSTAName(ssidIndex, ssid_ifname); |
| if (ret != RETURN_OK) |
| return RETURN_ERR; |
| |
| if (enable) { |
| snprintf(cmd, sizeof(cmd), "wpa_cli -g/var/run/wpa_supplicant-global interface_add %s /nvram/%s.conf nl80211 /var/run/wpa_supplicant", ssid_ifname, ssid_ifname); |
| ret = _syscmd(cmd, out, 64); |
| } else { |
| snprintf(cmd, sizeof(cmd), "wpa_cli -g/var/run/wpa_supplicant-global -i global interface_remove %s", ssid_ifname); |
| ret = _syscmd(cmd, out, 64); |
| } |
| |
| return ret == 0 ? RETURN_OK : RETURN_ERR; |
| } |
| |
| INT wifi_createSTAInterface(INT ssidIndex, char *bssid, BOOL wds_flag) |
| { |
| char cmd[128] = {0}; |
| char buf[128] = {0}; |
| char ssid_ifname[128] = {0}; |
| int radioIndex = 0; |
| int phyIndex = 0; |
| int ret = 0; |
| |
| ret = wifi_getSTAName(ssidIndex, ssid_ifname); |
| if (ret != RETURN_OK) |
| return RETURN_ERR; |
| |
| wifi_getSTARadioIndex(ssidIndex, &radioIndex); |
| phyIndex = radio_index_to_phy(radioIndex); |
| if (phyIndex == -1) { |
| fprintf(stderr, "%s: Invalid radio index %d.\n", __func__, radioIndex); |
| return RETURN_ERR; |
| } |
| snprintf(cmd, sizeof(cmd), "iw phy phy%d interface add %s type managed %s", phyIndex, ssid_ifname, wds_flag?"4addr on":""); |
| _syscmd(cmd, buf, sizeof(buf)); |
| snprintf(cmd, sizeof(cmd), "ip link set dev %s address %s && ip link set dev %s up", ssid_ifname, bssid, ssid_ifname); |
| _syscmd(cmd, buf, sizeof(buf)); |
| |
| return RETURN_OK; |
| } |