haiku.git

/*
 * Copyright 2006-2019, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Axel Dörfler, axeld@pinc-software.de
 * 		Vegard Wærp, vegarwa@online.no
 *		Alexander von Gluck, kallisti5@unixzen.com
 */


#include "NetServer.h"

#include <errno.h>
#include <map>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <strings.h>
#include <syslog.h>
#include <unistd.h>

#include <arpa/inet.h>
#include <net/if_dl.h>
#include <net/if_types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/sockio.h>

#include <Alert.h>
#include <Deskbar.h>
#include <Directory.h>
#include <Entry.h>
#include <NetworkDevice.h>
#include <NetworkInterface.h>
#include <NetworkRoster.h>
#include <NetworkSettings.h>
#include <Path.h>
#include <PathMonitor.h>
#include <Roster.h>
#include <Server.h>
#include <TextView.h>
#include <FindDirectory.h>

#include <AutoDeleter.h>
#include <WPASupplicant.h>

#include "AutoconfigLooper.h"
#include "Services.h"

extern "C" {
#	include <freebsd_network/compat/sys/cdefs.h>
#	include <freebsd_network/compat/sys/ioccom.h>
#	include <net80211/ieee80211_ioctl.h>
}


using namespace BNetworkKit;


typedef std::map<std::string, AutoconfigLooper*> LooperMap;


class NetServer : public BServer {
public:
								NetServer(status_t& status);
	virtual						~NetServer();

	virtual	void				ReadyToRun();
	virtual	void				MessageReceived(BMessage* message);

private:
			bool				_IsValidFamily(uint32 family);
			bool				_IsValidInterface(BNetworkInterface& interface);
			void				_RemoveInvalidInterfaces();
			status_t			_RemoveInterface(const char* name);
			status_t			_DisableInterface(const char* name);
			bool				_TestForInterface(const char* name);
			status_t			_ConfigureInterface(BMessage& interface);
			status_t			_ConfigureResolver(
									BMessage& resolverConfiguration);
			bool				_QuitLooperForDevice(const char* device);
			AutoconfigLooper*	_LooperForDevice(const char* device);
			status_t			_ConfigureDevice(const char* path);
			void				_ConfigureDevices(const char* path,
									BStringList& devicesAlreadyConfigured,
									BMessage* suggestedInterface = NULL);
			void				_ConfigureInterfacesFromSettings(
									BStringList& devicesSet,
									BMessage* _missingDevice = NULL);
			void				_ConfigureIPv6LinkLocal(const char* name);

			void				_BringUpInterfaces();
			void				_StartServices();
			status_t			_HandleDeviceMonitor(BMessage* message);

			status_t			_AutoJoinNetwork(const BMessage& message);
			status_t			_JoinNetwork(const BMessage& message,
									const BNetworkAddress* address = NULL,
									const char* name = NULL);
			status_t			_LeaveNetwork(const BMessage& message);

			status_t			_ConvertNetworkToSettings(BMessage& message);
			status_t			_ConvertNetworkFromSettings(BMessage& message);

private:
			BNetworkSettings	fSettings;
			LooperMap			fDeviceMap;
			BMessenger			fServices;
};


// #pragma mark - private functions


static status_t
set_80211(const char* name, int32 type, void* data,
	int32 length = 0, int32 value = 0)
{
	FileDescriptorCloser socket(::socket(AF_INET, SOCK_DGRAM, 0));
	if (!socket.IsSet())
		return errno;

	struct ieee80211req ireq;
	strlcpy(ireq.i_name, name, IF_NAMESIZE);
	ireq.i_type = type;
	ireq.i_val = value;
	ireq.i_len = length;
	ireq.i_data = data;

	if (ioctl(socket.Get(), SIOCS80211, &ireq, sizeof(struct ieee80211req))
		< 0)
		return errno;

	return B_OK;
}


//	#pragma mark -


NetServer::NetServer(status_t& error)
	:
	BServer(kNetServerSignature, false, &error)
{
}


NetServer::~NetServer()
{
	BPrivate::BPathMonitor::StopWatching("/dev/net", this);
}


void
NetServer::ReadyToRun()
{
	fSettings.StartMonitoring(this);
	_BringUpInterfaces();
	_StartServices();

	BPrivate::BPathMonitor::StartWatching("/dev/net",
		B_WATCH_FILES_ONLY | B_WATCH_RECURSIVELY, this);
}


