openbase 0.8.1

data/History.txt

@@ -0,0 +1,50 @@
+=== 0.8.1
+
+* Converted the project to a rubygem using hoe & newgem
+* Renamed README to README.txt for Hoe compatibility
+* Renamed CHANGES to History.txt for Hoe compatibility
+* Adjusted initialization routine for OpenBaseResult objects to prevent a certain memory error
+
+
+=== 0.8.0
+
+Maintenance of this library is now being handled by Derrick Spell (derrick.spell@gmail.com)
+
+* Complete rewrite of library in C
+* now returns money columns as ruby BigDecimal
+
+
+=== 0.7.3
+
+I received patches from Yuichi Fujishige and Derrick Spell. Thank you!
+
+* Implemented OpenBase#insert_binary.
+* Fixed memory bugs.
+* Changed return value type of unique_row_id() to number.
+* Changed to convert NULL to nil.
+* Fixed to convert integer type records correctly.
+
+
+=== 0.7.2
+
+* Added the following methods.
+    * OpenBase#tables
+    * OpenBase#columns,
+    * OpenBase#relationships
+    * OpenBaseResult#free
+* Supports the following data types.
+    * boolean
+    * binary
+    * text
+    * timestamp 
+
+
+=== 0.7.1
+
+* fixed to return value of money type as string.
+
+
+=== 0.7.0
+
+first release.
+

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Derrick Spell
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,53 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+examples/example.rb
+ext/CommAPI.c
+ext/Headers/CommAPI.h
+ext/Headers/NetClient.h
+ext/Headers/NetClientLib.h
+ext/Headers/OB_Memory.h
+ext/Headers/OpenBaseAdmin.h
+ext/Headers/OpenBaseConnection.h
+ext/Headers/OpenBaseEncoding.h
+ext/Headers/OpenBasePrepare.h
+ext/Headers/OpenBaseSupport.h
+ext/Headers/Platform_Carbon_Header.h
+ext/Headers/Platform_Classic_Header.h
+ext/Headers/Platform_Linux.h
+ext/Headers/Platform_Mach_Header.h
+ext/Headers/Platform_Windows.h
+ext/Headers/conversion.h
+ext/Headers/datetime.h
+ext/Headers/longlong.h
+ext/Headers/platform.h
+ext/Headers/stringConversion.h
+ext/NetClient.c
+ext/OpenBaseAdmin.c
+ext/OpenBaseConnection.c
+ext/OpenBaseEncoding.c
+ext/OpenBaseEncoding_DOS.c
+ext/OpenBaseEncoding_ISO8859.c
+ext/OpenBaseEncoding_MacOS.c
+ext/OpenBaseEncoding_Windows.c
+ext/OpenBasePrepare.c
+ext/OpenBaseSupport.c
+ext/conversion.c
+ext/datetime.c
+ext/depend
+ext/extconf.rb
+ext/longlong.c
+ext/openbase.c
+ext/stringConversion.c
+lib/ruby-openbase/version.rb
+scripts/txt2html
+setup.rb
+test/test_helper.rb
+test/test_openbase.rb
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.rhtml

data/README.txt

@@ -0,0 +1,35 @@
+= Ruby/OpenBase - OpenBase Connectivity for Ruby
+
+== What's Ruby/OpenBase?
+
+Ruby/OpenBase is a ruby extension library to access OpenBase database from Ruby.
+
+
+== Requirements
+
+Version 0.8 of Ruby/OpenBase has the following requirements:
+* Ruby 1.8.4 or later
+* OpenBase 10.0.6 or later
+* Mac OS X 10.4 or later
+
+
+== Installation
+
+  % ruby setup.rb config
+  % ruby setup.rb setup
+  % sudo ruby setup.rb install
+
+
+== License
+
+Ruby/OpenBase is a free software distributed under the BSD license.
+
+
+== Author
+
+C translation and current maintenance provided by:
+Derrick Spell <derrick.spell@gmail.com>
+
+Original Cocoa library written by:
+SUZUKI Tetsuya <suzuki@spice-of-life.net>
+

