haiku.git

// Settings.cpp

#include <new>

#include <stdio.h>
#include <stdlib.h>

#include <driver_settings.h>
#include <FindDirectory.h>

#include "Debug.h"
#include "HashMap.h"
#include "IOCtlInfo.h"
#include "Settings.h"

using std::nothrow;

static const directory_which kDirectories[] = {
	B_USER_NONPACKAGED_DATA_DIRECTORY,
	B_USER_DATA_DIRECTORY,
	B_SYSTEM_NONPACKAGED_DATA_DIRECTORY,
	B_SYSTEM_DATA_DIRECTORY
};
static const char *kFSSubpath = "/userlandfs/file_systems/";

// IOCtlInfoMap
struct Settings::IOCtlInfoMap : public HashMap<HashKey32<int>, IOCtlInfo*> {
};


// _FindNextParameter
template<typename container_t>
static
const driver_parameter *
_FindNextParameter(const container_t *container, const char *name,
	int32 &cookie)
{
	const driver_parameter *parameter = NULL;
	if (container) {
		for (; !parameter && cookie < container->parameter_count; cookie++) {
			const driver_parameter &param = container->parameters[cookie];
			if (!strcmp(param.name, name))
				parameter = &param;
		}
	}
	return parameter;
}

// _GetParameterValue
template<typename container_t>
static
const char *
_GetParameterValue(const container_t *container, const char *name,
	const char *unknownValue, const char *noArgValue)
{
	if (container) {
		for (int32 i = container->parameter_count - 1; i >= 0; i--) {
			const driver_parameter &param = container->parameters[i];
			if (!strcmp(param.name, name)) {
				if (param.value_count > 0)
					return param.values[0];
				return noArgValue;
			}
		}
	}
	return unknownValue;
}

// contains
static inline
bool
contains(const char **array, size_t size, const char *value)
{
	for (int32 i = 0; i < (int32)size; i++) {
		if (!strcmp(array[i], value))
			return true;
	}
	return false;
}

// _GetParameterValue
template<typename container_t>
static
bool
_GetParameterValue(const container_t *container, const char *name,
	bool unknownValue, bool noArgValue)
{
	// note: container may be NULL
	const char unknown = 0;
	const char noArg = 0;
	const char *value = _GetParameterValue(container, name, &unknown, &noArg);
	if (value == &unknown)
		return unknownValue;
	if (value == &noArg)
		return noArgValue;
	const char *trueStrings[]
		= { "1", "true", "yes", "on", "enable", "enabled" };
	const char *falseStrings[]
		= { "0", "false", "no", "off", "disable", "disabled" };
	if (contains(trueStrings, sizeof(trueStrings) / sizeof(const char*),
				 value)) {
		return true;
	}
	if (contains(falseStrings, sizeof(falseStrings) / sizeof(const char*),
				 value)) {
		return false;
	}
	return unknownValue;
}

// _GetParameterValue
template<typename container_t>
static
int
_GetParameterValue(const container_t *container, const char *name,
	int unknownValue, int noArgValue)
{
	// note: container may be NULL
	const char unknown = 0;
	const char noArg = 0;
	const char *value = _GetParameterValue(container, name, &unknown, &noArg);
	if (value == &unknown)
		return unknownValue;
	if (value == &noArg)
		return noArgValue;
	return atoi(value);
}

// _FindFSParameter
static
const driver_parameter *
_FindFSParameter(const driver_settings *settings, const char *name)
{
	if (settings) {
		int32 cookie = 0;
		while (const driver_parameter *parameter
				= _FindNextParameter(settings, "file_system", cookie)) {
PRINT(("  found file_system parameter\n"));
if (parameter->value_count > 0)
PRINT(("    value: `%s'\n", parameter->values[0]));
			if (parameter->value_count == 1
				&& !strcmp(parameter->values[0], name)) {
				return parameter;
			}
		}
	}
	return NULL;
}

// constructor
Settings::Settings()
	: fIOCtlInfos(NULL)
{
}

// destructor
Settings::~Settings()
{
	Unset();
}

