haiku.git

/*
 * Copyright 2015, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include "Conditions.h"

#include <stdio.h>

#include <driver_settings.h>
#include <Entry.h>
#include <File.h>
#include <ObjectList.h>
#include <Message.h>
#include <Path.h>
#include <StringList.h>

#include "NetworkWatcher.h"
#include "Utility.h"


class ConditionContainer : public Condition {
protected:
								ConditionContainer(const BMessage& args);
								ConditionContainer();

public:
			void				AddCondition(Condition* condition);

	virtual	bool				IsConstant(ConditionContext& context) const;

protected:
			void				AddConditionsToString(BString& string) const;

protected:
			BObjectList<Condition, true> fConditions;
};


class AndCondition : public ConditionContainer {
public:
								AndCondition(const BMessage& args);
								AndCondition();

	virtual	bool				Test(ConditionContext& context) const;
	virtual	BString				ToString() const;
};


class OrCondition : public ConditionContainer {
public:
								OrCondition(const BMessage& args);

	virtual	bool				Test(ConditionContext& context) const;
	virtual	bool				IsConstant(ConditionContext& context) const;

	virtual	BString				ToString() const;
};


class NotCondition : public ConditionContainer {
public:
								NotCondition(const BMessage& args);
								NotCondition();

	virtual	bool				Test(ConditionContext& context) const;
	virtual	BString				ToString() const;
};


class SafeModeCondition : public Condition {
public:
	virtual	bool				Test(ConditionContext& context) const;
	virtual	bool				IsConstant(ConditionContext& context) const;

	virtual	BString				ToString() const;
};


class ReadOnlyCondition : public Condition {
public:
								ReadOnlyCondition(const BMessage& args);

	virtual	bool				Test(ConditionContext& context) const;
	virtual	bool				IsConstant(ConditionContext& context) const;

	virtual	BString				ToString() const;

private:
			BString				fPath;
	mutable	bool				fIsReadOnly;
	mutable	bool				fTestPerformed;
};


class FileExistsCondition : public Condition {
public:
								FileExistsCondition(const BMessage& args);

	virtual	bool				Test(ConditionContext& context) const;
	virtual	BString				ToString() const;

private:
			BStringList			fPaths;
};


class NetworkAvailableCondition : public Condition {
public:
	virtual	bool				Test(ConditionContext& context) const;
	virtual	bool				IsConstant(ConditionContext& context) const;

	virtual	BString				ToString() const;
};


class SettingCondition : public Condition {
public:
								SettingCondition(const BMessage& args);

	virtual	bool				Test(ConditionContext& context) const;

	virtual	BString				ToString() const;

private:
			BPath				fPath;
			BString				fField;
			BString				fValue;
};


static Condition*
create_condition(const char* name, const BMessage& args)
{
	if (strcmp(name, "and") == 0 && !args.IsEmpty())
		return new AndCondition(args);
	if (strcmp(name, "or") == 0 && !args.IsEmpty())
		return new OrCondition(args);
	if (strcmp(name, "not") == 0 && !args.IsEmpty())
		return new NotCondition(args);

	if (strcmp(name, "safemode") == 0)
		return new SafeModeCondition();
	if (strcmp(name, "read_only") == 0)
		return new ReadOnlyCondition(args);
	if (strcmp(name, "file_exists") == 0)
		return new FileExistsCondition(args);
	if (strcmp(name, "network_available") == 0)
		return new NetworkAvailableCondition();
	if (strcmp(name, "setting") == 0)
		return new SettingCondition(args);

	return NULL;
}


// #pragma mark -


Condition::Condition()
{
}


Condition::~Condition()
{
}


bool
Condition::IsConstant(ConditionContext& context) const
{
	return false;
}


// #pragma mark -


ConditionContainer::ConditionContainer(const BMessage& args)
	:
	fConditions(10)
{
	char* name;
	type_code type;
	int32 count;
	for (int32 index = 0; args.GetInfo(B_MESSAGE_TYPE, index, &name, &type,
			&count) == B_OK; index++) {
		BMessage message;
		for (int32 messageIndex = 0; args.FindMessage(name, messageIndex,
				&message) == B_OK; messageIndex++) {
			AddCondition(create_condition(name, message));
		}
	}
}


ConditionContainer::ConditionContainer()
	:
	fConditions(10)
{
}


void
ConditionContainer::AddCondition(Condition* condition)
{
	if (condition != NULL)
		fConditions.AddItem(condition);
}


/*!	A single constant failing condition makes this constant, too, otherwise,
	a single non-constant condition makes this non-constant as well.
*/
bool
ConditionContainer::IsConstant(ConditionContext& context) const
{
	bool fixed = true;
	for (int32 index = 0; index < fConditions.CountItems(); index++) {
		const Condition* condition = fConditions.ItemAt(index);
		if (condition->IsConstant(context)) {
			if (!condition->Test(context))
				return true;
		} else
			fixed = false;
	}
	return fixed;
}


