Merge changes 1093,1094 into donut (90290568) · Commits · e / os / android_system_core

nexus/Android.mk

0 → 100644

+47 −0

Original line number	Diff line number	Diff line
		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)

nexus/CommandListener.cpp

0 → 100644

+124 −0

Original line number	Diff line number	Diff line
		/*
		* 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;
		}

nexus/CommandListener.h

0 → 100644

+70 −0

Original line number	Diff line number	Diff line
		/*
		* 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

nexus/Controller.cpp

0 → 100644

+144 −0

Original line number	Diff line number	Diff line
		/*
		* 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;
		}

nexus/Controller.h

0 → 100644

+47 −0

Original line number	Diff line number	Diff line
		/*
		* 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