haiku.git

/*
 * Copyright 2003-2007, Waldemar Kornewald <wkornew@gmx.net>
 * Distributed under the terms of the MIT License.
 */

#include <KPPPDefs.h>
#include <driver_settings.h>

#include "settings_tools.h"

#include <cstring>
#include <malloc.h>


static const char *sSkipInterfaceParameters[] = {
	PPP_ASK_BEFORE_CONNECTING_KEY,
	PPP_DISONNECT_AFTER_IDLE_SINCE_KEY,
	PPP_CONNECT_RETRIES_LIMIT_KEY,
	PPP_CONNECT_RETRY_DELAY_KEY,
	PPP_AUTO_RECONNECT_KEY,
	PPP_RECONNECT_DELAY_KEY,
	NULL
};


driver_settings*
dup_driver_settings(const driver_settings *dup)
{
	if (!dup)
		return NULL; // we got a NULL pointer, so return nothing
	
	driver_settings *ret = new_driver_settings();
	
	ret->parameter_count = dup->parameter_count;
	
	if (ret->parameter_count > 0) {
		ret->parameters = (driver_parameter*)
			malloc(ret->parameter_count * sizeof(driver_parameter));
		memset(ret->parameters, 0, ret->parameter_count * sizeof(driver_parameter));
	} else
		ret->parameters = NULL;
	
	for (int32 index = 0; index < ret->parameter_count; index++)
		copy_driver_parameter(&dup->parameters[index], &ret->parameters[index]);
	
	return ret;
}


void
free_driver_settings(driver_settings *settings)
{
	if (!settings)
		return;
	
	for (int32 index = 0; index < settings->parameter_count; index++)
		free_driver_parameter_fields(&settings->parameters[index]);
	
	free(settings->parameters);
	free(settings);
}


void
free_driver_parameter(driver_parameter *parameter)
{
	free_driver_parameter_fields(parameter);
	free(parameter);
}


void
free_driver_parameter_fields(driver_parameter *parameter)
{
	free(parameter->name);
	
	for (int32 index = 0; index < parameter->value_count; index++)
		free(parameter->values[index]);
	
	free(parameter->values);
	
	for (int32 index = 0; index < parameter->parameter_count; index++)
		free_driver_parameter_fields(&parameter->parameters[index]);
	
	free(parameter->parameters);
}


driver_settings*
new_driver_settings()
{
	driver_settings *settings = (driver_settings*) malloc(sizeof(driver_settings));
	memset(settings, 0, sizeof(driver_settings));
	
	return settings;
}


driver_parameter*
new_driver_parameter(const char *name)
{
	driver_parameter *parameter = (driver_parameter*) malloc(sizeof(driver_parameter));
	memset(parameter, 0, sizeof(driver_parameter));
	
	set_driver_parameter_name(name, parameter);
	
	return parameter;
}


bool
copy_driver_parameter(const driver_parameter *from, driver_parameter *to)
{
	if (!from || !to)
		return false;
	
	free_driver_parameter_fields(to);
	
	if (from->name)
		to->name = strdup(from->name);
	else
		to->name = NULL;
	
	to->value_count = from->value_count;
	if (from->value_count > 0)
		to->values = (char**) malloc(from->value_count * sizeof(char*));
	else
		to->values = NULL;
	
	for (int32 index = 0; index < to->value_count; index++)
		to->values[index] = strdup(from->values[index]);
	
	to->parameter_count = from->parameter_count;
	
	if (to->parameter_count > 0) {
		to->parameters =
			(driver_parameter*) malloc(to->parameter_count * sizeof(driver_parameter));
		memset(to->parameters, 0, to->parameter_count * sizeof(driver_parameter));
	} else
		to->parameters = NULL;
	
	for (int32 index = 0; index < to->parameter_count; index++)
		copy_driver_parameter(&from->parameters[index], &to->parameters[index]);
	
	return true;
}


bool
set_driver_parameter_name(const char *name, driver_parameter *parameter)
{
	if (!parameter)
		return false;
	
	free(parameter->name);
	
	if (name)
		parameter->name = strdup(name);
	else
		parameter->name = NULL;
	
	return true;
}


bool
add_driver_parameter_value(const char *value, driver_parameter *to)
{
	if (!value || !to)
		return false;
	
	int32 oldCount = to->value_count;
	char **old = to->values;
	
	to->values = (char**) malloc((oldCount + 1) * sizeof(char*));
	
	if (!to->values) {
		to->values = old;
		return false;
	}
	
	to->value_count++;
	memcpy(to->values, old, oldCount * sizeof(char*));
	to->values[oldCount] = strdup(value);
	
	return true;
}


bool
add_driver_parameter(driver_parameter *add, driver_settings *to)
{
	if (!add || !to)
		return false;
	
	int32 oldCount = to->parameter_count;
	driver_parameter *old = to->parameters;
	
	to->parameters =
		(driver_parameter*) malloc((oldCount + 1) * sizeof(driver_parameter));
	
	if (!to->parameters) {
		to->parameters = old;
		return false;
	}
	
	to->parameter_count++;
	memcpy(to->parameters, old, oldCount * sizeof(driver_parameter));
	memcpy(to->parameters + oldCount, add, sizeof(driver_parameter));
	
	return true;
}