void
ConditionContainer::AddConditionsToString(BString& string) const
{
	string += "[";

	for (int32 index = 0; index < fConditions.CountItems(); index++) {
		if (index != 0)
			string += ", ";
		string += fConditions.ItemAt(index)->ToString();
	}
	string += "]";
}


// #pragma mark - and


AndCondition::AndCondition(const BMessage& args)
	:
	ConditionContainer(args)
{
}


AndCondition::AndCondition()
{
}


bool
AndCondition::Test(ConditionContext& context) const
{
	for (int32 index = 0; index < fConditions.CountItems(); index++) {
		Condition* condition = fConditions.ItemAt(index);
		if (!condition->Test(context))
			return false;
	}
	return true;
}


BString
AndCondition::ToString() const
{
	BString string = "and ";
	ConditionContainer::AddConditionsToString(string);
	return string;
}


// #pragma mark - or


OrCondition::OrCondition(const BMessage& args)
	:
	ConditionContainer(args)
{
}


bool
OrCondition::Test(ConditionContext& context) const
{
	if (fConditions.IsEmpty())
		return true;

	for (int32 index = 0; index < fConditions.CountItems(); index++) {
		Condition* condition = fConditions.ItemAt(index);
		if (condition->Test(context))
			return true;
	}
	return false;
}


/*!	If there is a single succeeding constant condition, this is constant, too.
	Otherwise, it is non-constant if there is a single non-constant condition.
*/
bool
OrCondition::IsConstant(ConditionContext& context) const
{
	bool fixed = true;
	for (int32 index = 0; index < fConditions.CountItems(); index++) {
		const Condition* condition = fConditions.ItemAt(index);
		if (condition->IsConstant(context)) {
			if (condition->Test(context))
				return true;
		} else
			fixed = false;
	}
	return fixed;
}


BString
OrCondition::ToString() const
{
	BString string = "or ";
	ConditionContainer::AddConditionsToString(string);
	return string;
}


// #pragma mark - or


NotCondition::NotCondition(const BMessage& args)
	:
	ConditionContainer(args)
{
}


NotCondition::NotCondition()
{
}


bool
NotCondition::Test(ConditionContext& context) const
{
	for (int32 index = 0; index < fConditions.CountItems(); index++) {
		Condition* condition = fConditions.ItemAt(index);
		if (condition->Test(context))
			return false;
	}
	return true;
}


BString
NotCondition::ToString() const
{
	BString string = "not ";
	ConditionContainer::AddConditionsToString(string);
	return string;
}


// #pragma mark - safemode


bool
SafeModeCondition::Test(ConditionContext& context) const
{
	return context.IsSafeMode();
}


bool
SafeModeCondition::IsConstant(ConditionContext& context) const
{
	return true;
}


BString
SafeModeCondition::ToString() const
{
	return "safemode";
}


// #pragma mark - read_only


ReadOnlyCondition::ReadOnlyCondition(const BMessage& args)
	:
	fPath(args.GetString("args")),
	fIsReadOnly(false),
	fTestPerformed(false)
{
}


bool
ReadOnlyCondition::Test(ConditionContext& context) const
{
	if (fTestPerformed)
		return fIsReadOnly;

	if (fPath.IsEmpty() || fPath == "/boot")
		fIsReadOnly = context.BootVolumeIsReadOnly();
	else
		fIsReadOnly = Utility::IsReadOnlyVolume(fPath);

	fTestPerformed = true;

	return fIsReadOnly;
}


