tequilaOS/platform_system_qcom
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
platform_system_qcom/softap/sdk/qsap.c
Purushottam Kushwaha a49496aea8 qsap: Remove support for wifi_fst from QSAP APIs 
wifi_fst.h is no longer part of /hardware/libhardware_legacy/ ,
therefore, compilation of libqsap_sdk would fail. Remove dependencies
for wifi_fst from QSAP.

Additionally, skip calling 'chown' after changing configuration
parameters as QSAP is not changing ownership.

CRs-Fixed: 2069881
Change-Id: Iaadfa182270f22555e486dac24a5acafc247b943
2017-07-13 12:12:08 +05:30

697 lines
18 KiB
C
Raw Blame History

/*
* Copyright (c) 2010-2013, The Linux Foundation. All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of The Linux Foundation, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <sys/socket.h>
#include <linux/if.h>
#include <linux/wireless.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define LOG_TAG "QCLDR-"
#include "cutils/log.h"
#include "cutils/memory.h"
#include "cutils/misc.h"
#include "cutils/properties.h"
#include "private/android_filesystem_config.h"
#include "qsap_api.h"
#include "qsap.h"
#include <sys/system_properties.h>
#ifndef WIFI_DRIVER_MODULE_PATH
#define WIFI_DRIVER_MODULE_PATH "/system/lib/modules/wlan.ko"
#endif
#ifndef WIFI_DRIVER_MODULE_NAME
#define WIFI_DRIVER_MODULE_NAME "wlan"
#endif
#ifdef WIFI_DRIVER_MODULE_ARG
#undef WIFI_DRIVER_MODULE_ARG
#endif
#define WIFI_DRIVER_MODULE_ARG ""
/* WIFI_SDIO_IF_DRIVER_MODULE_NAME must be defined if sdioif driver required */
#ifdef WIFI_SDIO_IF_DRIVER_MODULE_NAME
#ifndef WIFI_SDIO_IF_DRIVER_MODULE_PATH
#define WIFI_SDIO_IF_DRIVER_MODULE_PATH "/system/lib/modules/librasdioif.ko"
#endif
#ifndef WIFI_SDIO_IF_DRIVER_MODULE_ARG
#define WIFI_SDIO_IF_DRIVER_MODULE_ARG ""
#endif
#endif
#ifndef WIFI_CFG80211_DRIVER_MODULE_PATH
#define WIFI_CFG80211_DRIVER_MODULE_PATH ""
#endif
#ifndef WIFI_CFG80211_DRIVER_MODULE_NAME
#define WIFI_CFG80211_DRIVER_MODULE_NAME ""
#endif
#ifndef WIFI_CFG80211_DRIVER_MODULE_ARG
#define WIFI_CFG80211_DRIVER_MODULE_ARG ""
#endif
extern int init_module(const char *name, u32, const s8 *);
extern int delete_module(const char *name, int);
extern struct Command qsap_str[];
static s32 check_driver_loaded( const s8 * tag)
{
FILE *proc;
s8 line[126];
if ((proc = fopen("/proc/modules", "r")) == NULL) {
ALOGW("Could not open %s: %s", "/proc/modules", strerror(errno));
return 0;
}
while ((fgets(line, sizeof(line), proc)) != NULL) {
if (strncmp(line, tag, strlen(tag)) == 0) {
fclose(proc);
return 1;
}
}
fclose(proc);
return 0;
}
static s32 insmod(const s8 *filename, const s8 *args, const s8 * tag)
{
#ifndef SDK_TEST
void *module;
s32 size;
s32 ret = 0;
if ( check_driver_loaded(tag) ) {
ALOGE("Driver: %s already loaded\n", filename);
return ret;
}
ALOGD("Loading Driver: %s %s\n", filename, args);
module = (void*)load_file(filename, (unsigned int*)&size);
if (!module) {
ALOGE("Cannot load file: %s\n", filename);
return -1;
}
ret = init_module(module, size, args);
if ( ret ) {
ALOGE("init_module (%s:%d) failed\n", filename, (int)size);
}
free(module);
return ret;
#else
return 0;
#endif
}
static s32 rmmod(const s8 *modname)
{
#ifndef SDK_TEST
s32 ret = 0;
s32 maxtry = 10;
while (maxtry-- > 0) {
ret = delete_module(modname, O_NONBLOCK | O_EXCL);
if (ret < 0 && errno == EAGAIN){
usleep(50000);
} else {
break;
}
}
if (ret != 0) {
ALOGD("Unable to unload driver module \"%s\": %s\n",
modname, strerror(errno));
}
return ret;
#else
return 0;
#endif
}
static const s8 SDIO_POLLING_ON[] = "/etc/init.qcom.sdio.sh 1";
static const s8 SDIO_POLLING_OFF[] = "/etc/init.qcom.sdio.sh 0";
static const char DRIVER_CFG80211_MODULE_NAME[] = WIFI_CFG80211_DRIVER_MODULE_NAME;
static const char DRIVER_CFG80211_MODULE_PATH[] = WIFI_CFG80211_DRIVER_MODULE_PATH;
static const char DRIVER_CFG80211_MODULE_ARG[] = WIFI_CFG80211_DRIVER_MODULE_ARG;
s32 wifi_qsap_load_driver(void)
{
s32 size;
s32 ret = -1;
s32 retry;
if (system(SDIO_POLLING_ON)) {
// ALOGE("Could not turn on the polling...");
}
if ('\0' != *DRIVER_CFG80211_MODULE_PATH) {
if (insmod(DRIVER_CFG80211_MODULE_PATH, DRIVER_CFG80211_MODULE_ARG,DRIVER_CFG80211_MODULE_NAME) < 0) {
ALOGE("Could not load cfg80211...");
return ret;
}
}
#ifdef WIFI_SDIO_IF_DRIVER_MODULE_NAME
ret = insmod(WIFI_SDIO_IF_DRIVER_MODULE_PATH, WIFI_SDIO_IF_DRIVER_MODULE_ARG, WIFI_SDIO_IF_DRIVER_MODULE_NAME " ");
if ( ret != 0 ) {
ALOGE("init_module failed sdioif\n");
ret = eERR_LOAD_FAILED_SDIOIF;
goto end;
}
sched_yield();
#endif
ret = insmod(WIFI_DRIVER_MODULE_PATH, WIFI_DRIVER_MODULE_ARG, WIFI_DRIVER_MODULE_NAME " ");
if ( ret != 0 ) {
#ifdef WIFI_SDIO_IF_DRIVER_MODULE_NAME
if ( check_driver_loaded(WIFI_SDIO_IF_DRIVER_MODULE_NAME " ") ) {
if ( rmmod(WIFI_SDIO_IF_DRIVER_MODULE_NAME) ) {
ALOGE("Unable to unload the station mode librasdioif driver\n");
}
}
#endif
if ('\0' != *DRIVER_CFG80211_MODULE_NAME) {
rmmod(DRIVER_CFG80211_MODULE_NAME);
}
ALOGE("init_module failed libra_softap\n");
ret = eERR_LOAD_FAILED_SOFTAP;
goto end;
}
sched_yield();
ret = eSUCCESS;
end:
if(system(SDIO_POLLING_OFF)) {
// ALOGE("Could not turn off the polling...");
}
return ret;
}
void qsap_send_module_down_indication(void)
{
int s, ret;
struct iwreq wrq;
/*
* If the driver is loaded, ask it to broadcast a netlink message
* that it will be closing, so listeners can close their sockets.
*
*/
/* Equivalent to: iwpriv wlan0 sendModuleInd */
if ((s = socket(PF_INET, SOCK_DGRAM, 0)) >= 0) {
strlcpy(wrq.ifr_name, "wlan0", IFNAMSIZ);
wrq.u.data.length = 0; /* No Set arguments */
wrq.u.mode = 5; /* WE_MODULE_DOWN_IND sub-command */
ret = ioctl(s, (SIOCIWFIRSTPRIV + 1), &wrq);
if (ret < 0 ) {
strlcpy(wrq.ifr_name, "softap.0", IFNAMSIZ);
ret = ioctl(s, (SIOCIWFIRSTPRIV + 1), &wrq);
if (ret < 0 ) {
ALOGE("ioctl failed: %s", strerror(errno));
}
}
close(s);
sched_yield();
}
else {
ALOGE("Socket open failed: %s", strerror(errno));
}
}
s32 qsap_send_init_ap(void)
{
int s, ret;
struct iwreq wrq;
s32 status = eSUCCESS;
u32 *params = (u32 *)&wrq.u;
/* Equivalent to: iwpriv wlan0 initAP */
if ((s = socket(AF_INET, SOCK_DGRAM, 0)) >= 0) {
strlcpy(wrq.ifr_name, "wlan0", IFNAMSIZ);
wrq.u.data.length = 0; /* No Set arguments */
wrq.u.data.flags = 2; /* WE_INIT_AP sub-command */
ret = ioctl(s, (SIOCIWFIRSTPRIV + 6), &wrq);
if (ret < 0 ) {
ALOGE("ioctl failed: %s", strerror(errno));
status = eERR_START_SAP;
}
close(s);
sched_yield();
}
else {
ALOGE("Socket open failed: %s", strerror(errno));
status = eERR_START_SAP;
}
return status;
}
s32 qsap_send_exit_ap(void)
{
int s, ret;
struct iwreq wrq;
s32 status = eSUCCESS;
u32 *params = (u32 *)&wrq.u;
/* Equivalent to: iwpriv wlan0 exitAP */
if ((s = socket(AF_INET, SOCK_DGRAM, 0)) >= 0) {
strlcpy(wrq.ifr_name, "wlan0", IFNAMSIZ);
wrq.u.data.length = 0; /* No Set arguments */
wrq.u.data.flags = 3; /*WE_EXIT_AP sub-command */
ret = ioctl(s, (SIOCIWFIRSTPRIV + 6), &wrq);
if (ret < 0 ) {
ALOGE("ioctl failed: %s", strerror(errno));
status = eERR_STOP_SAP;
}
close(s);
sched_yield();
}
else {
ALOGE("Socket open failed: %s", strerror(errno));
status = eERR_STOP_SAP;
}
return status;
}
s32 wifi_qsap_unload_driver()
{
s32 ret = eSUCCESS;
if(system(SDIO_POLLING_ON)) {
ALOGE("Could not turn on the polling...");
}
if ( check_driver_loaded(WIFI_DRIVER_MODULE_NAME " ") ) {
qsap_send_module_down_indication();
if ( rmmod(WIFI_DRIVER_MODULE_NAME) ) {
ALOGE("Unable to unload the libra_softap driver\n");
ret = eERR_UNLOAD_FAILED_SOFTAP;
goto end;
}
}
sched_yield();
#ifdef WIFI_SDIO_IF_DRIVER_MODULE_NAME
if ( check_driver_loaded(WIFI_SDIO_IF_DRIVER_MODULE_NAME " ") ) {
if ( rmmod(WIFI_SDIO_IF_DRIVER_MODULE_NAME) ) {
ALOGE("Unable to unload the librasdioif driver\n");
ret = eERR_UNLOAD_FAILED_SDIO;
goto end;
}
}
#endif
end:
if(system(SDIO_POLLING_OFF)) {
ALOGE("Could not turn off the polling...");
}
return ret;
}
s32 wifi_qsap_stop_bss(void)
{
#define QCIEEE80211_IOCTL_STOPBSS (SIOCIWFIRSTPRIV + 6)
s32 sock;
s32 ret = eERR_STOP_BSS;
s8 cmd[] = "stopbss";
s8 interface[128];
s8 *iface;
s32 len = 128;
struct iwreq wrq;
struct iw_priv_args *priv_ptr;
if(ENABLE != is_softap_enabled()) {
ret = eERR_BSS_NOT_STARTED;
return ret;
}
if(NULL == (iface = qsap_get_config_value(CONFIG_FILE, &qsap_str[STR_INTERFACE], interface, (u32*)&len))) {
ALOGE("%s :interface error \n", __func__);
return ret;
}
/* Issue the stopbss command to driver */
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0) {
ALOGE("Failed to open socket");
return eERR_STOP_BSS;
}
strlcpy(wrq.ifr_name, iface, sizeof(wrq.ifr_name));
wrq.u.data.length = sizeof(cmd);
wrq.u.data.pointer = cmd;
wrq.u.data.flags = 0;
ret = ioctl(sock, QCIEEE80211_IOCTL_STOPBSS, &wrq);
/* Here IOCTL is always returning non Zero: temporary fix untill driver is fixed*/
ret = 0;
close(sock);
if (ret) {
ALOGE("IOCTL stopbss failed: %ld", ret);
ret = eERR_STOP_BSS;
} else {
ALOGD("STOP BSS ISSUED");
ret = eSUCCESS;
}
sched_yield();
return ret;
}
s32 is_softap_enabled(void)
{
s32 mode = 0;
int ret;
ret = qsap_get_mode(&mode);
if (eSUCCESS != ret) {
ALOGD("Failed to get the mode of operation\n");
return eERR_UNKNOWN;
}
if (mode == IW_MODE_MASTER) {
ALOGD("HOSTAPD Enabled\n");
return ENABLE;
}
ALOGD("HOSTAPD Disabled\n");
return DISABLE;
}
s32 commit(void)
{
#ifndef SDK_TEST
s32 ret = eERR_COMMIT;
if ( is_softap_enabled() ) {
/** Stop BSS */
if(eSUCCESS != (ret = wifi_qsap_stop_bss())) {
ALOGE("%s: stop bss failed \n", __func__);
return ret;
}
sleep(1);
}
ret = wifi_qsap_start_softap();
if( eSUCCESS != ret )
wifi_qsap_unload_driver();
return ret;
#else
return eSUCCESS;
#endif
}
s32 wifi_qsap_start_softap()
{
s32 retry = 4;
FILE * fp;
ALOGD("Starting Soft AP...\n");
/* Check if configuration files are present, if not create the default files */
check_for_configuration_files();
/* Delete control interface if it was left over because of previous crash */
if ( !is_softap_enabled() ) {
qsap_del_ctrl_iface();
}
/* Ensure correct path for ini file name */
qsap_set_ini_filename();
while(retry--) {
/* May be the configuration file is corrupted or not available, */
/* copy the default configuration file */
if ( retry == 1 )
wifi_qsap_reset_to_default(CONFIG_FILE, DEFAULT_CONFIG_FILE_PATH);
/** Stop hostapd */
if(0 != property_set("ctl.start", "hostapd")) {
ALOGE("failed \n");
continue;
}
sleep(1);
if ( is_softap_enabled() ) {
ALOGD("success \n");
return eSUCCESS;
}
}
ALOGE("Unable to start the SoftAP\n");
return eERR_START_SAP;
}
#ifdef QCOM_WLAN_CONCURRENCY
s32 wifi_qsap_start_softap_in_concurrency()
{
s32 status;
/*Send initAP IOCTL to Driver. Hostapd start is done by Netd.*/
status = qsap_send_init_ap();
return status;
}
s32 wifi_qsap_stop_softap_in_concurrency()
{
s32 status;
/*Send exitAP IOCTL to Driver. Hostapd stop is done by Netd.*/
status = qsap_send_exit_ap();
return status;
}
#endif
s32 wifi_qsap_stop_softap()
{
s32 ret = eSUCCESS;
if ( is_softap_enabled() ) {
ALOGD("Stopping BSS ..... ");
/** Stop the BSS */
if (eSUCCESS != (ret = wifi_qsap_stop_bss()) ) {
ALOGE("failed \n");
return ret;
}
sleep(1);
}
return ret;
}
s32 wifi_qsap_reload_softap()
{
s32 ret = eERR_RELOAD_SAP;
/** SDK API to reload the firmware */
if (eSUCCESS != (ret = wifi_qsap_stop_softap())) {
return ret;
}
if (eSUCCESS != (ret = wifi_qsap_unload_driver())) {
return ret;
}
usleep(500000);
if (eSUCCESS != (ret = wifi_qsap_load_driver())) {
return ret;
}
sleep(1);
if (eSUCCESS != (ret = wifi_qsap_start_softap())) {
wifi_qsap_unload_driver();
return ret;
}
return eSUCCESS;
}
static pid_t wigigSoftApPid = 0;
static const char WIGIG_ENTROPY_FILE[] = "/data/misc/wifi/wigig_entropy.bin";
static unsigned char dummy_key[21] = { 0x02, 0x11, 0xbe, 0x33, 0x43, 0x35,
0x68, 0x47, 0x84, 0x99, 0xa9, 0x2b,
0x1c, 0xd3, 0xee, 0xff, 0xf1, 0xe2,
0xf3, 0xf4, 0xf5 };
static const char HOSTAPD_BIN_FILE[] = "/system/bin/hostapd";
static const char WIGIG_HOSTAPD_CONF_FILE[] = "/data/misc/wifi/wigig_hostapd.conf";
#define AP_BSS_START_DELAY 200000
#define AP_BSS_STOP_DELAY 500000
int wigig_ensure_entropy_file_exists()
{
int ret;
int destfd;
ret = access(WIGIG_ENTROPY_FILE, R_OK|W_OK);
if ((ret == 0) || (errno == EACCES)) {
if ((ret != 0) &&
(chmod(WIGIG_ENTROPY_FILE, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP) != 0)) {
ALOGE("Cannot set RW to \"%s\": %s", WIGIG_ENTROPY_FILE, strerror(errno));
return -1;
}
return 0;
}
destfd = TEMP_FAILURE_RETRY(open(WIGIG_ENTROPY_FILE, O_CREAT|O_RDWR, 0660));
if (destfd < 0) {
ALOGE("Cannot create \"%s\": %s", WIGIG_ENTROPY_FILE, strerror(errno));
return -1;
}
if (TEMP_FAILURE_RETRY(write(destfd, dummy_key, sizeof(dummy_key))) != sizeof(dummy_key)) {
ALOGE("Error writing \"%s\": %s", WIGIG_ENTROPY_FILE, strerror(errno));
close(destfd);
return -1;
}
close(destfd);
/* chmod is needed because open() didn't set permisions properly */
if (chmod(WIGIG_ENTROPY_FILE, 0660) < 0) {
ALOGE("Error changing permissions of %s to 0660: %s",
WIGIG_ENTROPY_FILE, strerror(errno));
unlink(WIGIG_ENTROPY_FILE);
return -1;
}
if (chown(WIGIG_ENTROPY_FILE, AID_SYSTEM, AID_WIFI) < 0) {
ALOGE("Error changing group ownership of %s to %d: %s",
WIGIG_ENTROPY_FILE, AID_WIFI, strerror(errno));
unlink(WIGIG_ENTROPY_FILE);
return -1;
}
return 0;
}
s32 wifi_qsap_start_wigig_softap(void)
{
pid_t pid = 1;
ALOGD("%s", __func__);
if (wigigSoftApPid) {
ALOGE("Wigig SoftAP is already running");
return eERR_START_SAP;
}
if (wigig_ensure_entropy_file_exists() < 0) {
ALOGE("Wigig entropy file was not created");
}
if ((pid = fork()) < 0) {
ALOGE("fork failed (%s)", strerror(errno));
return eERR_START_SAP;
}
if (!pid) {
if (execl(HOSTAPD_BIN_FILE, HOSTAPD_BIN_FILE,
"-e", WIGIG_ENTROPY_FILE, "-dd",
WIGIG_HOSTAPD_CONF_FILE, (char *) NULL)) {
ALOGE("execl failed (%s)", strerror(errno));
}
ALOGE("Wigig SoftAP failed to start. Exiting child process...");
exit(-1);
}
wigigSoftApPid = pid;
ALOGD("Wigig SoftAP started successfully");
usleep(AP_BSS_START_DELAY);
return eSUCCESS;
}
s32 wifi_qsap_stop_wigig_softap(void)
{
ALOGD("%s", __func__);
if (wigigSoftApPid == 0) {
ALOGE("Wigig SoftAP is not running");
return eSUCCESS;
}
ALOGD("Stopping the Wigig SoftAP...");
kill(wigigSoftApPid, SIGTERM);
waitpid(wigigSoftApPid, NULL, 0);
wigigSoftApPid = 0;
ALOGD("Wigig SoftAP stopped successfully");
usleep(AP_BSS_STOP_DELAY);
return eSUCCESS;
}
Reference in a new issue View git blame Copy permalink