Allow configuration of the server port that the client will connect to

(bbackupd and bbackupquery).

Redesign ConfigurationVerify to use classes instead of structs.

Use port 22011 instead of 2201 during tests, to reduce the chances of 
conflicting with a running bbstored or other process.

Ignore autogen_* in svn:ignore everywhere instead of individual per-file 
ignores.

1 files changed, 148 insertions, 56 deletions

diff --git a/lib/common/Configuration.cpp b/lib/common/Configuration.cpp
index 4d76e0e0..f797f454 100644
--- a/lib/common/Configuration.cpp
+++ b/lib/common/Configuration.cpp
@@ -12,6 +12,8 @@
 #include <stdlib.h>
 #include <limits.h>
 
+#include <sstream>
+
 #include "Configuration.h"
 #include "CommonException.h"
 #include "Guards.h"
@@ -29,7 +31,105 @@ inline bool iw(int c)
 static const char *sValueBooleanStrings[] = {"yes", "true", "no", "false", 0};
 static const bool sValueBooleanValue[] = {true, true, false, false};
 
+ConfigurationVerifyKey::ConfigurationVerifyKey
+(
+	std::string name,
+	int flags,
+	void *testFunction
+)
+: mName(name),
+  mHasDefaultValue(false),
+  mFlags(flags),
+  mTestFunction(testFunction)
+{ }
+
+// to allow passing NULL for default ListenAddresses
+
+ConfigurationVerifyKey::ConfigurationVerifyKey
+(
+	std::string name,
+	int flags,
+	NoDefaultValue_t t,
+	void *testFunction
+)
+: mName(name),
+  mHasDefaultValue(false),
+  mFlags(flags),
+  mTestFunction(testFunction)
+{ }
+
+ConfigurationVerifyKey::ConfigurationVerifyKey
+(
+	std::string name,
+	int flags,
+	std::string defaultValue,
+	void *testFunction
+)
+: mName(name),
+  mDefaultValue(defaultValue),
+  mHasDefaultValue(true),
+  mFlags(flags),
+  mTestFunction(testFunction)
+{ }
+
+ConfigurationVerifyKey::ConfigurationVerifyKey
+(
+	std::string name,
+	int flags,
+	const char *defaultValue,
+	void *testFunction
+)
+: mName(name),
+  mDefaultValue(defaultValue),
+  mHasDefaultValue(true),
+  mFlags(flags),
+  mTestFunction(testFunction)
+{ }
+
+ConfigurationVerifyKey::ConfigurationVerifyKey
+(
+	std::string name,
+	int flags,
+	int defaultValue,
+	void *testFunction
+)
+: mName(name),
+  mHasDefaultValue(true),
+  mFlags(flags),
+  mTestFunction(testFunction)
+{
+	ASSERT(flags & ConfigTest_IsInt);
+	std::ostringstream val;
+	val << defaultValue;
+	mDefaultValue = val.str();
+}
 
+ConfigurationVerifyKey::ConfigurationVerifyKey
+(
+	std::string name,
+	int flags,
+	bool defaultValue,
+	void *testFunction
+)
+: mName(name),
+  mHasDefaultValue(true),
+  mFlags(flags),
+  mTestFunction(testFunction)
+{
+	ASSERT(flags & ConfigTest_IsBool);
+	mDefaultValue = defaultValue ? "yes" : "no";
+}
+
+ConfigurationVerifyKey::ConfigurationVerifyKey
+(
+	const ConfigurationVerifyKey& rToCopy
+)
+: mName(rToCopy.mName),
+  mDefaultValue(rToCopy.mDefaultValue),
+  mHasDefaultValue(rToCopy.mHasDefaultValue),
+  mFlags(rToCopy.mFlags),
+  mTestFunction(rToCopy.mTestFunction)
+{ }
 
 // --------------------------------------------------------------------------
 //