void
NetServer::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case B_PATH_MONITOR:
		{
			fSettings.Update(message);
			_HandleDeviceMonitor(message);
			break;
		}

		case BNetworkSettings::kMsgInterfaceSettingsUpdated:
		{
			BStringList devicesSet;
			_ConfigureInterfacesFromSettings(devicesSet);
			break;
		}

		case BNetworkSettings::kMsgServiceSettingsUpdated:
		{
			BMessage update = fSettings.Services();
			update.what = kMsgUpdateServices;

			fServices.SendMessage(&update);
			break;
		}

		case kMsgConfigureInterface:
		{
			status_t status = _ConfigureInterface(*message);

			BMessage reply(B_REPLY);
			reply.AddInt32("status", status);
			message->SendReply(&reply);
			break;
		}

		case kMsgConfigureResolver:
		{
			status_t status = _ConfigureResolver(*message);

			BMessage reply(B_REPLY);
			reply.AddInt32("status", status);
			message->SendReply(&reply);
			break;
		}

		case kMsgJoinNetwork:
		{
			status_t status = _JoinNetwork(*message);

			BMessage reply(B_REPLY);
			reply.AddInt32("status", status);
			message->SendReply(&reply);
			break;
		}

		case kMsgLeaveNetwork:
		{
			status_t status = _LeaveNetwork(*message);

			BMessage reply(B_REPLY);
			reply.AddInt32("status", status);
			message->SendReply(&reply);
			break;
		}

		case kMsgAutoJoinNetwork:
		{
			_AutoJoinNetwork(*message);
			break;
		}

		case kMsgCountPersistentNetworks:
		{
			BMessage reply(B_REPLY);
			reply.AddInt32("count", fSettings.CountNetworks());
			message->SendReply(&reply);
			break;
		}

		case kMsgGetPersistentNetwork:
		{
			uint32 index = 0;
			status_t result = message->FindInt32("index", (int32*)&index);

			BMessage reply(B_REPLY);
			if (result == B_OK) {
				BMessage network;
				result = fSettings.GetNextNetwork(index, network);
				if (result == B_OK)
					result = reply.AddMessage("network", &network);
			}

			reply.AddInt32("status", result);
			message->SendReply(&reply);
			break;
		}

		case kMsgAddPersistentNetwork:
		{
			BMessage network = *message;
			status_t result = fSettings.AddNetwork(network);

			BMessage reply(B_REPLY);
			reply.AddInt32("status", result);
			message->SendReply(&reply);
			break;
		}

		case kMsgRemovePersistentNetwork:
		{
			const char* networkName = NULL;
			status_t result = message->FindString("name", &networkName);
			if (result == B_OK)
				result = fSettings.RemoveNetwork(networkName);

			BMessage reply(B_REPLY);
			reply.AddInt32("status", result);
			message->SendReply(&reply);
			break;
		}

		case kMsgIsServiceRunning:
		{
			// Forward the message to the handler that can answer it
			BHandler* handler = fServices.Target(NULL);
			if (handler != NULL)
				handler->MessageReceived(message);
			break;
		}

		default:
			BApplication::MessageReceived(message);
			return;
	}
}


/*!	Checks if provided address family is valid.
	Families include AF_INET, AF_INET6, AF_APPLETALK, etc
*/
bool
NetServer::_IsValidFamily(uint32 family)
{
	// Mostly verifies add-on is present
	int socket = ::socket(family, SOCK_DGRAM, 0);
	if (socket < 0)
		return false;

	close(socket);
	return true;
}


/*!	Checks if an interface is valid, that is, if it has an address in any
	family, and, in case of ethernet, a hardware MAC address.
*/
bool
NetServer::_IsValidInterface(BNetworkInterface& interface)
{
	// check if it has an address

	if (interface.CountAddresses() == 0)
		return false;

	// check if it has a hardware address, too, in case of ethernet

	BNetworkAddress link;
	if (interface.GetHardwareAddress(link) != B_OK)
		return false;

	if (link.LinkLevelType() == IFT_ETHER && link.LinkLevelAddressLength() != 6)
		return false;

	return true;
}


void
NetServer::_RemoveInvalidInterfaces()
{
	BNetworkRoster& roster = BNetworkRoster::Default();
	BNetworkInterface interface;
	uint32 cookie = 0;

	while (roster.GetNextInterface(&cookie, interface) == B_OK) {
		if (!_IsValidInterface(interface)) {
			// remove invalid interface
			_RemoveInterface(interface.Name());
		}
	}
}