bool
ReadOnlyCondition::IsConstant(ConditionContext& context) const
{
	return true;
}


BString
ReadOnlyCondition::ToString() const
{
	BString string = "readonly ";
	string << fPath;
	return string;
}


// #pragma mark - file_exists


FileExistsCondition::FileExistsCondition(const BMessage& args)
{
	for (int32 index = 0;
			const char* path = args.GetString("args", index, NULL); index++) {
		fPaths.Add(Utility::TranslatePath(path));
	}
}


bool
FileExistsCondition::Test(ConditionContext& context) const
{
	for (int32 index = 0; index < fPaths.CountStrings(); index++) {
		BEntry entry;
		if (entry.SetTo(fPaths.StringAt(index)) != B_OK
			|| !entry.Exists())
			return false;
	}
	return true;
}


BString
FileExistsCondition::ToString() const
{
	BString string = "file_exists [";
	for (int32 index = 0; index < fPaths.CountStrings(); index++) {
		if (index != 0)
			string << ", ";
		string << fPaths.StringAt(index);
	}
	string += "]";
	return string;
}


// #pragma mark - network_available


bool
NetworkAvailableCondition::Test(ConditionContext& context) const
{
	return NetworkWatcher::NetworkAvailable(false);
}


bool
NetworkAvailableCondition::IsConstant(ConditionContext& context) const
{
	return false;
}


BString
NetworkAvailableCondition::ToString() const
{
	return "network_available";
}


// #pragma mark - setting


SettingCondition::SettingCondition(const BMessage& args)
{
	fPath.SetTo(Utility::TranslatePath(args.GetString("args", 0, NULL)));
	fField = args.GetString("args", 1, NULL);
	fValue = args.GetString("args", 2, NULL);
}


bool
SettingCondition::Test(ConditionContext& context) const
{
	BFile file(fPath.Path(), B_READ_ONLY);
	if (file.InitCheck() != B_OK)
		return false;

	BMessage settings;
	if (settings.Unflatten(&file) == B_OK) {
		type_code type;
		int32 count;
		if (settings.GetInfo(fField, &type, &count) == B_OK) {
			switch (type) {
				case B_BOOL_TYPE:
				{
					bool value = settings.GetBool(fField);
					bool expect = fValue.IsEmpty();
					if (!expect) {
						expect = fValue == "true" || fValue == "yes"
							|| fValue == "on" || fValue == "1";
					}
					return value == expect;
				}
				case B_STRING_TYPE:
				{
					BString value = settings.GetString(fField);
					if (fValue.IsEmpty() && !value.IsEmpty())
						return true;

					return fValue == value;
				}
			}
		}
		return false;
	}

	void* handle = load_driver_settings(fPath.Path());
	if (handle != NULL) {
		char buffer[512];
		size_t bufferSize = sizeof(buffer);
		if (get_driver_settings_string(handle, buffer, &bufferSize, true) == B_OK) {
			BString pattern(fField);
			if (!fValue.IsEmpty()) {
				pattern << " = ";
				pattern << fValue;
			}
			return strstr(buffer, pattern.String()) != NULL;
		}
		unload_driver_settings(handle);
	}

	return false;
}


BString
SettingCondition::ToString() const
{
	BString string = "setting file ";
	string << fPath.Path() << ", field " << fField;
	if (!fValue.IsEmpty())
		string << ", value " << fValue;

	return string;
}


// #pragma mark -


/*static*/ Condition*
Conditions::FromMessage(const BMessage& message)
{
	return create_condition("and", message);
}


/*static*/ Condition*
Conditions::AddNotSafeMode(Condition* condition)
{
	AndCondition* andCondition = dynamic_cast<AndCondition*>(condition);
	if (andCondition == NULL)
		andCondition = new AndCondition();
	if (andCondition != condition && condition != NULL)
		andCondition->AddCondition(condition);

	NotCondition* notCondition = new NotCondition();
	notCondition->AddCondition(new SafeModeCondition());

	andCondition->AddCondition(notCondition);
	return andCondition;
}