@@ -120,8 +220,8 @@ std::auto_ptr<Configuration> Configuration::LoadAndVerify(
 		{
 			if(!Verify(*pconfig, *pVerify, std::string(), rErrorMsg))
 			{
-				//TRACE1("Error message from Verify: %s", rErrorMsg.c_str());
-				TRACE0("Error at Configuration::Verify\n");
+				BOX_ERROR("Error verifying configuration: " <<
+					rErrorMsg);
 				delete pconfig;
 				pconfig = 0;
 				return std::auto_ptr<Configuration>(0);
@@ -189,7 +289,8 @@ bool Configuration::LoadInto(Configuration &rConfig, FdGetLine &rGetLine, std::s
 			}
 			else
 			{
-				rErrorMsg += "Unexpected start block in " + rConfig.mName + "\n";
+				rErrorMsg += "Unexpected start block in " +
+					rConfig.mName + "\n";
 			}
 		}
 		else
@@ -290,36 +391,32 @@ bool Configuration::LoadInto(Configuration &rConfig, FdGetLine &rGetLine, std::s
 // --------------------------------------------------------------------------
 //
 // Function
-//		Name:    Configuration::KeyExists(const char *)
+//		Name:    Configuration::KeyExists(const std::string&)
 //		Purpose: Checks to see if a key exists
 //		Created: 2003/07/23
 //
 // --------------------------------------------------------------------------
-bool Configuration::KeyExists(const char *pKeyName) const
+bool Configuration::KeyExists(const std::string& rKeyName) const
 {
-	if(pKeyName == 0) {THROW_EXCEPTION(CommonException, BadArguments)}
-
-	return mKeys.find(pKeyName) != mKeys.end();
+	return mKeys.find(rKeyName) != mKeys.end();
 }
 
 
 // --------------------------------------------------------------------------
 //
 // Function
-//		Name:    Configuration::GetKeyValue(const char *)
+//		Name:    Configuration::GetKeyValue(const std::string&)
 //		Purpose: Returns the value of a configuration variable
 //		Created: 2003/07/23
 //
 // --------------------------------------------------------------------------
-const std::string &Configuration::GetKeyValue(const char *pKeyName) const
+const std::string &Configuration::GetKeyValue(const std::string& rKeyName) const
 {
-	if(pKeyName == 0) {THROW_EXCEPTION(CommonException, BadArguments)}
-
-	std::map<std::string, std::string>::const_iterator i(mKeys.find(pKeyName));
+	std::map<std::string, std::string>::const_iterator i(mKeys.find(rKeyName));
 	
 	if(i == mKeys.end())
 	{
-		BOX_ERROR("Missing configuration key: " << pKeyName);
+		BOX_ERROR("Missing configuration key: " << rKeyName);
 		THROW_EXCEPTION(CommonException, ConfigNoKey)
 	}
 	else
@@ -332,16 +429,14 @@ const std::string &Configuration::GetKeyValue(const char *pKeyName) const
 // --------------------------------------------------------------------------
 //
 // Function
-//		Name:    Configuration::GetKeyValueInt(const char *)
+//		Name:    Configuration::GetKeyValueInt(const std::string& rKeyName)
 //		Purpose: Gets a key value as an integer
 //		Created: 2003/07/23
 //
 // --------------------------------------------------------------------------
-int Configuration::GetKeyValueInt(const char *pKeyName) const
+int Configuration::GetKeyValueInt(const std::string& rKeyName) const
 {
-	if(pKeyName == 0) {THROW_EXCEPTION(CommonException, BadArguments)}
-
-	std::map<std::string, std::string>::const_iterator i(mKeys.find(pKeyName));
+	std::map<std::string, std::string>::const_iterator i(mKeys.find(rKeyName));
 	
 	if(i == mKeys.end())
 	{
@@ -362,16 +457,14 @@ int Configuration::GetKeyValueInt(const char *pKeyName) const
 // --------------------------------------------------------------------------
 //
 // Function
-//		Name:    Configuration::GetKeyValueBool(const char *) const
+//		Name:    Configuration::GetKeyValueBool(const std::string&)
 //		Purpose: Gets a key value as a boolean
 //		Created: 17/2/04
 //
 // --------------------------------------------------------------------------
-bool Configuration::GetKeyValueBool(const char *pKeyName) const
+bool Configuration::GetKeyValueBool(const std::string& rKeyName) const
 {
-	if(pKeyName == 0) {THROW_EXCEPTION(CommonException, BadArguments)}
-
-	std::map<std::string, std::string>::const_iterator i(mKeys.find(pKeyName));
+	std::map<std::string, std::string>::const_iterator i(mKeys.find(rKeyName));
 	
 	if(i == mKeys.end())
 	{
@@ -428,22 +521,21 @@ std::vector<std::string> Configuration::GetKeyNames() const
 // --------------------------------------------------------------------------
 //
 // Function
-//		Name:    Configuration::SubConfigurationExists(const char *)
+//		Name:    Configuration::SubConfigurationExists(const
+//			 std::string&)
 //		Purpose: Checks to see if a sub configuration exists
 //		Created: 2003/07/23
 //
 // --------------------------------------------------------------------------
-bool Configuration::SubConfigurationExists(const char *pSubName) const
+bool Configuration::SubConfigurationExists(const std::string& rSubName) const
 {
-	if(pSubName == 0) {THROW_EXCEPTION(CommonException, BadArguments)}
-
 	// Attempt to find it...
 	std::list<std::pair<std::string, Configuration> >::const_iterator i(mSubConfigurations.begin());
 	
 	for(; i != mSubConfigurations.end(); ++i)
 	{
 		// This the one?
-		if(i->first == pSubName)
+		if(i->first == rSubName)
 		{
 			// Yes.
 			return true;
@@ -458,22 +550,22 @@ bool Configuration::SubConfigurationExists(const char *pSubName) const
 // --------------------------------------------------------------------------
 //
 // Function
-//		Name:    Configuration::GetSubConfiguration(const char *)
+//		Name:    Configuration::GetSubConfiguration(const
+//			 std::string&)
 //		Purpose: Gets a sub configuration
 //		Created: 2003/07/23
 //
 // --------------------------------------------------------------------------
-const Configuration &Configuration::GetSubConfiguration(const char *pSubName) const
+const Configuration &Configuration::GetSubConfiguration(const std::string&
+	rSubName) const
 {
-	if(pSubName == 0) {THROW_EXCEPTION(CommonException, BadArguments)}
-
 	// Attempt to find it...
 	std::list<std::pair<std::string, Configuration> >::const_iterator i(mSubConfigurations.begin());
 	
 	for(; i != mSubConfigurations.end(); ++i)
 	{
 		// This the one?
-		if(i->first == pSubName)
+		if(i->first == rSubName)
 		{
 			// Yes.
 			return i->second;
@@ -528,15 +620,14 @@ bool Configuration::Verify(Configuration &rConfig, const ConfigurationVerify &rV
 		do
 		{
 			// Can the key be found?
-			ASSERT(pvkey->mpName);
-			if(rConfig.KeyExists(pvkey->mpName))
+			if(rConfig.KeyExists(pvkey->Name()))
 			{
 				// Get value
-				const std::string &rval = rConfig.GetKeyValue(pvkey->mpName);
+				const std::string &rval = rConfig.GetKeyValue(pvkey->Name());
 				const char *val = rval.c_str();
 
 				// Check it's a number?
-				if((pvkey->Tests & ConfigTest_IsInt) == ConfigTest_IsInt)
+				if((pvkey->Flags() & ConfigTest_IsInt) == ConfigTest_IsInt)
 				{					
 					// Test it...
 					char *end;
@@ -545,12 +636,12 @@ bool Configuration::Verify(Configuration &rConfig, const ConfigurationVerify &rV
 					{
 						// not a good value
 						ok = false;
-						rErrorMsg += rLevel + rConfig.mName +"." + pvkey->mpName + " (key) is not a valid integer.\n";
+						rErrorMsg += rLevel + rConfig.mName + "." + pvkey->Name() + " (key) is not a valid integer.\n";
 					}
 				}
 				
 				// Check it's a bool?
-				if((pvkey->Tests & ConfigTest_IsBool) == ConfigTest_IsBool)
+				if((pvkey->Flags() & ConfigTest_IsBool) == ConfigTest_IsBool)
 				{				
 					// See if it's one of the allowed strings.
 					bool found = false;
@@ -568,37 +659,38 @@ bool Configuration::Verify(Configuration &rConfig, const ConfigurationVerify &rV
 					if(!found)
 					{
 						ok = false;
-						rErrorMsg += rLevel + rConfig.mName +"." + pvkey->mpName + " (key) is not a valid boolean value.\n";
+						rErrorMsg += rLevel + rConfig.mName + "." + pvkey->Name() + " (key) is not a valid boolean value.\n";
 					}
 				}
 				
 				// Check for multi valued statments where they're not allowed
-				if((pvkey->Tests & ConfigTest_MultiValueAllowed) == 0)
+				if((pvkey->Flags() & ConfigTest_MultiValueAllowed) == 0)
 				{
 					// Check to see if this key is a multi-value -- it shouldn't be
 					if(rval.find(MultiValueSeparator) != rval.npos)
 					{
 						ok = false;
-						rErrorMsg += rLevel + rConfig.mName +"." + pvkey->mpName + " (key) multi value not allowed (duplicated key?).\n";
+						rErrorMsg += rLevel + rConfig.mName +"." + pvkey->Name() + " (key) multi value not allowed (duplicated key?).\n";
 					}
 				}				
 			}
 			else
 			{
 				// Is it required to exist?
-				if((pvkey->Tests & ConfigTest_Exists) == ConfigTest_Exists)
+				if((pvkey->Flags() & ConfigTest_Exists) == ConfigTest_Exists)
 				{
 					// Should exist, but doesn't.
 					ok = false;
-					rErrorMsg += rLevel + rConfig.mName + "." + pvkey->mpName + " (key) is missing.\n";
+					rErrorMsg += rLevel + rConfig.mName + "." + pvkey->Name() + " (key) is missing.\n";
 				}
-				else if(pvkey->mpDefaultValue)
+				else if(pvkey->HasDefaultValue())
 				{
-					rConfig.mKeys[std::string(pvkey->mpName)] = std::string(pvkey->mpDefaultValue);
+					rConfig.mKeys[pvkey->Name()] =
+						pvkey->DefaultValue();
 				}
 			}
 		
-			if((pvkey->Tests & ConfigTest_LastEntry) == ConfigTest_LastEntry)
+			if((pvkey->Flags() & ConfigTest_LastEntry) == ConfigTest_LastEntry)
 			{
 				// No more!
 				todo = false;
@@ -618,14 +710,14 @@ bool Configuration::Verify(Configuration &rConfig, const ConfigurationVerify &rV
 			bool found = false;
 			while(scan)
 			{
-				if(scan->mpName == i->first)
+				if(scan->Name() == i->first)
 				{
 					found = true;
 					break;
 				}
 				
 				// Next?
-				if((scan->Tests & ConfigTest_LastEntry) == ConfigTest_LastEntry)
+				if((scan->Flags() & ConfigTest_LastEntry) == ConfigTest_LastEntry)
 				{
 					break;
 				}
@@ -650,8 +742,7 @@ bool Configuration::Verify(Configuration &rConfig, const ConfigurationVerify &rV
 		const ConfigurationVerify *scan = rVerify.mpSubConfigurations;
 		while(scan)
 		{
-			ASSERT(scan->mpName);
-			if(scan->mpName[0] == '*')
+			if(scan->mName.length() > 0 && scan->mName[0] == '*')
 			{
 				wildcardverify = scan;
 			}
@@ -659,7 +750,8 @@ bool Configuration::Verify(Configuration &rConfig, const ConfigurationVerify &rV
 			// Required?
 			if((scan->Tests & ConfigTest_Exists) == ConfigTest_Exists)
 			{
-				if(scan->mpName[0] == '*')
+				if(scan->mName.length() > 0 &&
+					scan->mName[0] == '*')
 				{
 					// Check something exists
 					if(rConfig.mSubConfigurations.size() < 1)
@@ -672,11 +764,11 @@ bool Configuration::Verify(Configuration &rConfig, const ConfigurationVerify &rV
 				else
 				{
 					// Check real thing exists
-					if(!rConfig.SubConfigurationExists(scan->mpName))
+					if(!rConfig.SubConfigurationExists(scan->mName))
 					{
 						// Should exist, but doesn't.
 						ok = false;
-						rErrorMsg += rLevel + rConfig.mName + "." + scan->mpName + " (block) is missing.\n";
+						rErrorMsg += rLevel + rConfig.mName + "." + scan->mName + " (block) is missing.\n";
 					}
 				}
 			}
@@ -701,7 +793,7 @@ bool Configuration::Verify(Configuration &rConfig, const ConfigurationVerify &rV
 			ASSERT(name);
 			while(scan)
 			{
-				if(strcmp(scan->mpName, name) == 0)
+				if(scan->mName == name)
 				{
 					// found it!
 					subverify = scan;