Empty schema, table, user and password fix, not exported table fix

src/Configuration.h

@@ -55,7 +55,7 @@ protected:
 
 public:
 //------------------------------------------------------------------------------
-//	[Public] User methods
+//	[Public] Create class method
 //------------------------------------------------------------------------------
 	static Configuration::SP create(std::string certificateFile,
         std::string privateKeyFile, std::string dHTempFile,
@@ -73,19 +73,27 @@ public:
 		return c_sp;
 	}
 
-	std::string getCertificateFile() const { return m_certificateFile; };
-	std::string getPrivateKeyFile() const { return m_privateKeyFile; };
-	std::string getDHTempFile() const { return m_dHTempFile; };
-	std::string getLocalHost() const { return m_localHost; };
-	unsigned int getLocalPort() const { return m_localPort; };
-	unsigned int getWorkerNumber() const { return m_workerNumber; };
-	std::string getDatabaseHost() const { return m_databaseHost; };
-	unsigned int getDatabasePort() const { return m_databasePort; };
-	std::string getDatabaseUsername() const { return m_databaseUsername; };
-	std::string getDatabasePassword() const { return m_databasePassword; };
+//------------------------------------------------------------------------------
+//	[Public] Getter methods
+//------------------------------------------------------------------------------
+	std::string getCertificateFile() const { return m_certificateFile; }
+	std::string getPrivateKeyFile() const { return m_privateKeyFile; }
+	std::string getDHTempFile() const { return m_dHTempFile; }
+	std::string getLocalHost() const { return m_localHost; }
+	unsigned int getLocalPort() const { return m_localPort; }
+	unsigned int getWorkerNumber() const { return m_workerNumber; }
+	std::string getDatabaseHost() const { return m_databaseHost; }
+	unsigned int getDatabasePort() const { return m_databasePort; }
+	std::string getDatabaseUsername() const { return m_databaseUsername; }
+	std::string getDatabasePassword() const { return m_databasePassword; }
     unsigned int getDatabaseConnectionNumber() const { return m_databaseConnectionNumber; }
     ExportedTablesMap& getExportedTablesMap() const { return m_exportedTablesMap; }
+    AuthorisedUsersMap& getAuthorisedUsersMap() const { return m_authorisedUsersMap; }
+
 
+//------------------------------------------------------------------------------
+//	[Public] Utilities methods
+//------------------------------------------------------------------------------
     bool isTableExported(const std::string schema, const std::string table)
     {
         std::pair<ExportedTablesMap::const_iterator, ExportedTablesMap::const_iterator > ret;

src/MetadataExporter.cpp

@@ -41,7 +41,6 @@
 
 #include <MetadataExporter.h>
 #include <MetadataExporterClass.h>
-#include <Configuration.h>
 #include <PlainServer.h>
 #include <SSLServer.h>
 
@@ -601,8 +600,25 @@ void MetadataExporter::importExportedTables(std::vector<std::string>& exportedTa
         }
 
         std::string schema = exportedTables.at(i).substr(0, found);
+
+        if(schema.empty())
+        {
+            std::stringstream errorStream;
+            errorStream << "ExportedTables property has empty schema at "
+                << i << " position" << std::endl;
+            throw std::invalid_argument(errorStream.str());
+        }
+
         std::string table = exportedTables.at(i).substr(found+1, std::string::npos);
 
+        if(table.empty())
+        {
+            std::stringstream errorStream;
+            errorStream << "ExportedTables property has empty table at "
+                << i << " position" << std::endl;
+            throw std::invalid_argument(errorStream.str());
+        }
+
         INFO_STREAM << "MetadataExporter::importExportedTables() schema "
             << schema << " table " << table << endl;
 
@@ -632,8 +648,25 @@ void MetadataExporter::importAuthorisedUsers(std::vector<std::string>& authorise
         }
 
         std::string user = authorisedUsers.at(i).substr(0, found);
+
+        if(user.empty())
+        {
+            std::stringstream errorStream;
+            errorStream << "AuthorisedUsers property has empty user at "
+                << i << " position" << std::endl;
+            throw std::invalid_argument(errorStream.str());
+        }
+
         std::string password = authorisedUsers.at(i).substr(found+1, std::string::npos);
 
+        if(password.empty())
+        {
+            std::stringstream errorStream;
+            errorStream << "AuthorisedUsers property has empty password at "
+                << i << " position" << std::endl;
+            throw std::invalid_argument(errorStream.str());
+        }
+
         #ifdef VERBOSE_DEBUG
             INFO_STREAM << "MetadataExporter::importAuthorisedUsers() user "
                 << user << " password " << password << endl;

src/MetadataExporter.h

@@ -38,6 +38,7 @@
 #ifndef MetadataExporter_H
 #define MetadataExporter_H
 
+#include <Configuration.h>
 #include <Server.h>
 
 #include <tango.h>

src/ProtocolManager.cpp

@@ -163,6 +163,8 @@ ResponseSP ProtocolManager::prepareValidation(RequestSP request_sp)
             m_validatedSchema = validationReq.schema();
             m_validatedTable =  validationReq.table();
 
+            if(m_configuration_sp->isTableExported(m_validatedSchema, m_validatedTable))
+            {
                 try
                 {
                     DBManager::InformationList informationList =
@@ -206,6 +208,15 @@ ResponseSP ProtocolManager::prepareValidation(RequestSP request_sp)
                 }
             }
             else
+            {
+                WARN_STREAM << "ProtocolManager::prepareValidation() "
+                    << "Not exported table from " << m_remoteEndpoint << endl;
+
+                validationRes->set_state(Response::Validation::REJECTED);
+                validationRes->set_status("Not exported table");
+            }
+        }
+        else
         {
             WARN_STREAM << "ProtocolManager::prepareValidation() "
                 << "Already validated from " << m_remoteEndpoint << endl;