int wifi_send_command(struct wpa_ctrl *ctrl, const char *cmd, char *reply, size_t *reply_len)
{
int ret;
if (ctrl_conn == NULL) {
LOGV("Not connected to wpa_supplicant - \"%s\" command dropped.\n", cmd);
return -1;
}
if (strcmp(cmd, "DRIVER START") == 0) {
LOGD("wifi.c : load driver after resume\n");
wifi_load_driver();
}
ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), reply, reply_len, NULL);
LOGV("wifi.c : cmd=%s, reply=%s\n", cmd, reply);
if (strcmp(cmd, "DRIVER STOP") == 0) {
LOGD("wifi.c : unload driver before suspend\n");
wifi_unload_driver();
}
if (ret == -2) {
LOGD("'%s' command timed out.\n", cmd);
/* unblocks the monitor receive socket for termination */
write(exit_sockets[0], "T", 1);
return -2;
} else if (ret < 0 || strncmp(reply, "FAIL", 4) == 0) {
return -1;
}
if (strncmp(cmd, "PING", 4) == 0) {
reply[*reply_len] = '\0';
}
return 0;
}
int wifi_change_fw_path(const char *fwpath)
{
int len;
int fd;
int ret = 0;
static char previous_fwpath[4];
// if (!fwpath)
// return ret;
LOGE("%s: %s\n", __FUNCTION__, fwpath);
if(strncmp("P2P", fwpath, 3) == 0) {
ret = wifi_load_driver();
} else if(strncmp("P2P", previous_fwpath, 3) == 0) {
ret = wifi_unload_driver();
}
strncpy(previous_fwpath, fwpath, 3);
#if 0
fd = open(WIFI_DRIVER_FW_PATH_PARAM, O_WRONLY);
if (fd < 0) {
LOGE("Failed to open wlan fw path param (%s)", strerror(errno));
return -1;
}
len = strlen(fwpath) + 1;
if (write(fd, fwpath, len) != len) {
LOGE("Failed to write wlan fw path param (%s)", strerror(errno));
ret = -1;
}
close(fd);
#endif
return ret;
}
char* LoadWifiFn(const char* name, State* state, int argc, Expr* argv[]) {
if (argc != 0)
return ErrorAbort(state, "%s() expects 0 arg, got %d", name, argc);
if (wifi_load_driver() != 0) {
return ErrorAbort(state, "Unable to load wifi-driver: %s", strerror(errno));
}
return strdup("t");
}
int wifi_load_hotspot_driver()
{
#ifndef WIFI_AP_DRIVER_MODULE_PATH
return wifi_load_driver();
#else
char driver_status[PROPERTY_VALUE_MAX];
int count = 100; /* wait at most 20 seconds for completion */
char module_arg[PROPERTY_VALUE_MAX];
if (is_wifi_hotspot_driver_loaded()) {
property_set(AP_DRIVER_PROP_NAME, "ok");
return 0;
}
property_set(AP_DRIVER_PROP_NAME, "loading");
#ifdef WIFI_EXT_MODULE_PATH
if (insmod(EXT_MODULE_PATH, EXT_MODULE_ARG) < 0)
return -1;
usleep(200000);
#endif
property_get(AP_DRIVER_PROP_MODULE_ARG, module_arg, AP_DRIVER_MODULE_ARG);
if (insmod(AP_DRIVER_MODULE_PATH, module_arg) < 0) {
#ifdef WIFI_EXT_MODULE_NAME
rmmod(EXT_MODULE_NAME);
#endif
return -1;
}
if (strcmp(AP_FIRMWARE_LOADER,"") == 0) {
/* usleep(WIFI_DRIVER_LOADER_DELAY); */
property_set(AP_DRIVER_PROP_NAME, "ok");
}
else {
property_set("ctl.start", AP_FIRMWARE_LOADER);
}
sched_yield();
while (count-- > 0) {
if (property_get(AP_DRIVER_PROP_NAME, driver_status, NULL)) {
if (strcmp(driver_status, "ok") == 0)
return 0;
else if (strcmp(AP_DRIVER_PROP_NAME, "failed") == 0) {
wifi_unload_hotspot_driver();
return -1;
}
}
usleep(200000);
}
property_set(AP_DRIVER_PROP_NAME, "timeout");
wifi_unload_hotspot_driver();
return -1;
#endif
}
int enable_wifi()
{
int ret = 0;
wifi_state = ENABLING;
ALOGD("load wlan driver...");
wifi_load_driver();
ALOGD("start supplicant...");
if(wifi_start_supplicant(1) != 0)
{
ALOGE("start supplicant failed!");
ret = -1;
goto error_exit;
}
int count = 100;
struct stat buf;
while((count-->0) && (stat("/dev/socket/wpa_wlan0",&buf)!=0)) usleep(100);
if(count==0)
{
ALOGE("WPA Supplicant not initialized, not wait and exit.");
ret = -1;
goto error_exit;
}
ALOGD("connect supplicant wlan0...");
if(wifi_connect_to_supplicant("wlan0") != 0)
{
ALOGE("connect supplicant wlan0 failed!");
ret = -2;
goto error_exit;
}
ALOGD("connect supplicant p2p0...");
if(wifi_connect_to_supplicant("p2p0") != 0)
{
ALOGE("connect supplicant p2p0 failed!");
ret = -3;
goto error_exit;
}
wifi_state = ENABLED;
WIFI_MSG_INFO_CALLBACK("Wifi enabled.");
start_autoManager();
return 0;
error_exit:
WIFI_MSG_ERR_CALLBACK("Wifi enable fail.");
wifi_state = DISABLED;
return ret;
}
char* LoadWifiFn(const char* name, State* state, int argc, Expr* argv[]) {
if (argc != 0)
return ErrorAbort(state, "%s() expects 0 arg, got %d", name, argc);
void *h = dlopen("/system/lib/libhardware_legacy.so",RTLD_LAZY);
int (*wifi_load_driver)() = dlsym(h,"wifi_load_driver");
if (wifi_load_driver) {
if (wifi_load_driver() != 0) {
return ErrorAbort(state, "Unable to load wifi-driver: %s", strerror(errno));
}
return strdup("t");
}
return ErrorAbort(state, "libhardware_legacy is not available.");
}
/*
* Arguments:
* argv[2] - interface name
* argv[3] - AP or STA
*/
int SoftapController::fwReloadSoftap(int argc, char *argv[])
{
int ret, i = 0;
char *iface;
char *fwpath;
if (mSock < 0) {
LOGE("Softap fwrealod - failed to open socket");
return -1;
}
if (argc < 4) {
LOGE("Softap fwreload - missing arguments");
return -1;
}
iface = argv[2];
if (strcmp(argv[3], "AP") == 0) {
fwpath = (char *)wifi_get_fw_path(WIFI_GET_FW_PATH_AP);
} else if (strcmp(argv[3], "P2P") == 0) {
fwpath = (char *)wifi_get_fw_path(WIFI_GET_FW_PATH_P2P);
} else {
fwpath = (char *)wifi_get_fw_path(WIFI_GET_FW_PATH_STA);
}
if (!fwpath)
return -1;
#ifdef HAVE_HOSTAPD
if(strcmp(argv[3],"AP") == 0)
wifi_unload_driver();
ret = wifi_change_fw_path((const char *)fwpath);
if(strcmp(argv[3],"AP") == 0)
wifi_load_driver();
#else
sprintf(mBuf, "FW_PATH=%s", fwpath);
ret = setCommand(iface, "WL_FW_RELOAD");
#endif
if (ret) {
LOGE("Softap fwReload - failed: %d", ret);
}
else {
LOGD("Softap fwReload - Ok");
}
return ret;
}
int wifi_check_is_dongle_in()
{
struct device_node * ptmp = NULL;
if(driver_is_load)
{
LOGD("wifi_set_dongle_inside dongle already in");
return 0;
}
ptmp = phead;
while(ptmp != NULL)
{
cur_module = wifi_trans_pid_to_module(ptmp->device_id);
if (cur_module >= 0)
{
wifi_set_envir_vali(cur_module);
pcurr_device = ptmp;
return wifi_load_driver();
}
ptmp = ptmp->pnext;
}
return -1;
}
/*
* Main
*
* Performs the following high-level sequence of operations:
*
* 1. Command-line parsing
*
* 2. Initialization
*
* 3. Execute passes that repeatedly perform the WiFi load, scan,
* associate, unload sequence.
*
* 4. Restore state of WiFi driver to state it was at the
* start of the test.
*
* 5. Restart framework
*/
int
main(int argc, char *argv[])
{
FILE *fp;
int rv, opt;
int cpu;
char *chptr;
unsigned int pass;
char cmd[MAXCMD];
float duration = DEFAULT_DURATION;
unsigned int startPass = DEFAULT_START_PASS, endPass = DEFAULT_END_PASS;
struct timeval startTime, currentTime, delta;
testSetLogCatTag(LOG_TAG);
// Parse command line arguments
while ((opt = getopt(argc, argv, "d:D:s:e:p:t:?")) != -1) {
switch (opt) {
case 'd': // Minimum Delay
delayMin = strtod(optarg, &chptr);
if ((*chptr != '\0') || (delayMin < 0.0)) {
testPrintE("Invalid command-line specified minimum delay "
"of: %s", optarg);
exit(1);
}
break;
case 'D': // Maximum Delay
delayMax = strtod(optarg, &chptr);
if ((*chptr != '\0') || (delayMax < 0.0)) {
testPrintE("Invalid command-line specified maximum delay "
"of: %s", optarg);
exit(2);
}
break;
case 't': // Duration
duration = strtod(optarg, &chptr);
if ((*chptr != '\0') || (duration < 0.0)) {
testPrintE("Invalid command-line specified duration of: %s",
optarg);
exit(3);
}
break;
case 's': // Starting Pass
if (sFlag || pFlag) {
testPrintE("Invalid combination of command-line options,");
if (sFlag) {
testPrintE(" -s flag specified multiple times.");
} else {
testPrintE(" -s and -p flags are mutually exclusive.");
}
exit(10);
}
sFlag = true;
startPass = strtoul(optarg, &chptr, 10);
if (*chptr != '\0') {
testPrintE("Invalid command-line specified starting pass "
"of: %s", optarg);
exit(4);
}
break;
case 'e': // Ending Pass
if (eFlag || pFlag) {
testPrintE("Invalid combination of command-line options,");
if (sFlag) {
testPrintE(" -e flag specified multiple times.");
} else {
testPrintE(" -e and -p flags are mutually exclusive.");
}
exit(11);
}
eFlag = true;
endPass = strtoul(optarg, &chptr, 10);
if (*chptr != '\0') {
testPrintE("Invalid command-line specified ending pass "
"of: %s", optarg);
exit(5);
}
break;
case 'p': // Single Specific Pass
if (pFlag || sFlag || eFlag) {
testPrintE("Invalid combination of command-line options,");
if (pFlag) {
testPrintE(" -p flag specified multiple times.");
} else {
testPrintE(" -p and -%c flags are mutually exclusive.",
(sFlag) ? 's' : 'e');
}
exit(12);
}
pFlag = true;
endPass = startPass = strtoul(optarg, &chptr, 10);
if (*chptr != '\0') {
testPrintE("Invalid command-line specified pass "
"of: %s", optarg);
exit(13);
}
break;
case '?':
default:
testPrintE(" %s [options]", basename(argv[0]));
testPrintE(" options:");
testPrintE(" -s Starting pass");
testPrintE(" -e Ending pass");
testPrintE(" -p Specific single pass");
testPrintE(" -t Duration");
testPrintE(" -d Delay min");
testPrintE(" -D Delay max");
exit(((optopt == 0) || (optopt == '?')) ? 0 : 6);
}
}
if (delayMax < delayMin) {
testPrintE("Unexpected maximum delay less than minimum delay");
testPrintE(" delayMin: %f delayMax: %f", delayMin, delayMax);
exit(7);
}
if (endPass < startPass) {
testPrintE("Unexpected ending pass before starting pass");
testPrintE(" startPass: %u endPass: %u", startPass, endPass);
exit(8);
}
if (argc != optind) {
testPrintE("Unexpected command-line postional argument");
testPrintE(" %s [-s start_pass] [-e end_pass] [-d duration]",
basename(argv[0]));
exit(9);
}
testPrintI("duration: %g", duration);
testPrintI("startPass: %u", startPass);
testPrintI("endPass: %u", endPass);
testPrintI("delayMin: %f", delayMin);
testPrintI("delayMax: %f", delayMax);
init();
// For each pass
gettimeofday(&startTime, NULL);
for (pass = startPass; pass <= endPass; pass++) {
// Stop if duration of work has already been performed
gettimeofday(¤tTime, NULL);
delta = tvDelta(&startTime, ¤tTime);
if (tv2double(&delta) > duration) { break; }
testPrintI("==== Starting pass: %u", pass);
// Use a pass dependent sequence of random numbers
srand48(pass);
// Load WiFi Driver
randBind(&availCPU, &cpu);
if ((rv = wifi_load_driver()) != 0) {
testPrintE("CPU: %i wifi_load_driver() failed, rv: %i\n",
cpu, rv);
exit(20);
}
testPrintI("CPU: %i wifi_load_driver succeeded", cpu);
// Start Supplicant
randBind(&availCPU, &cpu);
if ((rv = wifi_start_supplicant(false)) != 0) {
testPrintE("CPU: %i wifi_start_supplicant() failed, rv: %i\n",
cpu, rv);
exit(21);
}
testPrintI("CPU: %i wifi_start_supplicant succeeded", cpu);
// Sleep a random amount of time
randDelay();
/*
* Obtain WiFi Status
* Half the time skip this step, which helps increase the
* level of randomization.
*/
if (testRandBool()) {
rv = snprintf(cmd, sizeof(cmd), "%s", CMD_STATUS);
if (rv >= (signed) sizeof(cmd) - 1) {
testPrintE("Command too long for: %s\n", CMD_STATUS);
exit(22);
}
testExecCmd(cmd);
}
// Stop Supplicant
randBind(&availCPU, &cpu);
if ((rv = wifi_stop_supplicant(false)) != 0) {
testPrintE("CPU: %i wifi_stop_supplicant() failed, rv: %i\n",
cpu, rv);
exit(23);
}
testPrintI("CPU: %i wifi_stop_supplicant succeeded", cpu);
// Unload WiFi Module
randBind(&availCPU, &cpu);
if ((rv = wifi_unload_driver()) != 0) {
testPrintE("CPU: %i wifi_unload_driver() failed, rv: %i\n",
cpu, rv);
exit(24);
}
testPrintI("CPU: %i wifi_unload_driver succeeded", cpu);
testPrintI("==== Completed pass: %u", pass);
}
// If needed restore WiFi driver to state it was in at the
// start of the test. It is assumed that it the driver
// was loaded, then the wpa_supplicant was also running.
if (driverLoadedAtStart) {
// Load driver
if ((rv = wifi_load_driver()) != 0) {
testPrintE("main load driver failed, rv: %i", rv);
exit(25);
}
// Start supplicant
if ((rv = wifi_start_supplicant(false)) != 0) {
testPrintE("main start supplicant failed, rv: %i", rv);
exit(26);
}
// Obtain WiFi Status
rv = snprintf(cmd, sizeof(cmd), "%s", CMD_STATUS);
if (rv >= (signed) sizeof(cmd) - 1) {
testPrintE("Command too long for: %s\n", CMD_STATUS);
exit(22);
}
testExecCmd(cmd);
}
// Start framework
rv = snprintf(cmd, sizeof(cmd), "%s", CMD_START_FRAMEWORK);
if (rv >= (signed) sizeof(cmd) - 1) {
testPrintE("Command too long for: %s\n", CMD_START_FRAMEWORK);
exit(27);
}
testExecCmd(cmd);
testPrintI("Successfully completed %u passes", pass - startPass);
return 0;
}
wifi_error wifi_initialize(wifi_handle *handle)
{
int err = 0;
bool driver_loaded = false;
wifi_error ret = WIFI_SUCCESS;
wifi_interface_handle iface_handle;
srand(getpid());
ALOGI("Initializing wifi");
hal_info *info = (hal_info *)malloc(sizeof(hal_info));
if (info == NULL) {
ALOGE("Could not allocate hal_info");
return WIFI_ERROR_UNKNOWN;
}
memset(info, 0, sizeof(*info));
ALOGI("Creating socket");
struct nl_sock *cmd_sock = wifi_create_nl_socket(WIFI_HAL_CMD_SOCK_PORT);
if (cmd_sock == NULL) {
ALOGE("Could not create handle");
return WIFI_ERROR_UNKNOWN;
}
struct nl_sock *event_sock =
wifi_create_nl_socket(WIFI_HAL_EVENT_SOCK_PORT);
if (event_sock == NULL) {
ALOGE("Could not create handle");
nl_socket_free(cmd_sock);
return WIFI_ERROR_UNKNOWN;
}
struct nl_cb *cb = nl_socket_get_cb(event_sock);
if (cb == NULL) {
ALOGE("Could not create handle");
return WIFI_ERROR_UNKNOWN;
}
err = 1;
nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);
nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);
nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err);
nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err);
nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, internal_valid_message_handler,
info);
nl_cb_put(cb);
info->cmd_sock = cmd_sock;
info->event_sock = event_sock;
info->clean_up = false;
info->in_event_loop = false;
info->event_cb = (cb_info *)malloc(sizeof(cb_info) * DEFAULT_EVENT_CB_SIZE);
info->alloc_event_cb = DEFAULT_EVENT_CB_SIZE;
info->num_event_cb = 0;
info->cmd = (cmd_info *)malloc(sizeof(cmd_info) * DEFAULT_CMD_SIZE);
info->alloc_cmd = DEFAULT_CMD_SIZE;
info->num_cmd = 0;
info->nl80211_family_id = genl_ctrl_resolve(cmd_sock, "nl80211");
if (info->nl80211_family_id < 0) {
ALOGE("Could not resolve nl80211 familty id");
nl_socket_free(cmd_sock);
nl_socket_free(event_sock);
free(info);
return WIFI_ERROR_UNKNOWN;
}
ALOGI("%s: family_id:%d", __func__, info->nl80211_family_id);
*handle = (wifi_handle) info;
wifi_add_membership(*handle, "scan");
wifi_add_membership(*handle, "mlme");
wifi_add_membership(*handle, "regulatory");
wifi_add_membership(*handle, "vendor");
if (!is_wifi_driver_loaded()) {
ret = (wifi_error)wifi_load_driver();
if(ret != WIFI_SUCCESS) {
ALOGE("%s Failed to load driver : %d\n", __func__, ret);
return WIFI_ERROR_UNKNOWN;
}
driver_loaded = true;
}
ret = wifi_init_interfaces(*handle);
if (ret != WIFI_SUCCESS) {
ALOGI("Failed to init interfaces");
goto unload;
}
if (info->num_interfaces == 0) {
ALOGI("No interfaces found");
ret = WIFI_ERROR_UNINITIALIZED;
goto unload;
}
iface_handle = wifi_get_iface_handle((info->interfaces[0])->handle,
(info->interfaces[0])->name);
if (iface_handle == NULL) {
int i;
for (i = 0; i < info->num_interfaces; i++)
{
free(info->interfaces[i]);
}
ALOGE("%s no iface with %s\n", __func__, info->interfaces[0]->name);
return WIFI_ERROR_UNKNOWN;
}
ret = acquire_supported_features(iface_handle,
&info->supported_feature_set);
if (ret != WIFI_SUCCESS) {
ALOGI("Failed to get supported feature set : %d", ret);
//acquire_supported_features failure is acceptable condition as legacy
//drivers might not support the required vendor command. So, do not
//consider it as failure of wifi_initialize
ret = WIFI_SUCCESS;
}
ALOGI("Initialized Wifi HAL Successfully; vendor cmd = %d Supported"
" features : %x", NL80211_CMD_VENDOR, info->supported_feature_set);
unload:
if (driver_loaded)
wifi_unload_driver();
return ret;
}