bool
NetServer::_TestForInterface(const char* name)
{

	BNetworkRoster& roster = BNetworkRoster::Default();
	int32 nameLength = strlen(name);
	BNetworkInterface interface;
	uint32 cookie = 0;

	while (roster.GetNextInterface(&cookie, interface) == B_OK) {
		if (!strncmp(interface.Name(), name, nameLength))
			return true;
	}

	return false;
}


status_t
NetServer::_RemoveInterface(const char* name)
{
	BNetworkRoster& roster = BNetworkRoster::Default();
	status_t status = roster.RemoveInterface(name);
	if (status != B_OK) {
		fprintf(stderr, "%s: Could not delete interface %s: %s\n",
			Name(), name, strerror(status));
		return status;
	}

	return B_OK;
}


status_t
NetServer::_DisableInterface(const char* name)
{
	BNetworkInterface interface(name);
	int32 flags = interface.Flags();

	// Set interface down
	flags &= ~(IFF_UP | IFF_AUTO_CONFIGURED | IFF_CONFIGURING);

	status_t status = interface.SetFlags(flags);
	if (status != B_OK) {
		fprintf(stderr, "%s: Setting flags failed: %s\n", Name(),
			strerror(status));
		return status;
	}

	fprintf(stderr, "%s: set %s interface down...\n", Name(), name);
	return B_OK;
}


status_t
NetServer::_ConfigureInterface(BMessage& message)
{
	const char* name;
	if (message.FindString("device", &name) != B_OK)
		return B_BAD_VALUE;

	bool startAutoConfig = false;

	int32 flags;
	if (message.FindInt32("flags", &flags) != B_OK)
		flags = IFF_UP;

	bool autoConfigured = false;
	if (message.FindBool("auto_configured", &autoConfigured) == B_OK
			&& autoConfigured) {
		flags |= IFF_AUTO_CONFIGURED;
	} else {
		_QuitLooperForDevice(name);
	}

	int32 mtu;
	if (message.FindInt32("mtu", &mtu) != B_OK)
		mtu = -1;

	int32 metric;
	if (message.FindInt32("metric", &metric) != B_OK)
		metric = -1;

	BNetworkInterface interface(name);
	if (!interface.Exists()) {
		// the interface does not exist yet, we have to add it first
		BNetworkRoster& roster = BNetworkRoster::Default();

		status_t status = roster.AddInterface(interface);
		if (status != B_OK) {
			fprintf(stderr, "%s: Could not add interface: %s\n",
				interface.Name(), strerror(status));
			return status;
		}
	}

	// Set up IPv6 Link Local address (based on MAC, if not loopback)

	// TODO: our IPv6 stack is still fairly fragile. We need more v6 work
	// (including IPv6 address scope flags before we start attaching link
	// local addresses by default.
	//_ConfigureIPv6LinkLocal(name);

	BMessage addressMessage;
	for (int32 index = 0; message.FindMessage("address", index,
			&addressMessage) == B_OK; index++) {
		BNetworkInterfaceAddressSettings addressSettings(addressMessage);

		if (addressSettings.IsAutoConfigure())
			startAutoConfig = true;

		// set address/mask/broadcast/peer

		if (!addressSettings.Address().IsEmpty()
			|| !addressSettings.Mask().IsEmpty()
			|| !addressSettings.Broadcast().IsEmpty()
			|| !addressSettings.Peer().IsEmpty()
			|| !addressSettings.IsAutoConfigure()) {
			BNetworkInterfaceAddress interfaceAddress;
			interfaceAddress.SetAddress(addressSettings.Address());
			interfaceAddress.SetMask(addressSettings.Mask());
			if (!addressSettings.Broadcast().IsEmpty())
				interfaceAddress.SetBroadcast(addressSettings.Broadcast());
			else if (!addressSettings.Peer().IsEmpty())
				interfaceAddress.SetDestination(addressSettings.Peer());

			status_t status = interface.SetAddress(interfaceAddress);
			if (status != B_OK) {
				fprintf(stderr, "%s: Setting address failed: %s\n", Name(),
					strerror(status));
				return status;
			}
		}

		// set gateway

		if (!addressSettings.Gateway().IsEmpty()) {
			// add gateway route, if we're asked for it
			interface.RemoveDefaultRoute(addressSettings.Family());
				// Try to remove a previous default route, doesn't matter
				// if it fails.

			status_t status = interface.AddDefaultRoute(
				addressSettings.Gateway());
			if (status != B_OK) {
				fprintf(stderr, "%s: Could not add route for %s: %s\n",
					Name(), name, strerror(errno));
			}
		}

		// set flags

		if (flags != 0) {
			int32 newFlags = interface.Flags();
			newFlags = (newFlags & ~IFF_CONFIGURING) | flags;
			if (!autoConfigured)
				newFlags &= ~IFF_AUTO_CONFIGURED;

			status_t status = interface.SetFlags(newFlags);
			if (status != B_OK) {
				fprintf(stderr, "%s: Setting flags failed: %s\n", Name(),
					strerror(status));
			}
		}

		// set options

		if (mtu != -1) {
			status_t status = interface.SetMTU(mtu);
			if (status != B_OK) {
				fprintf(stderr, "%s: Setting MTU failed: %s\n", Name(),
					strerror(status));
			}
		}

		if (metric != -1) {
			status_t status = interface.SetMetric(metric);
			if (status != B_OK) {
				fprintf(stderr, "%s: Setting metric failed: %s\n", Name(),
					strerror(status));
			}
		}
	}

	// Join the specified networks
	BMessage networkMessage;
	for (int32 index = 0; message.FindMessage("network", index,
			&networkMessage) == B_OK; index++) {
		const char* networkName = message.GetString("name", NULL);
		const char* addressString = message.GetString("mac", NULL);

		BNetworkAddress address;
		status_t addressStatus = address.SetTo(AF_LINK, addressString);

		BNetworkDevice device(name);
		if (device.IsWireless() && !device.HasLink()) {
			status_t status = _JoinNetwork(message,
				addressStatus == B_OK ? &address : NULL, networkName);
			if (status != B_OK) {
				fprintf(stderr, "%s: joining network \"%s\" failed: %s\n",
					interface.Name(), networkName, strerror(status));
			}
		}
	}

	if (startAutoConfig) {
		// start auto configuration
		AutoconfigLooper* looper = new AutoconfigLooper(this, name);
		looper->Run();

		fDeviceMap[name] = looper;
	}

	return B_OK;
}


