openbase 0.8.1

data/ext/OpenBaseAdmin.c

@@ -0,0 +1,1884 @@
+#include "platform.h"
+
+/*
+	OpenBaseAdmin.c
+	OpenBase Unified Client
+	�1996-2002 OpenBase International, Ltd.
+	All rights reserved
+	
+	Derived from CommAPI.c in old client.
+
+	Disclaimer:
+	-----------
+	THIS SOFTWARE IS FURNISHED ON AN "AS-IS" BASIS. OPENBASE MAKES NO WARRANTIES OF 
+	ANY KIND, EITHER EXPRESS OR IMPLIED, AS TO ANY MATTER WHATSOEVER, INCLUDING WITHOUT 
+	LIMITATION THE CONDITION, MERCHANTABILITY, OR FITNESS FOR ANY PARTICULAR PURPOSE OF 
+	THIS SOFTWARE. OPENBASE DOES NOT ASSUME ANY LIABILITY REGARDING USE OF, OR ANY 
+	DEFECT IN, THIS SOFTWARE. IN NO EVENT SHALL OPENBASE BE LIABLE FOR ANY INDIRECT, 
+	SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, EVEN IF IT HAS BEEN ADVISED OF THE 
+	POSSIBILITY OF SUCH DAMAGE.
+
+	WARNING: MODIFY THIS SOURCE CODE AT YOUR OWN RISK.  IF YOU DON'T NEED TO MODIFY THE 
+	OPENBASE API SOURCE, WE RECOMMEND THAT YOU USE THE COMPILED LIBRARIES.
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//================================================================================
+//	Includes
+//================================================================================
+
+	#include "OpenBaseConnection.h"
+	#include "CommAPI.h"
+	#include "OpenBaseAdmin.h"
+	
+	//#ifndef _OB_COMMUNICATIONS_H
+	//#include "OB_Communications.h"
+	//#endif
+
+	#include <stdio.h>
+	#include <stdlib.h>
+	#include <string.h>
+	
+//================================================================================
+//	Implementations
+//================================================================================
+#define YIELD_THREAD 	/*YieldToAnyThread()*/
+#define OB_DEALLOC(ptr)    if (ptr) { free(ptr); ptr = NULL; }
+
+
+//--------------------------------------------------------------------------------
+//	oba_newAdminConnection
+//--------------------------------------------------------------------------------
+
+OpenBaseAdminConnection* oba_newAdminConnection(const char *hostName)
+{
+	OpenBaseAdminConnection* result = NULL;
+
+	result = (OpenBaseAdminConnection *) malloc(sizeof(OpenBaseAdminConnection));
+	if (result != NULL)
+	{
+		result->info_connection = NULL;
+    	result->connection = ob_newNetConn();
+    	if (!connectToPort(result->connection, 20221, hostName))
+    	{
+			oba_deallocAdminConnection(result);
+			result = NULL;
+			return NULL;
+    	}
+    	
+    	result->info_connection = ob_newNetConn();
+    	if (!connectToPort(result->info_connection, 20222, hostName))
+    	{
+			oba_deallocAdminConnection(result);
+			result = NULL;
+			return NULL;
+    	}
+    	
+    	strcpy(result->hostAddress,hostName);
+	}
+
+	return result;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_deallocAdminConnection
+//--------------------------------------------------------------------------------
+
+void oba_deallocAdminConnection(OpenBaseAdminConnection* admin_conn)
+{
+	if (admin_conn != NULL)
+	{
+		if (admin_conn->connection) {
+			sendExitSignal(admin_conn->connection);
+			ob_deallocNetConn(admin_conn->connection);
+			admin_conn->connection = NULL;
+		}
+		if (admin_conn->info_connection) {
+			sendExitSignal(admin_conn->info_connection);
+			ob_deallocNetConn(admin_conn->info_connection);
+			admin_conn->info_connection = NULL;
+		}
+		
+		free(admin_conn);
+	}
+}
+
+
+//--------------------------------------------------------------------------------
+//	oba_databaseHostInfo
+//--------------------------------------------------------------------------------
+
+// returns "hostname|ethernetaddress|ipaddress|OpenBaseVersion|Platform"
+
+const char *oba_databaseHostInfoString(OpenBaseAdminConnection* admin_conn)
+{
+//	int stateChangedFlag = 0;
+//	double newTimestampValue = 0.0;
+	const char* value = NULL;
+	int len = 0;
+	
+	prepareDictionary(admin_conn->info_connection);
+	addDictionaryPair(admin_conn->info_connection, "action", "hostInfo");
+	addDictionaryPair(admin_conn->info_connection, "hostAddress", admin_conn->hostAddress);
+	
+	if (sendBuffer(admin_conn->info_connection))
+	{
+		YIELD_THREAD;
+		if (readResult(admin_conn->info_connection))
+		{
+			value = resultValueForKey(admin_conn->info_connection, "result", &len);
+		}
+	}
+	
+	return value;
+}
+
+
+//--------------------------------------------------------------------------------
+//	oba_checkStatesChanged
+//--------------------------------------------------------------------------------
+
+int oba_checkStatesChanged(OpenBaseAdminConnection* admin_conn)
+{
+	int stateChangedFlag = 0;
+	double newTimestampValue = 0.0;
+	const char* value = NULL;
+	int len = 0;
+	
+	prepareDictionary(admin_conn->info_connection);
+	addDictionaryPair(admin_conn->info_connection, "action", "changeTimestamp");
+	
+	if (sendBuffer(admin_conn->info_connection))
+	{
+		YIELD_THREAD;
+		if (readResult(admin_conn->info_connection))
+		{
+			value = resultValueForKey(admin_conn->info_connection, "result", &len);
+			if (value) {
+				newTimestampValue = atof(value);
+		        if (newTimestampValue != admin_conn->lastchanged) {
+		            stateChangedFlag = 1;
+		            admin_conn->lastchanged = newTimestampValue;
+		        }
+			}
+		}
+	}
+	
+	return stateChangedFlag;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_databaseStateList
+//--------------------------------------------------------------------------------
+
+// The state string gives a list of databases that have state information and their corresponding state.
+// Databases that are not running will not be listed.
+//
+// states = "databaseName:stateString|databaseName:stateString|databaseName:stateString"
+//  -- stateString can contain % done using the format:  stateString = "cleanup%49"
+//  -- other stateStrings include: running, starting, stopping
+//
+// Alerts are used for alerting the user of an error condition in the log.  Alerts are 
+// conveyed in the following format:
+//
+// alerts = "databaseName:alert%updateNumber|databaseName:alert%updateNumber|databaseName:alert%updateNumber"
+//  -- alert can be any of: none, warning, error, severe
+//  -- updateNumber is a timestamp which changes only when there is a new error in the log since the last time we checked.
+//
+
+int oba_databaseStateList(OpenBaseAdminConnection* admin_conn, const char **states, const char **alerts)
+{
+//	int stateChangedFlag = 0;
+//	double newTimestampValue = 0.0;
+//	const char* value = NULL;
+	int len = 0;
+	
+	prepareDictionary(admin_conn->info_connection);
+	addDictionaryPair(admin_conn->info_connection, "action", "databaseStates");
+	
+	if (sendBuffer(admin_conn->info_connection))
+	{
+		YIELD_THREAD;
+		if (readResult(admin_conn->info_connection))
+		{
+			*states = resultValueForKey(admin_conn->info_connection, "result", &len);
+			*alerts = resultValueForKey(admin_conn->info_connection, "alerts", &len);
+		} else {
+			*states = NULL;
+			*alerts = NULL;
+		}
+	}
+	
+	return (*states != NULL);
+}
+
+
+//--------------------------------------------------------------------------------
+//	oba_getDatabaseList
+//--------------------------------------------------------------------------------
+
+OpenBaseDatabaseList* oba_getDatabaseList(OpenBaseAdminConnection* admin_conn, const char* read_password)
+{
+	OpenBaseDatabaseList* result = NULL;
+	int i;
+	const char* database_list = NULL;
+	int len;
+	
+	if (admin_conn != NULL)
+	{
+		result = (OpenBaseDatabaseList*) malloc(sizeof(OpenBaseDatabaseList));
+		if (result != NULL)
+		{
+			for (i = 0; i < OB_MAX_DATABASES; i++)
+			{
+				result->databases[i] = NULL;
+				result->hosts[i] = NULL;
+				result->keys[i] = NULL;
+			}
+			result->databaseCount = 0;
+			
+			//	now send the request and process it.
+			prepareDictionary(admin_conn->connection);
+			addDictionaryPair(admin_conn->connection, "action", "databaseListForHost7");
+			
+			//	does it need an ip address?? ouch!
+			//	addDictionaryPair(admin_conn->connection, "ipaddress", "");
+			
+			if ((read_password != NULL) && (strcmp(read_password, "") != 0))
+			{
+				addDictionaryPair(admin_conn->connection, "groupcode", read_password);
+			}
+			
+			if (sendBuffer(admin_conn->connection))
+			{
+				YIELD_THREAD;
+				if (readResult(admin_conn->connection))
+				{
+					database_list = resultValueForKey(admin_conn->connection, "data", &len);
+				}
+			}
+			
+			if (database_list != NULL)
+			{
+				const char* delimiters = " \t\r\n(){};,=";
+				int index = 0;
+				
+				//	format should be an array of dictionaries
+				const char* key = strtok((char*) database_list, delimiters);
+				while (key != NULL)
+				{
+					const char* value = strtok(NULL, delimiters);
+					if (value != NULL)
+					{
+						if (strcmp(key, "databaseName") == 0)
+						{
+							if (result->databases[index] != NULL)
+							{
+								index++;
+							}
+							if (index < OB_MAX_DATABASES)
+							{
+								result->databases[index] = (char *)malloc(strlen(value) + 1);
+								if (result->databases[index] != NULL)
+								{
+									strcpy(result->databases[index], value);
+								}
+							}
+						}
+						else if (strcmp(key, "hostName") == 0)
+						{
+							if (result->hosts[index] != NULL)
+							{
+								index++;
+							}
+							if (index < OB_MAX_DATABASES)
+							{
+								result->hosts[index] = (char *)malloc(strlen(value) + 1);
+								if (result->hosts[index] != NULL)
+								{
+									strcpy(result->hosts[index], value);
+								}
+							}
+						}
+						else if (strcmp(key, "key") == 0)
+						{
+							if (result->keys[index] != NULL)
+							{
+								index++;
+							}
+							if (index < OB_MAX_DATABASES)
+							{
+								result->keys[index] = (char *)malloc(strlen(value) + 1);
+								if (result->keys[index] != NULL)
+								{
+									strcpy(result->keys[index], value);
+								}
+							}
+						}
+					}
+					key = strtok(NULL, delimiters);	
+				}
+				
+				result->databaseCount = index + 1;
+				
+				/*
+				//	This just gets the raw data
+				
+				result->databases[0] = malloc(strlen(database_list) + 1);
+				if (result->databases[0] != NULL)
+				{
+					strcpy(result->databases[0], database_list);
+					result->databaseCount = 1;
+				}
+				*/
+			}
+		}
+	}
+	
+	return result;
+}
+	
+//--------------------------------------------------------------------------------
+//	oba_deallocDatabaseList
+//--------------------------------------------------------------------------------
+
+void oba_deallocDatabaseList(OpenBaseDatabaseList* database_list)
+{
+	int i;
+	
+	if (database_list != NULL)
+	{
+		for (i = 0; i < database_list->databaseCount; i++)
+		{
+			OB_DEALLOC(database_list->databases[i]);
+			OB_DEALLOC(database_list->hosts[i]);
+			OB_DEALLOC(database_list->keys[i]);
+		}
+		free(database_list);
+	}
+}
+
+//--------------------------------------------------------------------------------
+//	oba_startDatabase
+//--------------------------------------------------------------------------------
+
+int oba_startDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "startDatabase");
+    addDictionaryPair(adminConnection->connection, "databaseName", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    addDictionaryPair(adminConnection->connection, "callBack", "");
+    addDictionaryPair(adminConnection->connection, "callbackHost", "");
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_stopDatabase
+//--------------------------------------------------------------------------------
+
+int oba_stopDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password)
+{
+//    const char *returnValue = NULL;
+    int len = 0;
+    NetConn *stop_connection = NULL;
+    int connectionPort;
+    
+    if (!oba_checkHostPassword(adminConnection, password)) {
+    	printf("host password check failed when stopping database\n");
+    	return 0;
+    }
+    
+    prepareDictionary(adminConnection->info_connection);
+    addDictionaryPair(adminConnection->info_connection, "findPort", databaseName);
+    addDictionaryPair(adminConnection->info_connection, "portHost",  adminConnection->hostAddress);
+
+    sendBuffer(adminConnection->info_connection);
+    YIELD_THREAD;
+    if (!readResult(adminConnection->info_connection)) {
+        return 0;
+    }
+    if (!resultValueForKey(adminConnection->info_connection, "portNumber", &len)) {
+        return 0;
+    }
+
+	connectionPort = atoi(resultValueForKey(adminConnection->info_connection, "portNumber", &len));
+	   
+	stop_connection = ob_newNetConn();
+    if (!connectToPort(	stop_connection, connectionPort, adminConnection->hostAddress)) {
+        //printf("could not find database\n"); ��dmr
+        return 0;
+    }
+
+    // stop the database
+    prepareDictionary(stop_connection);
+    addDictionaryPair(stop_connection, "action", "call_terminate");
+    if (!sendBuffer(stop_connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    //if (!readResult(stop_connection)) {
+    //    return 0;
+    //}
+    
+	sendExitSignal(stop_connection);
+    ob_deallocNetConn(stop_connection);
+
+    return 1;
+}
+
+
+
+//--------------------------------------------------------------------------------
+//	oba_newDatabase
+//--------------------------------------------------------------------------------
+
+int oba_newDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "newDatabase");
+    addDictionaryPair(adminConnection->connection, "databaseName", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_duplicateDatabase
+//--------------------------------------------------------------------------------
+
+int oba_duplicateDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *duplicatedName,  const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "duplicateDatabase");
+    addDictionaryPair(adminConnection->connection, "databaseName", databaseName);
+    addDictionaryPair(adminConnection->connection, "duplicatedName", duplicatedName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_renameDatabase
+//--------------------------------------------------------------------------------
+
+int oba_renameDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *newDatabaseName, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "renameDatabase");
+    addDictionaryPair(adminConnection->connection, "databaseName", databaseName);
+    addDictionaryPair(adminConnection->connection, "newName", newDatabaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_moveDatabase
+//--------------------------------------------------------------------------------
+
+int oba_moveDatabase(OpenBaseAdminConnection *adminConnection, const char *sourceDatabaseName, const char *sourcePassword, const char *targetHost, const char *targetHostPassword)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "moveDatabase");
+    addDictionaryPair(adminConnection->connection, "databaseName", sourceDatabaseName);
+    addDictionaryPair(adminConnection->connection, "sourcePassword", sourcePassword);
+    addDictionaryPair(adminConnection->connection, "hostName", targetHost);
+    addDictionaryPair(adminConnection->connection, "destPassword", targetHostPassword);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_deleteDatabase
+//--------------------------------------------------------------------------------
+
+int oba_deleteDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "deleteDatabase");
+    addDictionaryPair(adminConnection->connection, "databaseName", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_checkHostPassword
+//--------------------------------------------------------------------------------
+
+int oba_checkHostPassword(OpenBaseAdminConnection *adminConnection, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "checkPassword");
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_setHostPassword
+//--------------------------------------------------------------------------------
+
+// extern void out ( const char*, const char* );
+
+int oba_setHostPassword(OpenBaseAdminConnection *adminConnection, const char *oldpassword, const char *newpassword)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setPasswordTo");
+    addDictionaryPair(adminConnection->connection, "oldPassword", oldpassword);
+    addDictionaryPair(adminConnection->connection, "newPassword", newpassword);
+    if (!sendBuffer(adminConnection->connection)){
+	//    out ( "oba_setHostPassword", "sendBuffer() failed" );
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+	//    out ( "oba_setHostPassword", "readResult() failed" );
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+
+  //  out ( "oba_setHostPassword returnValue", returnValue );
+    return 0;
+}
+
+
+//--------------------------------------------------------------------------------
+//	oba_checkReadPassword
+//--------------------------------------------------------------------------------
+
+int oba_checkReadPassword(OpenBaseAdminConnection *adminConnection, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "checkReadPassword");
+    addDictionaryPair(adminConnection->connection, "groupCode", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_setReadPassword
+//--------------------------------------------------------------------------------
+
+int oba_setReadPassword(OpenBaseAdminConnection *adminConnection, const char *hostpassword, const char *new_read_password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setReadPasswordTo");
+    addDictionaryPair(adminConnection->connection, "hostCode", new_read_password);
+    addDictionaryPair(adminConnection->connection, "password", hostpassword);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_setEncodingForDatabase
+//--------------------------------------------------------------------------------
+
+int oba_setEncodingForDatabase(OpenBaseAdminConnection *adminConnection, const char *database, const char *encoding, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setEncoding");
+    addDictionaryPair(adminConnection->connection, "database", database);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    addDictionaryPair(adminConnection->connection, "encoding", encoding);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+
+//--------------------------------------------------------------------------------
+//	oba_encodingForDatabase
+//--------------------------------------------------------------------------------
+
+int oba_encodingForDatabase(OpenBaseAdminConnection *adminConnection, const char *database, char **encoding, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "getEncoding");
+    addDictionaryPair(adminConnection->connection, "password", password);
+    addDictionaryPair(adminConnection->connection, "database", database);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue) {
+    	strcpy(*encoding, returnValue);
+        return 1;
+    }
+    return 0;
+}
+
+
+//--------------------------------------------------------------------------------
+//	oba_databaseDescription
+//--------------------------------------------------------------------------------
+
+int oba_databaseDescription(OpenBaseAdminConnection *adminConnection, const char *databaseName, char **databaseDescription, char **bubbleColor, char **size)
+{
+//    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "getDescriptionForDatabase");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    *databaseDescription = resultValueForKey(adminConnection->connection, "databaseDescription", &len);
+    *bubbleColor = resultValueForKey(adminConnection->connection, "bubbleColor", &len);
+    *size = resultValueForKey(adminConnection->connection, "databaseSize", &len);
+
+    return 1;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_setDatabaseDescription
+//--------------------------------------------------------------------------------
+
+int oba_setDatabaseDescription(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password, const char *description, const char *bubbleColor)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setDescriptionForDatabase");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    addDictionaryPair(adminConnection->connection, "textColor", "black");
+    addDictionaryPair(adminConnection->connection, "bubbleColor", bubbleColor);
+    addDictionaryPair(adminConnection->connection, "databaseDescription", description);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+
+//--------------------------------------------------------------------------------
+//	oba_autoStartDatabaseList
+//--------------------------------------------------------------------------------
+
+// BTW, the password is the host password
+// The purpose of this routine is to return the list of databases that start up at boot time.
+// result = "databaseName|databaseName|databaseName"
+
+const char *oba_autoStartDatabaseList(OpenBaseAdminConnection *adminConnection, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "autostartArray");
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return NULL;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "autostartArray", &len);
+
+    return returnValue;
+}
+
+
+//--------------------------------------------------------------------------------
+//	oba_setAutoStartDatabase
+//--------------------------------------------------------------------------------
+
+int oba_setAutoStartDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password, const char *yn)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setAutoStart");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    addDictionaryPair(adminConnection->connection, "yn", yn?"1":"0");
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_getLogFile
+//--------------------------------------------------------------------------------
+
+const char *oba_getLogFile(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "getLogfile");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return NULL;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return NULL;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "data", &len);
+ 
+    return returnValue;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_getServerMacAddress
+//--------------------------------------------------------------------------------
+
+const char *oba_getServerMacAddress(OpenBaseAdminConnection *adminConnection)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "getMacAddress");
+    if (!sendBuffer(adminConnection->connection)){
+        return NULL;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return NULL;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "data", &len);
+ 
+    return returnValue;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_getDatabasePreferences
+//--------------------------------------------------------------------------------
+
+int oba_getDatabasePreferences(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password,
+		const char **sortChars,
+		const char **sortCharsCaps,
+		const char **moneyPostfix,
+		const char **moneyPrefix,
+		const char **date,
+		const char **time,
+		const char **logSQL,
+		const char **logSQLFile,
+		const char **compressedBackup,
+		const char **compressedBackupTime,
+		const char **compressedBackupDay,
+		const char **compressedBackupDirectory,
+		const char **asciiBackup,
+		const char **asciiBackupTime,
+		const char **asciiBackupDay,
+		const char **asciiBackupDirectory,
+		const char **createClientMirror,
+		const char **createMasterMirror,
+		const char **clientClusterName,
+		const char **masterClusterName)
+{
+//    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "preferencesForDatabase");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+
+    *sortChars = resultValueForKey(adminConnection->connection, "SortChars", &len);
+    *sortCharsCaps = resultValueForKey(adminConnection->connection, "SortCharsCaps", &len);
+    *moneyPostfix = resultValueForKey(adminConnection->connection, "MoneyPostfix", &len);
+    *moneyPrefix = resultValueForKey(adminConnection->connection, "MoneyPrefix", &len);
+    *date = resultValueForKey(adminConnection->connection, "Date", &len);
+    *time = resultValueForKey(adminConnection->connection, "Time", &len);
+    *logSQL = resultValueForKey(adminConnection->connection, "LogSQL", &len);
+    *logSQLFile = resultValueForKey(adminConnection->connection, "LogSQLFile", &len);
+    *compressedBackup = resultValueForKey(adminConnection->connection, "compressedBackup", &len);
+    *compressedBackupTime = resultValueForKey(adminConnection->connection, "compressedBackupTime", &len);
+    *compressedBackupDay = resultValueForKey(adminConnection->connection, "compressedBackupDay", &len);
+    *compressedBackupDirectory = resultValueForKey(adminConnection->connection, "compressedBackupDirectory", &len);
+    *asciiBackup = resultValueForKey(adminConnection->connection, "asciiBackup", &len);
+    *asciiBackupTime = resultValueForKey(adminConnection->connection, "asciiBackupTime", &len);
+    *asciiBackupDay = resultValueForKey(adminConnection->connection, "asciiBackupDay", &len);
+    *asciiBackupDirectory = resultValueForKey(adminConnection->connection, "asciiBackupDirectory", &len);
+    *createClientMirror = resultValueForKey(adminConnection->connection, "createClientMirror", &len);
+    *createMasterMirror = resultValueForKey(adminConnection->connection, "createMasterMirror", &len);
+    *clientClusterName = resultValueForKey(adminConnection->connection, "clientClusterName", &len);
+    *masterClusterName = resultValueForKey(adminConnection->connection, "masterClusterName", &len);
+    
+    return 1;
+}
+
+
+//--------------------------------------------------------------------------------
+//	oba_setDatabasePreferences
+//--------------------------------------------------------------------------------
+
+int oba_setDatabasePreferences(OpenBaseAdminConnection *adminConnection, const char *databaseName, 
+		const char *password,
+		const char *sortChars,
+		const char *sortCharsCaps,
+		const char *moneyPostfix,
+		const char *moneyPrefix,
+		const char *date,
+		const char *time,
+		const char *logSQL,
+		const char *logSQLFile,
+		const char *compressedBackup,
+		const char *compressedBackupTime,
+		const char *compressedBackupDay,
+		const char *compressedBackupDirectory,
+		const char *asciiBackup,
+		const char *asciiBackupTime,
+		const char *asciiBackupDay,
+		const char *asciiBackupDirectory,
+		
+		const char *createClientMirror,
+		const char *createMasterMirror,
+		const char *clientClusterName,
+		const char *masterClusterName,
+		
+		const char *dbSerialNumber,
+		const char *dbAuthorization)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setPreferencesForDatabase");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (sortChars) addDictionaryPair(adminConnection->connection, "SortChars", sortChars);
+    if (sortCharsCaps) addDictionaryPair(adminConnection->connection, "SortCharsCaps", sortCharsCaps);
+    if (moneyPostfix) addDictionaryPair(adminConnection->connection, "MoneyPostfix", moneyPostfix);
+    if (moneyPrefix) addDictionaryPair(adminConnection->connection, "MoneyPrefix", moneyPrefix);
+    if (date) addDictionaryPair(adminConnection->connection, "Date", date);
+    if (time) addDictionaryPair(adminConnection->connection, "Time", time);
+    if (logSQL) addDictionaryPair(adminConnection->connection, "LogSQL", logSQL);
+    if (logSQLFile) addDictionaryPair(adminConnection->connection, "LogSQLFile", logSQLFile);
+    if (compressedBackup) addDictionaryPair(adminConnection->connection, "compressedBackup", compressedBackup);
+    if (compressedBackupTime) addDictionaryPair(adminConnection->connection, "compressedBackupTime", compressedBackupTime);
+    if (compressedBackupDay) addDictionaryPair(adminConnection->connection, "compressedBackupDay", compressedBackupDay);
+    if (compressedBackupDirectory) addDictionaryPair(adminConnection->connection, "compressedBackupDirectory", compressedBackupDirectory);
+    
+    if (asciiBackup) addDictionaryPair(adminConnection->connection, "asciiBackup", asciiBackup);
+    if (asciiBackupTime) addDictionaryPair(adminConnection->connection, "asciiBackupTime", asciiBackupTime);
+    if (asciiBackupDay) addDictionaryPair(adminConnection->connection, "asciiBackupDay", asciiBackupDay);
+    if (asciiBackupDirectory) addDictionaryPair(adminConnection->connection, "asciiBackupDirectory", asciiBackupDirectory);
+    
+    if (createClientMirror) addDictionaryPair(adminConnection->connection, "createClientMirror", createClientMirror);
+    if (createMasterMirror) addDictionaryPair(adminConnection->connection, "createMasterMirror", createMasterMirror);
+    if (clientClusterName) addDictionaryPair(adminConnection->connection, "clientClusterName", clientClusterName);
+    if (masterClusterName) addDictionaryPair(adminConnection->connection, "masterClusterName", masterClusterName);
+
+    if (dbSerialNumber) addDictionaryPair(adminConnection->connection, "RegSerialNumber", dbSerialNumber);
+    if (dbAuthorization) addDictionaryPair(adminConnection->connection, "RegAuthorization", dbAuthorization);
+    
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+ 
+    return returnValue && (strcmp(returnValue,"succeed") == 0);
+}
+
+
+
+//--------------------------------------------------------------------------------
+//	oba_getInitializationForCluster
+//--------------------------------------------------------------------------------
+
+int oba_getInitializationForCluster(OpenBaseAdminConnection *adminConnection, 
+		const char *databaseName, const char *clusterName, 
+		char **targetDatabase, char **targetHost,
+	 	char **targetUser, char **targetPassword, 
+		int *frequency, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "getInitializationForCluster");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    addDictionaryPair(adminConnection->connection, "cluster", clusterName);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    *targetDatabase = resultValueForKey(adminConnection->connection, "targetDatabase", &len);
+    if (!*targetDatabase) {
+    	return 0;
+    }
+    *targetHost = resultValueForKey(adminConnection->connection, "targetHost", &len);
+    *targetUser = resultValueForKey(adminConnection->connection, "targetUser", &len);
+    *targetPassword = resultValueForKey(adminConnection->connection, "targetPassword", &len);
+    returnValue = resultValueForKey(adminConnection->connection, "frequency", &len);
+    if (*returnValue) {
+    	*frequency = atoi(returnValue);
+    }
+    
+    return 1;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_setInitializationForCluster
+//--------------------------------------------------------------------------------
+
+int oba_setInitializationForCluster(OpenBaseAdminConnection *adminConnection, 
+		const char *databaseName, const char *clusterName, 
+		const char *targetDatabase, const char *targetHost,
+		const char *targetUser, const char *targetPassword, 
+		int frequency, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setInitializationForCluster");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "targetDatabase", targetDatabase);
+    addDictionaryPair(adminConnection->connection, "targetHost", targetHost);
+    addDictionaryPair(adminConnection->connection, "targetUser", targetUser);
+    addDictionaryPair(adminConnection->connection, "targetPassword", targetPassword);
+    {
+    	char buffer[256];
+    	sprintf(buffer, "%d",frequency);
+    	addDictionaryPair(adminConnection->connection, "frequency", buffer);
+    }
+    
+    addDictionaryPair(adminConnection->connection, "cluster", clusterName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+
+//--------------------------------------------------------------------------------
+//	oba_createClusterFile
+//--------------------------------------------------------------------------------
+
+int oba_createClusterFile(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *clusterName, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "createClusterFile");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    addDictionaryPair(adminConnection->connection, "cluster", clusterName);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+
+    return returnValue && (strcmp(returnValue,"succeed") == 0);
+}
+
+//--------------------------------------------------------------------------------
+//	oba_removeCluster
+//--------------------------------------------------------------------------------
+
+int oba_removeCluster(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *clusterName, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "removeCluster");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    addDictionaryPair(adminConnection->connection, "cluster", clusterName);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+
+    return returnValue && (strcmp(returnValue,"succeed") == 0);
+}
+
+//--------------------------------------------------------------------------------
+//	oba_clearCluster
+//--------------------------------------------------------------------------------
+
+int oba_clearCluster(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *clusterName, const char *password)
+{
+	if (!oba_removeCluster(adminConnection, databaseName, clusterName, password) ) {
+		return 0;
+	}
+	if (!oba_createClusterFile(adminConnection, databaseName, clusterName, password) ) {
+		return 0;
+	}
+	
+	return 1;
+}
+
+
+
+
+//--------------------------------------------------------------------------------
+//	oba_encryptionForDatabase
+//--------------------------------------------------------------------------------
+
+int oba_encryptionForDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "getEncryption");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+
+    return returnValue && (strcmp(returnValue,"YES") == 0);
+}
+
+//--------------------------------------------------------------------------------
+//	oba_setEncryptionForDatabase
+//--------------------------------------------------------------------------------
+
+int oba_setEncryptionForDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password, int yn)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setEncryption");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (yn) {
+    	addDictionaryPair(adminConnection->connection, "encryption", "YES");
+    } else {
+    	addDictionaryPair(adminConnection->connection, "encryption", "NO");
+    }
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_portNumberForDatabase
+//--------------------------------------------------------------------------------
+
+int oba_portNumberForDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "getPortNumber");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+
+    return atoi(returnValue);
+}
+
+//--------------------------------------------------------------------------------
+//	oba_setPortNumberForDatabase
+//--------------------------------------------------------------------------------
+
+int oba_setPortNumberForDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password, int port)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    char theBuffer[256];
+
+    sprintf(theBuffer, "%d", port);
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setPortNumber");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    addDictionaryPair(adminConnection->connection, "portNumber", theBuffer);
+ 
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_notificationForDatabase
+//--------------------------------------------------------------------------------
+
+int oba_notificationForDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "getNotification");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+
+    return atoi(returnValue);
+}
+
+//--------------------------------------------------------------------------------
+//	oba_setNotificationForDatabase
+//--------------------------------------------------------------------------------
+
+int oba_setNotificationForDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password, int notify)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    char theBuffer[256];
+
+    sprintf(theBuffer, "%d", notify);
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setNotification");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    addDictionaryPair(adminConnection->connection, "notify", theBuffer);
+ 
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_distributedKeyForDatabase
+//--------------------------------------------------------------------------------
+
+int oba_distributedKeyForDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password, int *databaseKey, int *multiplier)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "getDistributedKey");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+	*databaseKey = atoi(returnValue);
+	
+    returnValue = resultValueForKey(adminConnection->connection, "multiplier", &len);
+	*multiplier = atoi(returnValue);
+	
+    return atoi(returnValue);
+}
+
+//--------------------------------------------------------------------------------
+//	oba_setDistributedKeyForDatabase
+//--------------------------------------------------------------------------------
+
+int oba_setDistributedKeyForDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password, int databaseKey, int multiplier)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    char theBuffer[256];
+
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setDistributedKey");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    sprintf(theBuffer, "%d", databaseKey);
+    addDictionaryPair(adminConnection->connection, "hostkey", theBuffer);
+    sprintf(theBuffer, "%d", multiplier);
+    addDictionaryPair(adminConnection->connection, "multiplier", theBuffer);
+ 
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+
+//--------------------------------------------------------------------------------
+//	oba_transactionTimeouts
+//--------------------------------------------------------------------------------
+
+int oba_transactionTimeout(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password, int *trans_timeout, int *connect_timeout)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "getTransactionTimeout");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "transTimeout", &len);
+	*trans_timeout = atoi(returnValue);
+	
+    returnValue = resultValueForKey(adminConnection->connection, "connTimeout", &len);
+	*connect_timeout = atoi(returnValue);
+	
+    return atoi(returnValue);
+}
+
+//--------------------------------------------------------------------------------
+//	oba_setTransactionTimeout
+//--------------------------------------------------------------------------------
+
+int oba_setTransactionTimeout(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password, int trans_timeout, int connect_timeout)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+    char theBuffer[256];
+
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setTransactionTimeout");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    sprintf(theBuffer, "%d", trans_timeout);
+    addDictionaryPair(adminConnection->connection, "transTimeout", theBuffer);
+    sprintf(theBuffer, "%d", connect_timeout);
+    addDictionaryPair(adminConnection->connection, "connTimeout", theBuffer);
+ 
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_isSimulationModeOnForDatabase
+//--------------------------------------------------------------------------------
+
+int oba_isSimulationModeOnForDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password) 
+{
+    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "isSimulationModeOnForDatabase");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+
+    return returnValue && (strcmp(returnValue,"yes") == 0);
+}
+
+//--------------------------------------------------------------------------------
+//	setSimulationMode
+//--------------------------------------------------------------------------------
+
+int oba_setSimulationMode(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password, int yn)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setSimulationMode");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (yn) {
+	    addDictionaryPair(adminConnection->connection, "yn", "1");
+    } else {
+    	addDictionaryPair(adminConnection->connection, "yn", "0");
+    }
+     
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_isNoDeleteModeOnForDatabase
+//--------------------------------------------------------------------------------
+
+int oba_isNoDeleteModeOnForDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password) 
+{
+    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "isNoDeleteModeOnForDatabase");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+
+    return returnValue && (strcmp(returnValue,"yes") == 0);
+}
+
+//--------------------------------------------------------------------------------
+//	ob_setNoDeleteMode
+//--------------------------------------------------------------------------------
+
+int oba_setNoDeleteMode(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password, int yn)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setNoDeleteMode");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (yn) {
+	    addDictionaryPair(adminConnection->connection, "yn", "1");
+    } else {
+    	addDictionaryPair(adminConnection->connection, "yn", "0");
+    }
+     
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+
+//--------------------------------------------------------------------------------
+//	oba_isSafeSQLModeForDatabase
+//--------------------------------------------------------------------------------
+
+int oba_isSafeSQLModeForDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password) 
+{
+    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "isSafeSQLModeForDatabase");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+
+    return returnValue && (strcmp(returnValue,"yes") == 0);
+}
+
+//--------------------------------------------------------------------------------
+//	oba_setSafeSQLMode
+//--------------------------------------------------------------------------------
+
+int oba_setSafeSQLMode(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password, int yn)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setSafeSQLMode");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (yn) {
+	    addDictionaryPair(adminConnection->connection, "yn", "1");
+    } else {
+    	addDictionaryPair(adminConnection->connection, "yn", "0");
+    }
+     
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_automaticTriggerFileForDatabase
+//--------------------------------------------------------------------------------
+
+const char *oba_automaticTriggerFileForDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password) 
+{
+    const char *returnValue = NULL;
+    int len = 0;
+        
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "automaticFile");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+
+    return returnValue;
+}
+
+//--------------------------------------------------------------------------------
+//	oba_setAutomaticTriggerFileForDatabase
+//--------------------------------------------------------------------------------
+
+int oba_setAutomaticTriggerFileForDatabase(OpenBaseAdminConnection *adminConnection, const char *databaseName, const char *password, const char *filecontent)
+{
+    const char *returnValue = NULL;
+    int len = 0;
+
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "setAutomaticFile");
+    addDictionaryPair(adminConnection->connection, "database", databaseName);
+    addDictionaryPair(adminConnection->connection, "password", password);
+    addDictionaryPair(adminConnection->connection, "automatic", filecontent);
+         
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 0;
+    }
+    returnValue = resultValueForKey(adminConnection->connection, "result", &len);
+    if (returnValue && (strcmp(returnValue,"succeed") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
+
+
+
+//--------------------------------------------------------------------------------
+//	oba_restartProcesses
+//--------------------------------------------------------------------------------
+
+int oba_restartProcesses(OpenBaseAdminConnection *adminConnection, const char *password)
+{
+//    const char *returnValue = NULL;
+//    int len = 0;
+
+    
+    prepareDictionary(adminConnection->connection);
+    addDictionaryPair(adminConnection->connection, "action", "restart");
+    addDictionaryPair(adminConnection->connection, "password", password);
+ 
+    if (!sendBuffer(adminConnection->connection)){
+        return 0;
+    }
+    
+    YIELD_THREAD;
+    
+    if (!readResult(adminConnection->connection)) {
+        return 1;
+    }
+    return 1;
+}
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+
+
+
+
+
+
+
+
+