bool
equal_driver_settings(const driver_settings *lhs, const driver_settings *rhs)
{
	if (!lhs && !rhs)
		return true;
	else if (!lhs || !rhs)
		return false;
	
	if (lhs->parameter_count != rhs->parameter_count)
		return false;
	
	for (int32 index = 0; index < lhs->parameter_count; index++) {
		if (!equal_driver_parameters(&lhs->parameters[index], &rhs->parameters[index]))
			return false;
	}
	
	return true;
}


bool
equal_driver_parameters(const driver_parameter *lhs, const driver_parameter *rhs)
{
	if (!lhs && !rhs)
		return true;
	else if (!lhs || !rhs)
		return false;
	
	if (lhs->name && rhs->name) {
		if (strcmp(lhs->name, rhs->name))
			return false;
	} else if (lhs->name != rhs->name)
		return false;
	
	if (lhs->value_count != rhs->value_count
			|| lhs->parameter_count != rhs->parameter_count)
		return false;
	
	for (int32 index = 0; index < lhs->value_count; index++) {
		if (strcmp(lhs->values[index], rhs->values[index]))
			return false;
	}
	
	for (int32 index = 0; index < lhs->parameter_count; index++) {
		if (!equal_driver_parameters(&lhs->parameters[index], &rhs->parameters[index]))
			return false;
	}
	
	return true;
}


bool
skip_interface_parameter(const driver_parameter *parameter)
{
	if (!parameter || !parameter->name)
		return false;
	
	for (int32 index = 0; sSkipInterfaceParameters[index]; index++)
		if (!strcasecmp(parameter->name, sSkipInterfaceParameters[index]))
			return true;
	
	return false;
}


bool
equal_interface_settings(const driver_settings *lhs, const driver_settings *rhs)
{
	if (!lhs && !rhs)
		return true;
	else if (!lhs || !rhs)
		return false;
	
	int32 lhsIndex = 0, rhsIndex = 0;
	for (; lhsIndex < lhs->parameter_count; lhsIndex++) {
		if (skip_interface_parameter(&lhs->parameters[lhsIndex]))
			continue;
		
		for (; rhsIndex < rhs->parameter_count; rhsIndex++)
			if (!skip_interface_parameter(&rhs->parameters[rhsIndex]))
				break;
		
		if (rhsIndex >= rhs->parameter_count)
			return false;
		
		if (!equal_driver_parameters(&lhs->parameters[lhsIndex],
				&rhs->parameters[rhsIndex]))
			return false;
	}
	
	for (; rhsIndex < rhs->parameter_count; rhsIndex++)
		if (!skip_interface_parameter(&rhs->parameters[rhsIndex]))
			return false;
	
	return true;
}


ppp_side
get_side_string_value(const char *sideString, ppp_side unknownValue)
{
	if (!sideString)
		return unknownValue;
	
	if (!strcasecmp(sideString, "local"))
		return PPP_LOCAL_SIDE;
	if (!strcasecmp(sideString, "peer"))
		return PPP_PEER_SIDE;
	if (!strcasecmp(sideString, "none")
			|| !strcasecmp(sideString, "no"))
		return PPP_NO_SIDE;
	if (!strcasecmp(sideString, "both"))
		return PPP_BOTH_SIDES;
	
	// no correct value has been found => return default value
	return unknownValue;
}


bool
get_boolean_value(const char *string, bool unknownValue)
{
	if (!string)
		return unknownValue;
	
	if (!strcmp(string, "1")
			|| !strcasecmp(string, "true")
			|| !strcasecmp(string, "yes")
			|| !strcasecmp(string, "on")
			|| !strcasecmp(string, "enable")
			|| !strcasecmp(string, "enabled"))
		return true;
	
	if (!strcmp(string, "0")
			|| !strcasecmp(string, "false")
			|| !strcasecmp(string, "no")
			|| !strcasecmp(string, "off")
			|| !strcasecmp(string, "disable")
			|| !strcasecmp(string, "disabled"))
		return false;
	
	// no correct value has been found => return default value
	return unknownValue;
}


const driver_parameter*
get_parameter_with_name(const char *name, const driver_settings *settings)
{
	if (!name || !settings)
		return NULL;
	
	for (int32 index = 0; index < settings->parameter_count; index++)
		if (!strcasecmp(settings->parameters[index].name, name))
			return &settings->parameters[index];
	
	return NULL;
}


const char*
get_settings_value(const char *name, const driver_settings *settings)
{
	const driver_parameter *parameter = get_parameter_with_name(name, settings);
	
	if (parameter && parameter->value_count > 0 && parameter->values)
		return parameter->values[0];
	
	return NULL;
}