data/Rakefile

@@ -0,0 +1,126 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require 'hoe'
+
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'ruby-openbase','version')
+
+AUTHOR = 'Derrick Spell'  # can also be an array of Authors
+EMAIL = "derrick.spell@gmail.com"
+DESCRIPTION = "Provides access to OpenBase databases from Ruby."
+GEM_NAME = 'openbase' # what ppl will type to install your gem
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}"
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  @rubyforge_username ||= @config["username"]
+end
+
+RUBYFORGE_PROJECT = 'ruby-openbase' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+NAME = "openbase"
+REV = nil 
+# UNCOMMENT IF REQUIRED: 
+# REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
+VERS = RubyOpenBase::VERSION::STRING + (REV ? ".#{REV}" : "")
+CLEAN.include ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']
+RDOC_OPTS = ['--quiet', '--title', 'ruby-openbase documentation',
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject { |x| Array(x).first == 'hoe' } 
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= CLEAN  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  #p.extra_deps = []     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  p.spec_extras = { # A hash of extra values to set in the gemspec.
+    :extensions => ["ext/extconf.rb"],
+    :autorequire => "openbase"
+  }    
+end
+
+CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\n\n")
+PATH    = RUBYFORGE_PROJECT
+hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+
+desc 'Generate website files'
+task :website_generate do
+  Dir['website/**/*.txt'].each do |txt|
+    sh %{ ruby scripts/txt2html #{txt} > #{txt.gsub(/txt$/,'html')} }
+  end
+end
+
+desc 'Upload website files to rubyforge'
+task :website_upload do
+  host = "#{rubyforge_username}@rubyforge.org"
+  remote_dir = "/var/www/gforge-projects/#{PATH}/"
+  local_dir = 'website'
+  sh %{rsync -aCv #{local_dir}/ #{host}:#{remote_dir}}
+end
+
+desc 'Generate and upload website files'
+task :website => [:website_generate, :website_upload, :publish_docs]
+
+desc 'Release the website and new gem version'
+task :deploy => [:check_version, :website, :release] do
+  puts "Remember to create SVN tag:"
+  puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " +
+    "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} "
+  puts "Suggested comment:"
+  puts "Tagging release #{CHANGES}"
+end
+
+desc 'Runs tasks website_generate and install_gem as a local deployment of the gem'
+task :local_deploy => [:website_generate, :install_gem]
+
+task :check_version do
+  unless ENV['VERSION']
+    puts 'Must pass a VERSION=x.y.z release version'
+    exit
+  end
+  unless ENV['VERSION'] == VERS
+    puts "Please update your version.rb to match the release version, currently #{VERS}"
+    exit
+  end
+end
+
+

data/examples/example.rb

@@ -0,0 +1,37 @@
+$LOAD_PATH.unshift('ext')
+require 'openbase'
+
+# connects to database
+ob = OpenBase.new('OBMovies', 'localhost', 'admin', '')
+
+# scheme information
+puts "* encoding = #{ob.encoding}"
+tables = ob.tables
+tables.reject! { |t| /\A_SYS_/ === t }
+puts "* tables = #{tables.join(', ')}"
+puts "* columns of MOVIE = #{ob.columns('MOVIE').join(', ')}"
+puts "* relationships of MOVIE = #{ob.relationships('MOVIE').join(', ')}"
+
+# insert binary
+blob = '12345'
+puts
+print "* insert binary '#{blob}' for "
+key = ob.insert_binary(blob)
+puts key
+
+# execute SQL statement
+result = ob.execute "select t0.TITLE, t0.REVENUE, t1.NAME from MOVIE t0, STUDIO t1 where t0.STUDIO_ID = t1.STUDIO_ID order by t0.REVENUE ASC"
+
+# show each row
+puts
+puts "* show infomation for the columns"
+result.column_infos.each do |info|
+  puts "** #{info.table}.#{info.name} = #{info.type}"
+end
+
+puts
+puts "* show rows"
+result.each do |row|
+  p row
+end
+

data/ext/CommAPI.c

@@ -0,0 +1,643 @@
+// ------------------------------------------------------------------------------
+// 
+// Copyright (c) 1996-2006 OpenBase International Ltd.
+// All rights reserved.
+//
+// ------------------------------------------------------------------------------
+#include "platform.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "CommAPI.h"
+#include "OB_Memory.h"
+
+#if MACOSX_CARBON 
+	#include <strings.h>
+	#include <OpenTransport.h>
+#endif
+
+#ifdef WINNT
+	#include <wtypes.h>
+#endif
+
+#ifdef MACOSX_UNIX
+	#include <sys/socket.h>
+#endif
+
+#include "NetClient.h"
+#include "OpenBaseConnection.h"
+#include "OpenBaseSupport.h"
+
+
+#define DISABLE_PRIVATE_TRANSMISSION
+
+int _readDictionary(NetConnPtr conn);
+
+int _readData(NetConnPtr conn);
+
+// ------------------------------------------------------------------------------------------
+
+#ifdef MACOS_CARBON
+
+	#ifdef TARGET_API_MAC_CARBON
+	char* MapAddressToName ( char* ipAddress, char* domainName, 
+							OTClientContextPtr outClientContext)
+	#else
+	char* MapAddressToName ( char* ipAddress, char* domainName, OTClientContextPtr)
+	#endif
+
+	{
+	domainName[0] = '\0'; // assume failure
+	OSStatus err;
+
+	#ifdef TARGET_API_MAC_CARBON
+		InetSvcRef isRef = OTOpenInternetServicesInContext( kDefaultInternetServicesPath, 
+															0, &err, outClientContext);
+	#else
+		InetSvcRef isRef = OTOpenInternetServices(kDefaultInternetServicesPath, 0, &err);
+	#endif
+
+	if (!err)
+	{
+		InetHost ipAddr;
+		err = OTInetStringToHost(ipAddress,&ipAddr);
+		if (!err)
+		{
+			err = OTInetAddressToName(isRef,ipAddr,domainName);
+			if (err) domainName[0] = '\0'; // failure was indicated
+		}
+	}
+	return domainName;
+}
+
+#ifdef TARGET_API_MAC_CARBON
+char* MapNameToAddress ( char* domainName, char* ipAddress, 
+						 OTClientContextPtr outClientContext)
+#else
+char* MapNameToAddress ( char* domainName, char* ipAddress, OTClientContextPtr)
+#endif
+{
+	ipAddress[0] = '\0'; // assume failure
+	OSStatus err;
+
+#ifdef TARGET_API_MAC_CARBON
+	InetSvcRef isRef = OTOpenInternetServicesInContext( kDefaultInternetServicesPath, 
+														0, &err, outClientContext);
+#else
+	InetSvcRef isRef = OTOpenInternetServices(kDefaultInternetServicesPath, 0, &err);
+#endif
+	if (!err)
+	{
+		InetHostInfo hinfo;
+		err = OTInetStringToAddress(isRef,domainName,&hinfo);
+		if (!err) OTInetHostToString(hinfo.addrs[0],ipAddress);
+	}
+	return ipAddress;
+}
+
+// ------------------------------------------------------------------------------------------
+#else
+#ifdef WINNT
+
+char* MapNameToAddress ( char* domainName, char* ipAddress )
+{
+    unsigned long ulAddr;
+    struct hostent *hostEntP;
+
+    ipAddress[0] = '\0'; // assume failure
+
+    ulAddr = inet_addr((char*)domainName);
+
+    if (ulAddr != ((unsigned long)-1)) {
+        strcpy(ipAddress, domainName);
+    } else {
+        hostEntP = gethostbyname((char*)domainName);
+        if ((hostEntP != NULL) && (hostEntP->h_addr_list != NULL)) {
+            char* address_ptr = hostEntP->h_addr_list[0];
+            if (address_ptr != NULL) {
+                char* address = inet_ntoa(*(in_addr*) address_ptr);
+                if (address != NULL) {
+                        strcpy(ipAddress, address);
+                }
+            }
+        }
+    }
+
+    return ipAddress;
+}
+
+#endif
+#endif
+
+
+// ------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------
+
+int connectToPort(NetConnPtr conn, int portNumber,const char *hostName)
+{
+#ifdef MACOS_CARBON
+    EndpointRef     ret = kOTInvalidEndpointRef;
+	TBind			server_info;
+	TBind			client_info;
+	unsigned char	server_address[256];
+	unsigned char	client_address[256];
+	OSStatus		err = noErr;
+
+	server_info.addr.maxlen = 256;
+	server_info.addr.buf = server_address;
+	client_info.addr.maxlen = 256;
+	client_info.addr.buf = client_address;
+#else 
+
+#ifdef WINNT
+	struct sockaddr_in	client_address;			//	internet style socket address
+	struct sockaddr_in	server_address;			//	internet style socket address
+#else
+	struct sockaddr	*client_address;			//	internet style socket address
+	struct sockaddr	*server_address;			//	internet style socket address
+#endif
+	int ret = -1;
+//	int client_len;
+//	int server_len;
+#endif
+	
+
+#ifdef MACOS_CARBON
+    ret = netConnect(portNumber, hostName, conn->outClientContext);
+    if (ret == kOTInvalidEndpointRef) 
+    {
+    	conn->socketConnection = kOTInvalidEndpointRef;	// ��dmr
+        return 0;
+    }
+    conn->socketConnection = ret;
+#else 
+    ret = netConnect(portNumber, hostName);
+    if (ret == -1) {
+        return 0;
+    }
+    conn->socketConnection = (int)ret;
+#endif
+
+#ifdef MACOS_CARBON
+	err = OTGetProtAddress(conn->socketConnection, &client_info, &server_info);
+	if (err == noErr) 
+	{
+		sprintf(conn->serverAddress, "%u.%u.%u.%u", server_address[4],
+					server_address[5], server_address[6], server_address[7]);
+		sprintf(conn->clientAddress, "%u.%u.%u.%u", client_address[4],
+					client_address[5], client_address[6], client_address[7]);
+	}
+#endif
+
+#ifdef WINNT
+	client_len = sizeof(client_address);
+	if (getsockname(conn->socketConnection, (struct sockaddr*) &client_address, &client_len) == 0) {
+		sprintf(conn->clientAddress, "%u.%u.%u.%u",
+					client_address.sin_addr.S_un.S_un_b.s_b1,
+					client_address.sin_addr.S_un.S_un_b.s_b2,
+					client_address.sin_addr.S_un.S_un_b.s_b3,
+					client_address.sin_addr.S_un.S_un_b.s_b4	);
+					
+	} else {
+            sprintf(conn->clientAddress, "Error...");
+	}
+
+	server_len = sizeof(server_address);
+	if (getpeername(conn->socketConnection, (struct sockaddr*) &server_address, &server_len) == 0) {
+		sprintf(conn->serverAddress, "%u.%u.%u.%u",
+					server_address.sin_addr.S_un.S_un_b.s_b1,
+					server_address.sin_addr.S_un.S_un_b.s_b2,
+					server_address.sin_addr.S_un.S_un_b.s_b3,
+					server_address.sin_addr.S_un.S_un_b.s_b4	);
+	} else {
+            sprintf(conn->clientAddress, "Error...");
+	}
+#endif
+    
+    return syncronizeVersion(conn);
+}
+
+// ------------------------------------------------------------------------------------------
+
+// clearing data
+void initComm(NetConnPtr conn)
+{
+    int ct;
+
+    for (ct = 0; ct < OB_MAX_KEYS; ct++) { 
+        conn->resultKeys[ct] 		= NULL;
+        conn->keyBufferSize[ct] 	= 0;
+        conn->resultValues[ct] 		= NULL;
+        conn->valueBufferSize[ct] 	= 0;
+        conn->resultLength[ct] 		= 0;
+    }
+
+    conn->didInit = YES;
+
+    conn->privateConnection = NO;
+}
+
+// ------------------------------------------------------------------------------------------
+
+void clearComm(NetConnPtr conn)
+{
+if (0 == conn->didInit) 
+	initComm(conn);
+}
+
+
+// ------------------------------------------------------------------------------------------
+
+int ob_copyAndFixString(unsigned char **tostring, int *tosize, int position, const unsigned char *str, int length, unsigned char *codedmap)
+{
+    char *strdest;
+
+    // make sure the string is long enough
+    if ((length + position) > (*tosize - 10)) {
+        *tosize = *tosize * 2;
+        // if doubling size isn't enough
+        if ((length + position) > (*tosize - 10)) {
+            *tosize = (length + position + 10);
+        }
+        //	*tostring = (unsigned char *)realloc(*tostring, *tosize);
+        *tostring = (unsigned char *)ob_realloc(*tostring, *tosize);
+    }
+
+    strdest = (char *)*tostring + position;
+
+    // copy the size of the string to the buffer
+    ob_intToBytes((unsigned char *)strdest, length);
+    strdest = strdest + sizeof(int);
+
+    // copy the string itself to the buffer
+    if (!codedmap) {
+        memcpy(strdest, str, length);
+    } else { // encode during copy
+        int ct;
+
+        for (ct=0; ct != length; ct++) {
+            strdest[ct] = codedmap[(unsigned int)str[ct]];
+        }
+    }
+    strdest[length] = '\0';
+    //printf("SEND TOKEN(%d) = %s\n", length, strdest);
+    return (length + sizeof(int));
+}
+
+// ------------------------------------------------------------------------------------------
+
+// extern int out ( const char* );
+
+// SENDING INFORMATION TO SERVER
+int prepareData(NetConnPtr conn, const char *data, int datalen, 
+				const char *parameter, const char *action)
+{
+    unsigned char **buffer = &(conn->dictionaryBuffer);
+    
+    int *len = &(conn->dictionaryBufferSize);
+    
+    unsigned char *privateEncriptionMap = conn->privateEncriptionMap;
+    
+    int position = 0;
+    
+    position = position + ob_copyAndFixString(buffer, len, position, 
+    			(const unsigned char*)"|data|", 6, privateEncriptionMap);
+    position = position + ob_copyAndFixString(buffer, len, position, 
+    			(const unsigned char*)action, strlen(action), privateEncriptionMap);
+    position = position + ob_copyAndFixString(buffer, len, position, 
+    			(const unsigned char*)parameter, strlen(parameter), privateEncriptionMap);
+    position = position + ob_copyAndFixString(buffer, len, position, 
+    			(const unsigned char*)data, datalen, privateEncriptionMap);
+    conn->dictionaryLength = position;
+
+    return position;
+}
+
+// ------------------------------------------------------------------------------------------
+
+void prepareDictionary(NetConnPtr conn)
+{
+    unsigned char *privateEncriptionMap = conn->privateEncriptionMap;
+    unsigned char **buffer = &(conn->dictionaryBuffer);
+    int *len = &(conn->dictionaryBufferSize);
+    int position = 0;
+
+    position = position + ob_copyAndFixString(buffer, len, position, 
+    			(const unsigned char*)"|dict|", 6, privateEncriptionMap);
+
+    conn->dictionaryLength = position;
+}
+
+// ------------------------------------------------------------------------------------------
+
+void addDictionaryPair(NetConnPtr conn, const char *key, const char *value)
+{
+    int position;
+    unsigned char *privateEncriptionMap = conn->privateEncriptionMap;
+    unsigned char **buffer = &(conn->dictionaryBuffer);
+    int *len = &(conn->dictionaryBufferSize);
+
+    position = conn->dictionaryLength;
+    position = position + ob_copyAndFixString( buffer, len, position, (const unsigned char*)key,
+    										strlen(key), privateEncriptionMap);
+    position = position + ob_copyAndFixString( buffer, len, position, (const unsigned char*)value, 
+    										strlen(value), privateEncriptionMap);
+    conn->dictionaryLength = position;
+}
+
+// ------------------------------------------------------------------------------------------
+
+int sendBuffer(NetConnPtr conn)
+{
+    int terminator = -1;
+    int position;
+    unsigned char **buffer = &(conn->dictionaryBuffer);
+    
+    // add terminator
+    position = conn->dictionaryLength;
+    ob_intToBytes((*buffer + position), terminator);
+    position = position + sizeof(int);
+    conn->dictionaryLength = position;
+    
+    return netSndRaw(conn->dictionaryBuffer, conn->dictionaryLength, conn->socketConnection);
+}
+
+// ------------------------------------------------------------------------------------------
+
+// RECEIVING FROM SERVER
+int _readDictionary(NetConnPtr conn)
+{
+    int ct;
+    int len = 0;
+    int flag = 0;
+	
+    for (ct = 0;; ct++) {
+    	if (conn->resultKeys[ct] == NULL) {
+	        //	conn->resultKeys[ct] = (unsigned char *)malloc(50);
+	        conn->resultKeys[ct] = (unsigned char *)ob_malloc(50);
+            conn->keyBufferSize[ct] = 50;
+    	}
+        if (conn->resultValues[ct] == NULL) {
+        	//	conn->resultValues[ct] = (unsigned char *)malloc(256); 
+        	conn->resultValues[ct] = (unsigned char *)ob_malloc(256); 
+        	conn->valueBufferSize[ct] = 256;
+		}
+       
+        len = (int)netRcvToken(&(conn->resultKeys[ct]), &(conn->keyBufferSize[ct]), 
+        						conn->socketConnection, conn->privateDecriptionMap, &flag);
+        if (len == -2L) { // terminator found
+            break;
+        }
+        if (len == -1L) { // error
+            return -1;
+        }
+
+        len = (int)netRcvToken(&(conn->resultValues[ct]), &(conn->valueBufferSize[ct]), 
+        						conn->socketConnection, conn->privateDecriptionMap, &flag);
+
+        if ((len == -1L) || (len == -2L)) { // error
+            return -1;
+        }
+        conn->resultLength[ct] = len;
+    }
+
+    conn->numberOfKeys = ct;
+    conn->resultLength[ct] = 0;
+    return 1;
+}
+
+// ------------------------------------------------------------------------------------------
+
+int _readData(NetConnPtr conn)
+{
+    int len = 0;
+	int flag = 0;
+	
+    if (conn->resultKeys[0] == NULL) {
+    	//	conn->resultKeys[0] = (unsigned char *)malloc(256); 
+    	conn->resultKeys[0] = (unsigned char *)ob_malloc(256); 
+    	conn->keyBufferSize[0] = 256;
+	}
+    if (conn->resultValues[0] == NULL) {
+    	//	conn->resultValues[0] = (unsigned char *)malloc(256); 
+    	conn->resultValues[0] = (unsigned char *)ob_malloc(256); 
+    	conn->valueBufferSize[0] = 256;
+	}
+	
+    if (conn->resultKeys[1] == NULL) {
+    	//	conn->resultKeys[1] = (unsigned char *)malloc(256); 
+    	conn->resultKeys[1] = (unsigned char *)ob_malloc(256); 
+    	conn->keyBufferSize[1] = 256;
+	}
+    if (conn->resultValues[1] == NULL) {
+    	//	conn->resultValues[1] = (unsigned char *)malloc(256); 
+    	conn->resultValues[1] = (unsigned char *)ob_malloc(256); 
+    	conn->valueBufferSize[1] = 256;
+	}
+
+    if (conn->resultKeys[2] == NULL) {
+    	//	conn->resultKeys[2] = (unsigned char *)malloc(256); 
+    	conn->resultKeys[2] = (unsigned char *)ob_malloc(256); 
+    	conn->keyBufferSize[2] = 256;
+	}
+		
+    if (conn->resultValues[2] == NULL) {
+        //	conn->resultValues[2] = (unsigned char *)malloc(256);
+        conn->resultValues[2] = (unsigned char *)ob_malloc(256);
+        conn->valueBufferSize[2] = 256;
+    }
+
+    // only to get terminator
+    if (conn->resultValues[3] == NULL) {
+        //	conn->resultValues[3] = (unsigned char *)malloc(256);
+        conn->resultValues[3] = (unsigned char *)ob_malloc(256);
+        conn->valueBufferSize[3] = 256;
+    }
+	
+    strcpy((char*)conn->resultKeys[0],"action");
+    len = (int)netRcvToken(&(conn->resultValues[0]), &(conn->valueBufferSize[0]), 
+    						conn->socketConnection, conn->privateDecriptionMap, &flag);
+    if ((len == -1L) || (len == -2L)) { // error
+        return -1;
+    }
+    conn->resultLength[0] = len;
+
+    strcpy((char*)conn->resultKeys[1],"parameter");
+    len = (int)netRcvToken(&(conn->resultValues[1]), &(conn->valueBufferSize[1]), 
+    						conn->socketConnection, conn->privateDecriptionMap, &flag);
+    if ((len == -1L) || (len == -2L)) { // error
+        return -1;
+    }
+    conn->resultLength[1] = len;
+
+    strcpy((char*)conn->resultKeys[2],"data");
+    len = (int)netRcvToken(&(conn->resultValues[2]), &(conn->valueBufferSize[2]), 
+    						conn->socketConnection, conn->privateDecriptionMap, &flag);
+    if ((len == -1L) || (len == -2L)) { // error
+        return -1;
+    }
+    conn->resultLength[2] = len;
+
+    // this is only to get terminator
+    len = (int)netRcvToken(&(conn->resultValues[3]), &(conn->valueBufferSize[3]), 
+    						conn->socketConnection, conn->privateDecriptionMap, &flag);
+    if (len != -2L) { // must be a terminator
+        return -1;
+    }
+
+    
+    conn->resultLength[3] = 0;
+    conn->numberOfKeys = 3;
+    return 1;
+}
+
+// ------------------------------------------------------------------------------------------
+
+int readResult(NetConn *conn)
+{
+    char *header = (char*)ob_malloc(10);
+    int headerLength = 10;
+    int ret = 0;
+    int len = 0;
+    int flag = 0;
+	
+    clearComm(conn);
+
+    len = (int)netRcvToken((unsigned char **)&header, &headerLength, conn->socketConnection, conn->privateDecriptionMap, &flag);
+    if ((len == -1L) || (len == -2L)) { // error
+        ob_free(header);
+        return 0;
+    }
+
+    if (strcmp((char*)header,"|dict|")==0) {
+        ret = _readDictionary(conn);
+    } else if (strcmp((char*)header,"|data|")==0){
+        ret = _readData(conn);
+    }
+    ob_free(header);
+    return ret;
+}
+
+
+// ------------------------------------------------------------------------------------------
+
+
+char *resultValueForKey(NetConnPtr conn, const char *key, int *valuelength)
+{
+    int ct;
+
+    for (ct = 0; ct < conn->numberOfKeys; ct++) {
+        if (strcmp(key, (char*)conn->resultKeys[ct])==0) {
+            *valuelength = conn->resultLength[ct];
+            return (char*)conn->resultValues[ct];
+        }
+    }
+    *valuelength = 0;
+    return NULL;
+}
+
+// ------------------------------------------------------------------------------------------
+
+static unsigned char *_decriptionKeyMap(unsigned char *keyString) //��dmr static!
+{
+    //	unsigned char *decriptMap = (unsigned char *)malloc(256);
+    unsigned char *decriptMap = (unsigned char *)ob_malloc(256);
+    int ct;
+    for (ct =0; ct < 256; ct++) {
+        decriptMap[keyString[ct]] = (unsigned char)ct;
+    }
+
+    return decriptMap;
+}
+
+// ------------------------------------------------------------------------------------------
+
+int syncronizeVersion(NetConnPtr conn)
+{
+    unsigned char buffer[20];
+    int ret = 0;
+	int flag = 0;
+	
+    buffer[0] = '#';
+    buffer[1] = strlen(COMM_VERSION);
+    strcpy((char *)&buffer[2],COMM_VERSION);
+
+    ret = netSndRaw(buffer, 5, conn->socketConnection);
+    if (!ret) 
+    {
+        netClose(conn->socketConnection);
+		#ifdef MACOS_CARBON
+	        conn->socketConnection = kOTInvalidEndpointRef;	
+		#endif
+        return 0;
+    }
+    if (OBSocketRead(conn->socketConnection, (unsigned char *)buffer, 1, &flag) != 1) 
+    {
+        netClose(conn->socketConnection);
+		#ifdef MACOS_CARBON
+	    	conn->socketConnection = kOTInvalidEndpointRef;	
+		#endif
+        return 0;
+    }
+    if (*buffer == 1) {
+        return 1;
+    }
+    netClose(conn->socketConnection);
+
+	#ifdef MACOS_CARBON
+	    conn->socketConnection = kOTInvalidEndpointRef;
+	#endif
+	
+    return 0;
+}
+
+// ------------------------------------------------------------------------------------------
+
+void sendExitSignal(NetConnPtr conn)
+{
+    unsigned char *privateEncriptionMap = conn->privateEncriptionMap;
+    unsigned char **buffer = &(conn->dictionaryBuffer);
+    int *len = &(conn->dictionaryBufferSize);
+    int position = 0;
+
+    position = position + ob_copyAndFixString(buffer, len, position, 
+    			(const unsigned char*)"|exit|", 6, privateEncriptionMap);
+
+    conn->dictionaryLength = position;
+    netSndRaw(conn->dictionaryBuffer, conn->dictionaryLength, conn->socketConnection);
+
+    return;
+}
+
+// ------------------------------------------------------------------------------------------
+
+void startPrivateTransmission(NetConnPtr conn)
+{
+    unsigned char *value;
+    int len = 0;
+    
+    prepareDictionary(conn);
+    addDictionaryPair(conn, "action", "privateConnection");
+    sendBuffer(conn);
+    if (!readResult(conn)) {
+        return;
+    }
+
+    value = (unsigned char *)resultValueForKey(conn, "result", &len);
+    if (!value || strcmp((const char *)value,(const char*)"no") == 0 || len < 255) {
+        return;
+    }
+
+    //	conn->privateEncriptionMap = (unsigned char *)malloc(256);
+    conn->privateEncriptionMap = (unsigned char *)ob_malloc(256);
+    conn->privateEncriptionMap[0] = '\0';
+    memcpy((conn->privateEncriptionMap + 1), value, 255);
+    conn->privateDecriptionMap = (unsigned char *)_decriptionKeyMap(conn->privateEncriptionMap);
+    conn->privateConnection = YES;
+}
+
+// ------------------------------------------------------------------------------------------