// SetTo
status_t
Settings::SetTo(const char* fsName)
{
	if (!fsName)
		RETURN_ERROR(B_BAD_VALUE);
	// unset
	Unset();
	// create the ioctl info map
	fIOCtlInfos = new(nothrow) IOCtlInfoMap;
	if (!fIOCtlInfos)
		RETURN_ERROR(B_NO_MEMORY);

	// load the driver settings for the FS
	char path[B_PATH_NAME_LENGTH];
	for (size_t i = 0; i < sizeof(kDirectories) / sizeof(kDirectories[0]);
			i++) {
		if (find_directory(kDirectories[i], -1, false, (char*)&path,
				B_PATH_NAME_LENGTH) != B_OK) {
			continue;
		}

		// construct the path within the directory
		strlcat(path, kFSSubpath, B_PATH_NAME_LENGTH);
		strlcat(path, fsName, B_PATH_NAME_LENGTH);

		// load the file at the constructed path
		void *settings = load_driver_settings((char*)&path);
		if (!settings)
			continue;

		// get the settings from the loaded file
		const driver_settings *ds = get_driver_settings(settings);
		if (!ds) {
			unload_driver_settings(settings);
			continue;
		}

		// get the parameter from the settings
		const driver_parameter *fsParameter = NULL;
		fsParameter = _FindFSParameter(ds, fsName);

		//  init the object and unload the settings
		if (fsParameter)
			_Init(ds, fsParameter);
		unload_driver_settings(settings);
		
		// if we found the parameter, we're done
		if (fsParameter)
			return B_OK;
	}

	// if we get here, we did not find the parameter
	return B_ENTRY_NOT_FOUND;
}

// Unset
void
Settings::Unset()
{
	if (fIOCtlInfos) {
		for (IOCtlInfoMap::Iterator it = fIOCtlInfos->GetIterator();
			 it.HasNext();) {
			IOCtlInfoMap::Entry entry = it.Next();
			delete entry.value;
		}
		delete fIOCtlInfos;
		fIOCtlInfos = NULL;
	}
}

// GetIOCtlInfo
const IOCtlInfo*
Settings::GetIOCtlInfo(int command) const
{
	return (fIOCtlInfos ? fIOCtlInfos->Get(command) : NULL);
}

// Dump
void
Settings::Dump() const
{
	D(
		PRINT(("Settings:\n"));
		if (fIOCtlInfos) {
			for (IOCtlInfoMap::Iterator it = fIOCtlInfos->GetIterator();
				 it.HasNext();) {
				IOCtlInfoMap::Entry entry = it.Next();
				IOCtlInfo* info = entry.value;
				PRINT(("  ioctl %d: buffer size: %" B_PRId32
					", write buffer size: %" B_PRId32 "\n", info->command,
					info->bufferSize, info->writeBufferSize));
			}
		}
	)
}

// _Init
status_t
Settings::_Init(const driver_settings *settings,
				const driver_parameter *fsParams)
{
PRINT(("Settings::_Init(%p, %p)\n", settings, fsParams));
	status_t error = B_OK;
	int32 cookie = 0;
	while (const driver_parameter *parameter
			= _FindNextParameter(fsParams, "ioctl", cookie)) {
		if (parameter->value_count == 1) {
			int command = atoi(parameter->values[0]);
			if (command > 0) {
				IOCtlInfo* info = fIOCtlInfos->Remove(command);
				if (!info) {
					info = new(nothrow) IOCtlInfo;
					if (!info)
						RETURN_ERROR(B_NO_MEMORY);
				}
				info->command = command;
				info->bufferSize
					= _GetParameterValue(parameter, "buffer_size", 0, 0);
				info->writeBufferSize
					= _GetParameterValue(parameter, "write_buffer_size", 0, 0);
				info->isBuffer = _GetParameterValue(parameter, "is_buffer",
					false, false);
				error = fIOCtlInfos->Put(command, info);
				if (error != B_OK) {
					delete info;
					return error;
				}
			}
		}
	}
PRINT(("Settings::_Init() done: %s\n", strerror(error)));
	return error;
}