status_t
NetServer::_ConfigureResolver(BMessage& resolverConfiguration)
{
	// Store resolver settings in resolv.conf file, while maintaining any
	// user specified settings already present.

	BPath path;
	if (find_directory(B_SYSTEM_SETTINGS_DIRECTORY, &path) != B_OK
		|| path.Append("network/resolv.conf") != B_OK)
		return B_ERROR;

	FILE* file = fopen(path.Path(), "r+");
	// open existing resolv.conf if possible
	if (file == NULL) {
		// no existing resolv.conf, create a new one
		file = fopen(path.Path(), "w");
		if (file == NULL) {
			fprintf(stderr, "Could not open resolv.conf: %s\n",
				strerror(errno));
			return errno;
		}
	} else {
		// An existing resolv.conf was found, parse it for user settings
		const char* staticDNS = "# Static DNS Only";
		size_t sizeStaticDNS = strlen(staticDNS);
		const char* dynamicDNS = "# Dynamic DNS entries";
		size_t sizeDynamicDNS = strlen(dynamicDNS);
		char resolveConfBuffer[80];
		size_t sizeResolveConfBuffer = sizeof(resolveConfBuffer);

		while (fgets(resolveConfBuffer, sizeResolveConfBuffer, file)) {
			if (strncmp(resolveConfBuffer, staticDNS, sizeStaticDNS) == 0) {
				// If DNS is set to static only, don't modify
				fclose(file);
				return B_OK;
			} else if (strncmp(resolveConfBuffer, dynamicDNS, sizeDynamicDNS)
					== 0) {
				// Overwrite existing dynamic entries
				break;
			}
		}

		if (feof(file) != 0) {
			// No static entries found, close and re-open as new file
			fclose(file);
			file = fopen(path.Path(), "w");
			if (file == NULL) {
				fprintf(stderr, "Could not open resolv.conf: %s\n",
					strerror(errno));
				return errno;
			}
		}
	}

	fprintf(file, "# Added automatically by DHCP\n");

	const char* nameserver;
	for (int32 i = 0; resolverConfiguration.FindString("nameserver", i,
			&nameserver) == B_OK; i++) {
		fprintf(file, "nameserver %s\n", nameserver);
	}

	const char* domain;
	if (resolverConfiguration.FindString("domain", &domain) == B_OK)
		fprintf(file, "domain %s\n", domain);

	fprintf(file, "# End of automatic DHCP additions\n");

	fclose(file);

	return B_OK;
}


