nexus: Initial checkin of Nexus - android native network management daemon.

BUILD_NEXUS := false

ifeq ($(BUILD_NEXUS),true)

LOCAL_PATH:= $(call my-dir)

include $(CLEAR_VARS)

LOCAL_SRC_FILES:=                          \

                  main.cpp                 \

                  NetworkManager.cpp       \

                  CommandListener.cpp      \

                  Controller.cpp           \

                  WifiController.cpp       \

                  LoopController.cpp       \

                  NexusCommand.cpp         \

                  TiwlanWifiController.cpp \

                  Supplicant.cpp           \

                  SupplicantEvent.cpp      \

                  SupplicantListener.cpp   \

                  VpnController.cpp        \

                  ScanResult.cpp           \

LOCAL_MODULE:= nexus

LOCAL_C_INCLUDES := $(KERNEL_HEADERS)

LOCAL_CFLAGS := 

LOCAL_SHARED_LIBRARIES := libsysutils libwpa_client libutils

include $(BUILD_EXECUTABLE)

include $(CLEAR_VARS)

LOCAL_SRC_FILES:=          \

                  nexctl.c \

LOCAL_MODULE:= nexctl

LOCAL_C_INCLUDES := $(KERNEL_HEADERS)

LOCAL_CFLAGS := 

LOCAL_SHARED_LIBRARIES := libutils

include $(BUILD_EXECUTABLE)

endif # ifeq ($(BUILD_NEXUS),true)

/*

 * Copyright (C) 2008 The Android Open Source Project

 *

 * 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 <stdlib.h>

#include <errno.h>

#define LOG_TAG "CommandListener"

#include <cutils/log.h>

#include "CommandListener.h"

#include "Controller.h"

#include "NetworkManager.h"

#include "WifiController.h"

CommandListener::CommandListener(NetworkManager *netman) :

                 FrameworkListener("nexus") {

    mNetman = netman;

    registerCmd(new WifiEnableCmd(netman));

    registerCmd(new WifiDisableCmd(netman));

    registerCmd(new WifiScanCmd(netman));

    registerCmd(new VpnEnableCmd(netman));

    registerCmd(new VpnDisableCmd(netman));

}

/* -------------

 * Wifi Commands

 * ------------ */

CommandListener::WifiEnableCmd::WifiEnableCmd(NetworkManager *netman) :

                 NexusCommand("wifi_enable", netman) {

} 

int CommandListener::WifiEnableCmd::runCommand(char *data) {

    Controller *c = mNetman->findController("WIFI");

    char buffer[32];

    sprintf(buffer, "WIFI_ENABLE:%d", (c->enable() ? errno : 0));

    mNetman->getFrameworkManager()->sendMsg(buffer);

    return 0;

}

CommandListener::WifiDisableCmd::WifiDisableCmd(NetworkManager *netman) :

                 NexusCommand("wifi_disable", netman) {

} 

int CommandListener::WifiDisableCmd::runCommand(char *data) {

    Controller *c = mNetman->findController("WIFI");

    char buffer[32];

    sprintf(buffer, "WIFI_DISABLE:%d", (c->disable() ? errno : 0));

    mNetman->getFrameworkManager()->sendMsg(buffer);

    return 0;

}

CommandListener::WifiScanCmd::WifiScanCmd(NetworkManager *netman) :

                 NexusCommand("wifi_scan", netman) {

} 

int CommandListener::WifiScanCmd::runCommand(char *data) {

    LOGD("WifiScanCmd(%s)", data);

    WifiController *wc = (WifiController *) mNetman->findController("WIFI");

    char buffer[32];

    int mode = 0;

    char *bword, *last;

    if (!(bword = strtok_r(data, ":", &last))) {

        errno = EINVAL;

        return -1;

    }

    if (!(bword = strtok_r(NULL, ":", &last))) {

        errno = EINVAL;

        return -1;

    }

    mode = atoi(bword);

    sprintf(buffer, "WIFI_SCAN:%d", (wc->setScanMode(mode) ? errno : 0));

    mNetman->getFrameworkManager()->sendMsg(buffer);

    return 0;

}

/* ------------

 * Vpn Commands

 * ------------ */

CommandListener::VpnEnableCmd::VpnEnableCmd(NetworkManager *netman) :

                 NexusCommand("vpn_enable", netman) {

} 

int CommandListener::VpnEnableCmd::runCommand(char *data) {

    Controller *c = mNetman->findController("VPN");

    char buffer[32];

    sprintf(buffer, "VPN_ENABLE:%d", (c->enable() ? errno : 0));

    mNetman->getFrameworkManager()->sendMsg(buffer);

    return 0;

}

CommandListener::VpnDisableCmd::VpnDisableCmd(NetworkManager *netman) :

                 NexusCommand("vpn_disable", netman) {

} 

int CommandListener::VpnDisableCmd::runCommand(char *data) {

    Controller *c = mNetman->findController("VPN");

    char buffer[32];

    sprintf(buffer, "VPN_DISABLE:%d", (c->disable() ? errno : 0));

    mNetman->getFrameworkManager()->sendMsg(buffer);

    return 0;

}

