#include <stdio.h>
|
#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 <syslog.h>
|
#include <fcntl.h>
|
#include <stdbool.h>
|
#include <assert.h>
|
#include <paths.h>
|
#include <sys/wait.h>
|
|
#define LOG_TAG "RK_BCM_LOG"
|
#define SYSLOG_DEBUG
|
#define DEBUG 1
|
|
#ifdef SYSLOG_DEBUG
|
#define pr_debug(fmt, ...) syslog(LOG_DEBUG, fmt, ##__VA_ARGS__)
|
#define pr_info(fmt, ...) syslog(LOG_INFO, fmt, ##__VA_ARGS__)
|
#define pr_warning(fmt, ...) syslog(LOG_WARNING, fmt, ##__VA_ARGS__)
|
#define pr_err(fmt, ...) syslog(LOG_ERR, fmt, ##__VA_ARGS__)
|
#else
|
#define pr_debug printf
|
#define pr_info printf
|
#define pr_warning printf
|
#define pr_err printf
|
#endif
|
|
static int system_fd_closexec(const char* command)
|
{
|
int wait_val = 0;
|
pid_t pid = -1;
|
|
if (!command)
|
return 1;
|
|
if ((pid = vfork()) < 0)
|
return -1;
|
|
if (pid == 0) {
|
int i = 0;
|
int stdin_fd = fileno(stdin);
|
int stdout_fd = fileno(stdout);
|
int stderr_fd = fileno(stderr);
|
long sc_open_max = sysconf(_SC_OPEN_MAX);
|
if (sc_open_max < 0) {
|
sc_open_max = 20000; /* enough? */
|
}
|
/* close all descriptors in child sysconf(_SC_OPEN_MAX) */
|
for (i = 0; i < sc_open_max; i++) {
|
if (i == stdin_fd || i == stdout_fd || i == stderr_fd)
|
continue;
|
close(i);
|
}
|
|
execl(_PATH_BSHELL, "sh", "-c", command, (char*)0);
|
_exit(127);
|
}
|
|
while (waitpid(pid, &wait_val, 0) < 0) {
|
if (errno != EINTR) {
|
wait_val = -1;
|
break;
|
}
|
}
|
|
return wait_val;
|
}
|
|
static int rk_command_system(const char *cmd)
|
{
|
pid_t status;
|
|
status = system_fd_closexec(cmd);
|
|
if (-1 == status) {
|
pr_err("[system_exec_err] -1\n");
|
return -1;
|
} else {
|
if (WIFEXITED(status)) {
|
if (0 == WEXITSTATUS(status)) {
|
return 0;
|
} else {
|
pr_err("[system_exec_err] -2\n");
|
return -2;
|
}
|
} else {
|
pr_err("[system_exec_err] -3\n");
|
return -3;
|
}
|
}
|
|
return 0;
|
}
|
|
void rk_command(const char cmdline[], char recv_buff[], int len)
|
{
|
if (DEBUG)
|
pr_info("[BT_DEBUG] execute: %s\n", cmdline);
|
|
FILE *stream = NULL;
|
char *tmp_buff = recv_buff;
|
|
memset(recv_buff, 0, len);
|
|
if ((stream = popen(cmdline, "r")) != NULL) {
|
while (fgets(tmp_buff, len, stream)) {
|
//pr_info("tmp_buf[%d]: %s\n", strlen(tmp_buff), tmp_buff);
|
tmp_buff += strlen(tmp_buff);
|
len -= strlen(tmp_buff);
|
if (len <= 1)
|
break;
|
}
|
|
if (DEBUG)
|
pr_info("[BT_DEBUG] execute_r: %s \n", recv_buff);
|
pclose(stream);
|
} else
|
pr_err("[popen] error: %s\n", cmdline);
|
}
|
|
static int rk_get_pid(const char Name[])
|
{
|
int len;
|
char name[32] = {0};
|
char cmdresult[256] = {0};
|
char cmd[64] = {0};
|
FILE *pFile = NULL;
|
int pid = 0;
|
|
len = strlen(Name);
|
strncpy(name,Name,len);
|
name[31] ='\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;
|
}
|
|
int rk_kill_task(char *name)
|
{
|
char cmd[128] = {0};
|
int exec_cnt = 3, retry_cnt = 10;
|
|
if (!rk_get_pid(name))
|
return 0;
|
|
memset(cmd, 0, 128);
|
sprintf(cmd, "killall %s", name);
|
|
while(exec_cnt) {
|
if(!rk_command_system(cmd))
|
break;
|
exec_cnt--;
|
}
|
|
if(exec_cnt <= 0) {
|
pr_info("%s: kill %s failed\n", __func__, name);
|
return -1;
|
}
|
msleep(100);
|
|
retry:
|
if (rk_get_pid(name) && (retry_cnt--)) {
|
msleep(100);
|
goto retry;
|
}
|
|
pr_info("%s: kill %s, retry_cnt = %d\n", __func__, name, retry_cnt);
|
if (rk_get_pid(name))
|
return -1;
|
else
|
return 0;
|
}
|
|
int rk_run_task(char *name, char *cmd)
|
{
|
int exec_cnt = 3, retry_cnt = 6;
|
|
while(exec_cnt) {
|
if(!rk_command_system(cmd))
|
break;
|
exec_cnt--;
|
}
|
|
if(exec_cnt <= 0) {
|
pr_info("%s: run %s failed\n", __func__, name);
|
return -1;
|
}
|
msleep(100);
|
|
retry:
|
if (!rk_get_pid(name) && (retry_cnt--)) {
|
msleep(100);
|
goto retry;
|
}
|
|
if (!rk_get_pid(name))
|
return -1;
|
else
|
return 0;
|
}
|
|
/****** wpa_supplicant ******/
|
#include <poll.h>
|
#include <wpa_ctrl.h>
|
|
#define EVENT_BUF_SIZE 1024
|
#define PROPERTY_VALUE_MAX 32
|
#define PROPERTY_KEY_MAX 32
|
|
static void wifi_close_sockets();
|
|
static const char WPA_EVENT_IGNORE[] = "CTRL-EVENT-IGNORE ";
|
static const char IFNAME[] = "IFNAME=";
|
static const char IFACE_DIR[] = "/var/run/wpa_supplicant";
|
|
#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[32] = "wlan0";
|
static int dispatch_event(char* event)
|
{
|
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__);
|
rk_command_system("ip addr flush dev wlan0");
|
rk_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__);
|
} else if (str_starts_with(event, (char *)WPA_EVENT_SCAN_RESULTS)) {
|
pr_info("%s: wifi event results\n", __func__);
|
} else if (strstr(event, "reason=WRONG_KEY")) {
|
pr_info("%s: wifi reason=WRONG_KEY \n", __func__);
|
} 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;
|
}
|
|
return 0;
|
}
|
|
static int check_wpa_supplicant_state() {
|
int count = 5;
|
int wpa_supplicant_pid = 0;
|
wpa_supplicant_pid = get_pid("wpa_suppplicant");
|
|
pr_info("%s: wpa_supplicant_pid = %d\n", __FUNCTION__, wpa_supplicant_pid);
|
|
if (wpa_supplicant_pid > 0) {
|
return 1;
|
}
|
|
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;
|
do {
|
res = TEMP_FAILURE_RETRY(poll(rfds, 2, 30000));
|
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;
|
}
|
} while (res == 0);
|
|
if (rfds[0].revents & POLLIN) {
|
return wpa_ctrl_recv(monitor_conn, reply, reply_len);
|
}
|
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;
|
|
prctl(PR_SET_NAME, "rk_wifi_monitor");
|
|
if ((ret = wifi_connect_to_supplicant()) != 0) {
|
pr_info("%s, connect to supplicant fail.\n", __FUNCTION__);
|
return;
|
}
|
|
for (;;) {
|
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;
|
}
|
}
|
}
|
|
/****** wpa_supplicant end ******/
|
|
void rk_wifi_module_init()
|
{
|
rk_command_system("insmod /vendor/lib/modules/bcmdhd_indep_power.ko");
|
}
|
|
void rk_wifi_module_exit()
|
{
|
rk_command_system("rmmod bcmdhd_indep_power");
|
}
|
|
void rk_wifi_disconnect_ap()
|
{
|
rk_command_system("killall wpa_supplicant");
|
}
|
|
int rk_get_dhcp()
|
{
|
char cmd[128], cmd_results[128];
|
int cnt = 60;
|
|
rk_command_system("udhcpc -i wlan0 -t 15 -q");
|
|
retry:
|
rk_command("ifconfig wlan0 | grep inet | awk '{print $2}' | awk -F: '{print $2}' | awk -F. '{print $1}'", cmd_results, 128);
|
if ((cmd_results[0] == 0) && (cmd_results[0] == 127) && (cmd_results[0] == 169)) {
|
sleep(1);
|
if (cnt--)
|
goto retry;
|
|
if (cnt == 0) {
|
pr_err("dhcp fail!!!\n");
|
return -1;
|
}
|
|
}
|
|
return 1;
|
}
|
|
int rk_wifi_get_status(void)
|
{
|
char cmd_results[128];
|
int cnt = 60;
|
|
retry:
|
rk_command("wl status | grep BSSID: | awk '{print $2}'", cmd_results, 128);
|
if ((cmd_results[0] == 0) || (strncmp(cmd_results, "00:00:00:00:00:00", 17))) {
|
sleep(1);
|
if (cnt--)
|
goto retry;
|
|
if (cnt == 0) {
|
pr_err("status: unknow\n");
|
return -1;
|
}
|
}
|
|
pr_err("status: connected!\n");
|
|
return 1;
|
}
|
|
int rk_wifi_get_channel(void)
|
{
|
char cmd_results[128];
|
|
rk_command("wl status | grep Channel | awk '{print $17}'", cmd_results, 128);
|
|
return cmd_results[0];
|
}
|
|
char *rk_wifi_get_wakeup_reason(void)
|
{
|
char cmd_results[128];
|
|
rk_command("dhd_priv wl wowl_wakeind | grep wakeind | awk '{print $4}' | sed -n '2p' | awk -F= '{print $2}'", cmd_results, 128);
|
|
pr_err("wakeup_reason: %s\n", cmd_results);
|
|
return cmd_results;
|
}
|
|
int rk_wifi_get_signal(void)
|
{
|
char cmd_results[128];
|
int signal = 0;
|
|
rk_command("wl status | grep noise | awk '{print $10}'", cmd_results, 128);
|
|
signal = atoi(cmd_results[0]);
|
|
pr_err("signal: %d\n", signal);
|
|
return signal;
|
}
|
|
int rk_wifi_set_net_info(char *ip, char *mask, char *gw, char *dns)
|
{
|
char cmd[128];
|
|
memset(cmd, 0, 128);
|
sprintf(cmd, "ifconfig wlan0 %s netmask %s", ip, mask);
|
rk_command_system(cmd);
|
|
memset(cmd, 0, 128);
|
sprintf(cmd, "route add default gw %s", gw);
|
rk_command_system(cmd);
|
|
memset(cmd, 0, 128);
|
sprintf(cmd, "echo \"nameserver %s\" > /etc/resolv.conf", dns);
|
rk_command_system(cmd);
|
|
return 1;
|
}
|
|
int rk_wifi_set_ssid_for_wakeup(void)
|
{
|
return 1;
|
}
|
|
int rk_wifi_clr_ssid_for_wakeup(void)
|
{
|
return 1;
|
}
|
|
int rk_wifi_start(void)
|
{
|
|
}
|
|
int rk_wifi_restart(void)
|
{
|
|
}
|
|
void rk_wifi_scan(void)
|
{
|
|
}
|
|
int rk_wifi_scan_results(struct wpa_ap_info *pslt, int num)
|
{
|
|
}
|
|
void rk_wifi_connect_ap(char *ssid, char *psk)
|
{
|
char cmd[128], cmd_results[128];
|
int cnt = 60;
|
|
rk_command_system("ifconfig wlan0 down");
|
usleep(500*100);
|
rk_command_system("ifconfig wlan0 up");
|
usleep(500*100);
|
rk_command_system("cp /etc/wpa_supplicant.conf /tmp/ -rf");
|
|
memset(cmd, 0, 128);
|
sprintf(cmd, "sed -i \"s/SSID/%s/g\" /tmp/wpa_supplicant.conf", ssid);
|
rk_command_system(cmd);
|
|
memset(cmd, 0, 128);
|
sprintf(cmd, "sed -i \"s/PASSWORD/%s/g\" /tmp/wpa_supplicant.conf", psk);
|
rk_command_system(cmd);
|
|
if (rk_get_pid("wpa_supplicant") > 0)
|
rk_kill_task("wpa_supplicant");
|
|
if (rk_run_task("wpa_supplicant", "wpa_supplicant -B -i wlan0 -c /tmp/wpa_supplicant.conf")) {
|
pr_err("wpa_supplicant start fail!!!\n");
|
return;
|
}
|
|
sleep(1);
|
|
rk_wifi_get_status();
|
rk_get_dhcp();
|
}
|
|
void rk_wifi_set_tcp_port(int port)
|
{
|
|
}
|
|
static char wowl_pattern[256];
|
void rk_wifi_set_tcp_wakeup_data(int offset, int num, char *data)
|
{
|
int mask;
|
|
for (int i = 0; i < num; i++)
|
mask |= (0x1 < i);
|
|
memset(wowl_pattern, 0, 256);
|
|
sprintf(wowl_pattern, "wl_cy wowl_pattern add %d 0x%x %s", offset, mask, data);
|
}
|
|
void rk_wifi_suspend(void)
|
{
|
int fd, size;
|
char buf[200];
|
|
fd = open("/proc/tcp_params", O_RDONLY);
|
|
memset(buf, 0, 200);
|
lseek(fd, 0, SEEK_SET);
|
size = read(fd, buf, 200);
|
|
rk_command_system("wl_cy tcpka_conn_mode 1");
|
usleep(200*200);
|
pr_info("buf: %s\n", buf);
|
rk_command_system(buf);
|
usleep(200*200);
|
rk_command_system("wl_cy tcpka_conn_enable 1 1 30 1 8");
|
usleep(200*200);
|
rk_command_system("wl_cy wowl 131094");
|
usleep(200*200);
|
//printf("wl_cy wowl_pattern add 54 0x07 0x313233\n");
|
//rk_command_system("wl_cy wowl_pattern add 54 0x07 0x313233");
|
//usleep(200*200);
|
//printf("wl_cy wowl_pattern add 66 0x07 0x313233\n");
|
//rk_command_system("wl_cy wowl_pattern add 66 0x07 0x313233");
|
pr_info("wowl_pattern: %s\n");
|
rk_command_system(wowl_pattern);
|
usleep(200*200);
|
rk_command_system("wl_cy wowl_activate 1");
|
usleep(200*200);
|
rk_command_system("wl_cy PM 2");
|
usleep(200*200);
|
rk_command_system("wl_cy hostsleep 1");
|
usleep(200*200);
|
rk_command_system("killall wpa_supplicant");
|
}
|