bool
NetServer::_QuitLooperForDevice(const char* device)
{
	LooperMap::iterator iterator = fDeviceMap.find(device);
	if (iterator == fDeviceMap.end())
		return false;

	// there is a looper for this device - quit it
	if (iterator->second->Lock())
		iterator->second->Quit();

	fDeviceMap.erase(iterator);
	return true;
}


AutoconfigLooper*
NetServer::_LooperForDevice(const char* device)
{
	LooperMap::const_iterator iterator = fDeviceMap.find(device);
	if (iterator == fDeviceMap.end())
		return NULL;

	return iterator->second;
}


status_t
NetServer::_ConfigureDevice(const char* device)
{
	// bring interface up, but don't configure it just yet
	BMessage interface;
	interface.AddString("device", device);
	BMessage address;
	address.AddString("family", "inet");
	address.AddBool("auto_config", true);
	interface.AddMessage("address", &address);

	return _ConfigureInterface(interface);
}


/*! \brief Traverses the device tree starting from \a startPath, and configures
		everything that has not yet been configured via settings before.

	\param suggestedInterface Contains the configuration of an interface that
		does not have any hardware left. It is used to configure the first
		unconfigured device. This allows to move a Haiku configuration around
		without losing the network configuration.
*/
void
NetServer::_ConfigureDevices(const char* startPath,
	BStringList& devicesAlreadyConfigured, BMessage* suggestedInterface)
{
	BDirectory directory(startPath);
	BEntry entry;
	while (directory.GetNextEntry(&entry) == B_OK) {
		char name[B_FILE_NAME_LENGTH];
		struct stat stat;
		BPath path;
		if (entry.GetName(name) != B_OK
			|| entry.GetPath(&path) != B_OK
			|| entry.GetStat(&stat) != B_OK
			|| devicesAlreadyConfigured.HasString(path.Path()))
			continue;

		if (S_ISBLK(stat.st_mode) || S_ISCHR(stat.st_mode)) {
			if (suggestedInterface != NULL
				&& suggestedInterface->SetString("device", path.Path()) == B_OK
				&& _ConfigureInterface(*suggestedInterface) == B_OK)
				suggestedInterface = NULL;
			else
				_ConfigureDevice(path.Path());
		} else if (entry.IsDirectory()) {
			_ConfigureDevices(path.Path(), devicesAlreadyConfigured,
				suggestedInterface);
		}
	}
}


void
NetServer::_ConfigureInterfacesFromSettings(BStringList& devicesSet,
	BMessage* _missingDevice)
{
	BMessage interface;
	uint32 cookie = 0;
	bool missing = false;
	while (fSettings.GetNextInterface(cookie, interface) == B_OK) {
		const char *device;
		if (interface.FindString("device", &device) != B_OK)
			continue;

		bool disabled = false;
		if (interface.FindBool("disabled", &disabled) == B_OK && disabled) {
			// disabled by user request
			_DisableInterface(device);
			continue;
		}

		if (!strncmp(device, "/dev/net/", 9)) {
			// it's a kernel device, check if it's present
			BEntry entry(device);
			if (!entry.Exists()) {
				if (!missing && _missingDevice != NULL) {
					*_missingDevice = interface;
					missing = true;
				}
				continue;
			}
		}

		if (_ConfigureInterface(interface) == B_OK)
			devicesSet.Add(device);
	}
}


void
NetServer::_BringUpInterfaces()
{
	// we need a socket to talk to the networking stack
	if (!_IsValidFamily(AF_LINK)) {
		fprintf(stderr, "%s: The networking stack doesn't seem to be "
			"available.\n", Name());
		Quit();
		return;
	}

	_RemoveInvalidInterfaces();

	// First, we look into the settings, and try to bring everything up from
	// there

	BStringList devicesAlreadyConfigured;
	BMessage missingDevice;
	_ConfigureInterfacesFromSettings(devicesAlreadyConfigured, &missingDevice);

	// Check configuration

	if (!_TestForInterface("loop")) {
		// there is no loopback interface, create one
		BMessage interface;
		interface.AddString("device", "loop");
		BMessage v4address;
		v4address.AddString("family", "inet");
		v4address.AddString("address", "127.0.0.1");
		interface.AddMessage("address", &v4address);

		// Check for IPv6 support and add ::1
		if (_IsValidFamily(AF_INET6)) {
			BMessage v6address;
			v6address.AddString("family", "inet6");
			v6address.AddString("address", "::1");
			interface.AddMessage("address", &v6address);
		}
		_ConfigureInterface(interface);
	}

	// TODO: also check if the networking driver is correctly initialized!
	//	(and check for other devices to take over its configuration)

	// There is no driver configured - see if there is one and try to use it
	_ConfigureDevices("/dev/net", devicesAlreadyConfigured,
		missingDevice.HasString("device") ? &missingDevice : NULL);
}