/*

 * Copyright (C) 2008 The Android Open Source Project

 *

 * 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.

 */

#ifndef _COMMANDLISTENER_H__

#define _COMMANDLISTENER_H__

#include <sysutils/FrameworkListener.h>

#include "NexusCommand.h"

class NetworkManager;

class CommandListener : public FrameworkListener {

protected:

    NetworkManager *mNetman;

public:

    CommandListener(NetworkManager *netman);

    virtual ~CommandListener() {}

private:

    class WifiEnableCmd : public NexusCommand {

    public:

        WifiEnableCmd(NetworkManager *);

        virtual ~WifiEnableCmd() {}

        int runCommand(char *data);

    };

    class WifiDisableCmd : public NexusCommand {

    public:

        WifiDisableCmd(NetworkManager *);

        virtual ~WifiDisableCmd() {}

        int runCommand(char *data);

    };

    class WifiScanCmd : public NexusCommand {

    public:

        WifiScanCmd(NetworkManager *);

        virtual ~WifiScanCmd() {}

        int runCommand(char *data);

    };

    class VpnEnableCmd : public NexusCommand {

    public:

        VpnEnableCmd(NetworkManager *);

        virtual ~VpnEnableCmd() {}

        int runCommand(char *data);

    };

    class VpnDisableCmd : public NexusCommand {

    public:

        VpnDisableCmd(NetworkManager *);

        virtual ~VpnDisableCmd() {}

        int runCommand(char *data);

    };

};

#endif

/*

 * Copyright (C) 2008 The Android Open Source Project

 *

 * 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 <string.h>

#include <fcntl.h>

#include <unistd.h>

#include <malloc.h>

#include <errno.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#define LOG_TAG "Controller"

#include <cutils/log.h>

#include "Controller.h"

extern "C" int init_module(void *, unsigned int, const char *);

extern "C" int delete_module(const char *, unsigned int);

Controller::Controller(const char *name) {

    mName = name;

}

int Controller::start() {

    return 0;

}

int Controller::stop() {

    return 0;

}

int Controller::loadKernelModule(char *modpath, const char *args) {

    void *module;

    unsigned int size;

    LOGD("loadKernelModule(%s, %s)", modpath, args);

    module = loadFile(modpath, &size);

    if (!module) {

        errno = -EIO;

        return -1;

    }

    int rc = init_module(module, size, args);

    free (module);

    return rc;

}

int Controller::unloadKernelModule(const char *modtag) {

    int rc = -1;

    int retries = 10;

    LOGD("unloadKernelModule(%s)", modtag);

    while (retries--) {

        rc = delete_module(modtag, O_NONBLOCK | O_EXCL);

        if (rc < 0 && errno == EAGAIN)

            usleep(1000*500);

        else

            break;

    }

    if (rc != 0) {

        LOGW("Unable to unload kernel driver '%s' (%s)", modtag, 

             strerror(errno));

    }

    return rc;

}

bool Controller::isKernelModuleLoaded(const char *modtag) {

    FILE *fp = fopen("/proc/modules", "r");

    if (!fp) {

        LOGE("Unable to open /proc/modules (%s)", strerror(errno));

        return false;

    }

    char line[255];

    while(fgets(line, sizeof(line), fp)) {

        char *endTag = strchr(line, ' ');

        if (!endTag) {

            LOGW("Unable to find tag for line '%s'", line);

            continue;

        }

        if (!strncmp(line, modtag, (endTag - line))) {

            fclose(fp);

            return true;

        }

    }

    fclose(fp);

    return false;

}

void *Controller::loadFile(char *filename, unsigned int *_size)

{

	int ret, fd;

	struct stat sb;

	ssize_t size;

	void *buffer = NULL;

	/* open the file */

	fd = open(filename, O_RDONLY);

	if (fd < 0)

		return NULL;

	/* find out how big it is */

	if (fstat(fd, &sb) < 0)

		goto bail;

	size = sb.st_size;

	/* allocate memory for it to be read into */

	buffer = malloc(size);

	if (!buffer)

		goto bail;

	/* slurp it into our buffer */

	ret = read(fd, buffer, size);

	if (ret != size)

		goto bail;

	/* let the caller know how big it is */

	*_size = size;

bail:

	close(fd);

	return buffer;

}

/*

 * Copyright (C) 2008 The Android Open Source Project

 *

 * 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.

 */

#ifndef _CONTROLLER_H

#define _CONTROLLER_H

#include "../../../frameworks/base/include/utils/List.h"

class Controller {

private:

    const char *mName;

public:

    Controller(const char *name);

    virtual ~Controller() {}

    virtual int start();

    virtual int stop();

    virtual int enable() = 0;

    virtual int disable() = 0;

    virtual const char *getName() { return mName; }

protected:

    int loadKernelModule(char *modpath, const char *args);

    bool isKernelModuleLoaded(const char *modtag);

    int unloadKernelModule(const char *modtag);

private:

    void *loadFile(char *filename, unsigned int *_size);

};

typedef android::List<Controller *> ControllerCollection;

#endif