/*!	Configure the link local address based on the network card's MAC address
	if this isn't a loopback device.
*/
void
NetServer::_ConfigureIPv6LinkLocal(const char* name)
{
	// Check for IPv6 support
	if (!_IsValidFamily(AF_INET6))
		return;

	BNetworkInterface interface(name);

	// Lets make sure this is *not* the loopback interface
	if ((interface.Flags() & IFF_LOOPBACK) != 0)
		return;

	BNetworkAddress link;
	status_t result = interface.GetHardwareAddress(link);

	if (result != B_OK || link.LinkLevelAddressLength() != 6)
		return;

	const uint8* mac = link.LinkLevelAddress();

	// Check for a few failure situations
	static const uint8 zeroMac[6] = {0, 0, 0, 0, 0, 0};
	static const uint8 fullMac[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
	if (memcmp(mac, zeroMac, 6) == 0
		|| memcmp(mac, fullMac, 6) == 0) {
		// Mac address is all 0 or all FF's
		syslog(LOG_DEBUG, "%s: MacAddress for interface '%s' is invalid.",
			__func__, name);
		return;
	}

	// Generate a Link Local Scope address
	// (IPv6 address based on Mac address)
	in6_addr addressRaw;
	memset(addressRaw.s6_addr, 0, sizeof(addressRaw.s6_addr));
	addressRaw.s6_addr[0] = 0xfe;
	addressRaw.s6_addr[1] = 0x80;
	addressRaw.s6_addr[8] = mac[0] ^ 0x02;
	addressRaw.s6_addr[9] = mac[1];
	addressRaw.s6_addr[10] = mac[2];
	addressRaw.s6_addr[11] = 0xff;
	addressRaw.s6_addr[12] = 0xfe;
	addressRaw.s6_addr[13] = mac[3];
	addressRaw.s6_addr[14] = mac[4];
	addressRaw.s6_addr[15] = mac[5];

	BNetworkAddress localLinkAddress(addressRaw, 0);
	BNetworkAddress localLinkMask(
		AF_INET6,
		"ffff:ffff:ffff:ffff::", // 64
		(uint16)0,
		B_UNCONFIGURED_ADDRESS_FAMILIES);
	BNetworkAddress localLinkBroadcast(
		AF_INET6,
		"fe80::ffff:ffff:ffff:ffff",
		(uint16)0,
		B_UNCONFIGURED_ADDRESS_FAMILIES);

	if (interface.FindAddress(localLinkAddress) >= 0) {
		// uhoh... already has a local link address

		/*	TODO: Check for any local link scope addresses assigned to card
			There isn't any flag at the moment though for address scope
		*/
		syslog(LOG_DEBUG, "%s: Local Link address already assigned to %s\n",
			__func__, name);
		return;
	}

	BNetworkInterfaceAddress interfaceAddress;
	interfaceAddress.SetAddress(localLinkAddress);
	interfaceAddress.SetMask(localLinkMask);
	interfaceAddress.SetBroadcast(localLinkMask);

	/*	TODO: Duplicate Address Detection.  (DAD)
		Need to blast an icmp packet over the IPv6 network from :: to ensure
		there aren't duplicate MAC addresses on the network. (definitely an
		edge case, but a possible issue)
	*/

	interface.AddAddress(interfaceAddress);
}


void
NetServer::_StartServices()
{
	BHandler* services = new (std::nothrow) Services(fSettings.Services());
	if (services != NULL) {
		AddHandler(services);
		fServices = BMessenger(services);
	}
}


status_t
NetServer::_HandleDeviceMonitor(BMessage* message)
{
	int32 opcode;
	const char* path;
	if (message->FindInt32("opcode", &opcode) != B_OK
		|| (opcode != B_ENTRY_CREATED && opcode != B_ENTRY_REMOVED)
		|| message->FindString("path", &path) != B_OK)
		return B_BAD_VALUE;

	if (strncmp(path, "/dev/net/", 9)) {
		// not a valid device entry, ignore
		return B_NAME_NOT_FOUND;
	}

	if (opcode == B_ENTRY_CREATED)
		_ConfigureDevice(path);
	else
		_RemoveInterface(path);

	return B_OK;
}


status_t
NetServer::_AutoJoinNetwork(const BMessage& message)
{
	const char* name = NULL;
	if (message.FindString("device", &name) != B_OK)
		return B_BAD_VALUE;

	BNetworkDevice device(name);

	// Choose among configured networks

	uint32 cookie = 0;
	BMessage networkMessage;
	while (fSettings.GetNextNetwork(cookie, networkMessage) == B_OK) {
		status_t status = B_ERROR;
		wireless_network network;
		const char* networkName;
		BNetworkAddress link;

		const char* mac = NULL;
		if (networkMessage.FindString("mac", &mac) == B_OK) {
			link.SetTo(AF_LINK, mac);
			status = device.GetNetwork(link, network);
		} else if (networkMessage.FindString("name", &networkName) == B_OK)
			status = device.GetNetwork(networkName, network);

		if (status == B_OK) {
			status = _JoinNetwork(message, mac != NULL ? &link : NULL,
				network.name);
			printf("auto join network \"%s\": %s\n", network.name,
				strerror(status));
			if (status == B_OK)
				return B_OK;
		}
	}

	return B_NO_INIT;
}


status_t
NetServer::_JoinNetwork(const BMessage& message, const BNetworkAddress* address,
	const char* name)
{
	const char* deviceName;
	if (message.FindString("device", &deviceName) != B_OK)
		return B_BAD_VALUE;

	BNetworkAddress deviceAddress;
	message.FindFlat("address", &deviceAddress);
	if (address == NULL)
		address = &deviceAddress;

	if (name == NULL)
		message.FindString("name", &name);
	if (name == NULL) {
		// No name specified, we need a network address
		if (address->Family() != AF_LINK)
			return B_BAD_VALUE;
	}

	// Search for a network configuration that may override the defaults

	bool found = false;
	uint32 cookie = 0;
	BMessage networkMessage;
	while (fSettings.GetNextNetwork(cookie, networkMessage) == B_OK) {
		const char* networkName;
		if (networkMessage.FindString("name", &networkName) == B_OK
			&& name != NULL && address->Family() != AF_LINK
			&& !strcmp(name, networkName)) {
			found = true;
			break;
		}

		const char* mac;
		if (networkMessage.FindString("mac", &mac) == B_OK
			&& address->Family() == AF_LINK) {
			BNetworkAddress link(AF_LINK, mac);
			if (link == *address) {
				found = true;
				break;
			}
		}
	}

	const char* password;
	if (message.FindString("password", &password) != B_OK && found)
		password = networkMessage.FindString("password");

	// Get network
	BNetworkDevice device(deviceName);
	wireless_network network;

	bool askForConfig = false;
	if ((address->Family() != AF_LINK
			|| device.GetNetwork(*address, network) != B_OK)
		&& device.GetNetwork(name, network) != B_OK) {
		// We did not find a network - just ignore that, and continue
		// with some defaults
		strlcpy(network.name, name != NULL ? name : "", sizeof(network.name));
		network.address = *address;
		network.authentication_mode = B_NETWORK_AUTHENTICATION_NONE;
		network.cipher = 0;
		network.group_cipher = 0;
		network.key_mode = 0;
		askForConfig = true;
	}

	BString string;
	if ((message.FindString("authentication", &string) == B_OK
			&& !string.IsEmpty())
		|| (found && networkMessage.FindString("authentication", &string)
				== B_OK && !string.IsEmpty())) {
		askForConfig = false;
		if (string.ICompare("wpa2") == 0) {
			network.authentication_mode = B_NETWORK_AUTHENTICATION_WPA2;
			network.key_mode = B_KEY_MODE_IEEE802_1X;
			network.cipher = network.group_cipher = B_NETWORK_CIPHER_CCMP;
		} else if (string.ICompare("wpa") == 0) {
			network.authentication_mode = B_NETWORK_AUTHENTICATION_WPA;
			network.key_mode = B_KEY_MODE_IEEE802_1X;
			network.cipher = network.group_cipher = B_NETWORK_CIPHER_TKIP;
		} else if (string.ICompare("wep") == 0) {
			network.authentication_mode = B_NETWORK_AUTHENTICATION_WEP;
			network.key_mode = B_KEY_MODE_NONE;
			network.cipher = network.group_cipher = B_NETWORK_CIPHER_WEP_40;
		} else if (string.ICompare("none") != 0 && string.ICompare("open") != 0) {
			fprintf(stderr, "%s: invalid authentication mode.\n", name);
			askForConfig = true;
		}
	}

	// We always try to join via the wpa_supplicant. Even if we could join
	// ourselves, we need to make sure that the wpa_supplicant knows about
	// our intention, as otherwise it would interfere with it.

	BMessenger wpaSupplicant(kWPASupplicantSignature);
	if (!wpaSupplicant.IsValid()) {
		// The wpa_supplicant isn't running yet, we may join ourselves.
		if (!askForConfig
			&& network.authentication_mode == B_NETWORK_AUTHENTICATION_NONE) {
			// We can join this network ourselves.
			status_t status = set_80211(deviceName, IEEE80211_IOC_SSID,
				network.name, strlen(network.name));
			if (status != B_OK) {
				fprintf(stderr, "%s: joining SSID failed: %s\n", name,
					strerror(status));
				return status;
			}
		}

		// We need the supplicant, try to launch it.
		status_t status = be_roster->Launch(kWPASupplicantSignature);
		if (status != B_OK && status != B_ALREADY_RUNNING)
			return status;

		wpaSupplicant.SetTo(kWPASupplicantSignature);
		if (!wpaSupplicant.IsValid())
			return B_ERROR;
	}

	// TODO: listen to notifications from the supplicant!

	BMessage join(kMsgWPAJoinNetwork);
	status_t status = join.AddString("device", deviceName);
	if (status == B_OK)
		status = join.AddString("name", network.name);
	if (status == B_OK)
		status = join.AddFlat("address", &network.address);
	if (status == B_OK && !askForConfig)
		status = join.AddUInt32("authentication", network.authentication_mode);
	if (status == B_OK && password != NULL)
		status = join.AddString("password", password);
	if (status != B_OK)
		return status;

	status = wpaSupplicant.SendMessage(&join);
	if (status != B_OK)
		return status;

	return B_OK;
}


status_t
NetServer::_LeaveNetwork(const BMessage& message)
{
	const char* deviceName;
	if (message.FindString("device", &deviceName) != B_OK)
		return B_BAD_VALUE;

	int32 reason;
	if (message.FindInt32("reason", &reason) != B_OK)
		reason = IEEE80211_REASON_AUTH_LEAVE;

	// We always try to send the leave request to the wpa_supplicant.

	BMessenger wpaSupplicant(kWPASupplicantSignature);
	if (wpaSupplicant.IsValid()) {
		BMessage leave(kMsgWPALeaveNetwork);
		status_t status = leave.AddString("device", deviceName);
		if (status == B_OK)
			status = leave.AddInt32("reason", reason);
		if (status != B_OK)
			return status;

		status = wpaSupplicant.SendMessage(&leave);
		if (status == B_OK)
			return B_OK;
	}

	// The wpa_supplicant doesn't seem to be running, check if this was an open
	// network we connected ourselves.
	BNetworkDevice device(deviceName);
	wireless_network network;

	uint32 cookie = 0;
	if (device.GetNextAssociatedNetwork(cookie, network) != B_OK
		|| network.authentication_mode != B_NETWORK_AUTHENTICATION_NONE) {
		// We didn't join ourselves, we can't do much.
		return B_ERROR;
	}

	// We joined ourselves, so we can just disassociate again.
	ieee80211req_mlme mlmeRequest;
	memset(&mlmeRequest, 0, sizeof(mlmeRequest));
	mlmeRequest.im_op = IEEE80211_MLME_DISASSOC;
	mlmeRequest.im_reason = reason;

	return set_80211(deviceName, IEEE80211_IOC_MLME, &mlmeRequest,
		sizeof(mlmeRequest));
}


//	#pragma mark -


int
main(int argc, char** argv)
{
	srand(system_time());

	status_t status;
	NetServer server(status);
	if (status != B_OK) {
		fprintf(stderr, "net_server: Failed to create application: %s\n",
			strerror(status));
		return 1;
	}

	server.Run();
	return 0;
}