rhodes 2.3.0 → 2.3.1.beta.1

data/platform/bb/Hsqldb/src/org/hsqldb/persist/DataFileCache.java

@@ -48,6 +48,7 @@ import org.hsqldb.rowio.RowInputInterface;
 import org.hsqldb.rowio.RowOutputBinary;
 import org.hsqldb.rowio.RowOutputInterface;
 import org.hsqldb.store.BitMap;
+import com.rho.RhoCrypto;
 
 /**
  * Acts as a manager for CACHED table persistence.<p>
@@ -107,6 +108,10 @@ public class DataFileCache {
     public long maxDataFileSize;
 
     //
+    
+    protected boolean m_bEncrypted = false;
+    RhoCrypto m_RhoCrypto;
+    
     protected Storage dataFile;
     protected long    fileFreePosition;
     protected int     maxCacheSize;                // number of Rows
@@ -161,6 +166,16 @@ public class DataFileCache {
                                               : (long) Integer.MAX_VALUE * 4;
         maxFreeBlocks   = 1 << cacheFreeCountScale;
         dataFile        = null;
+        
+        String strEncryptionInfo = database.getURLProperties().getProperty(
+                HsqlDatabaseProperties.hsqldb_encrypted, "");
+        
+        if ( strEncryptionInfo != null && strEncryptionInfo.length() > 0  )
+        {
+        	m_bEncrypted = true;        	
+        	cachedRowPadding = 16;
+        	m_RhoCrypto = new RhoCrypto(strEncryptionInfo,128); 
+        }
     }
 
     public void sync()throws IOException
@@ -378,6 +393,9 @@ public class DataFileCache {
                 fa.removeElement(fileName);
                 fa.removeElement(backupFileName);
             }
+            
+            if ( m_RhoCrypto != null )
+            	m_RhoCrypto.close();
         } catch (Exception e) {
             appLog.logContext(e, null);
 
@@ -560,8 +578,12 @@ public class DataFileCache {
 
         int size = object.getRealSize(rowOut);
 
-        size = ((size + cachedRowPadding - 1) / cachedRowPadding)
-               * cachedRowPadding;
+        if ( m_bEncrypted )
+        	size = (((size-4) + cachedRowPadding - 1) / cachedRowPadding)
+               * cachedRowPadding + 4;
+        else
+        	size = ((size + cachedRowPadding - 1) / cachedRowPadding)
+            	* cachedRowPadding;        	
 
         object.setStorageSize(size);
 
@@ -658,16 +680,32 @@ public class DataFileCache {
         return dataFile.readInt();
     }
 
-    protected synchronized RowInputBinary readObject(int pos)
-    throws IOException {
-
+    private byte[] m_decryptBuffer;
+    protected synchronized RowInputBinary readObject(int pos) throws IOException 
+    {
         dataFile.seek((long) pos * cacheFileScale);
-
         int size = dataFile.readInt();
 
         rowIn.resetRow(pos, size);
-        dataFile.read(rowIn.getBuffer(), 4, size - 4);
-
+        
+        if ( m_bEncrypted )
+        {
+	        if ( m_decryptBuffer == null || m_decryptBuffer.length < size-4 )
+	        	m_decryptBuffer = new byte[size-4];
+	        
+	        dataFile.read(m_decryptBuffer, 0, size-4);
+        
+	        try
+	        {
+	        	m_RhoCrypto.decrypt(m_decryptBuffer, 0, size-4, rowIn.getBuffer(), 4 );
+	        }catch(Exception exc)
+	        {
+	        	database.logger.appLog.logContext(exc, "decrypt failed");
+	        	throw new IOException("decrypt page failed.");
+	        }
+        }else
+        	dataFile.read(rowIn.getBuffer(), 4, size - 4);
+        
         return rowIn;
     }
 
@@ -675,9 +713,8 @@ public class DataFileCache {
         return cache.release(i);
     }
 
-    protected synchronized void saveRows(CachedObject[] rows, int offset,
-                                         int count) throws IOException {
-
+    protected synchronized void saveRows(CachedObject[] rows, int offset, int count) throws IOException 
+    {
         if (count == 0) {
             return;
         }
@@ -707,14 +744,27 @@ public class DataFileCache {
      * Writes out the specified Row. Will write only the Nodes or both Nodes
      * and table row data depending on what is not already persisted to disk.
      */
-    public synchronized void saveRow(CachedObject row) throws IOException {
-
+    public synchronized void saveRow(CachedObject row) throws IOException 
+    {
         setFileModified();
         rowOut.reset();
-        row.write(rowOut);
+        row.write(rowOut, m_bEncrypted);
+        int nOutSize = rowOut.getOutputStream().size();
+        byte[] outBuf = rowOut.getOutputStream().getBuffer();
+        
+        if ( m_bEncrypted )
+        {
+	        try{
+	        	m_RhoCrypto.encrypt(outBuf, 4, nOutSize-4, outBuf, 4 );
+	        }catch(Exception exc)
+	        {
+	         	database.logger.appLog.logContext(exc, "encrypt failed");
+	         	throw new IOException("encrypt page failed.");
+	        }
+        }
+        
         dataFile.seek((long) row.getPos() * cacheFileScale);
-        dataFile.write(rowOut.getOutputStream().getBuffer(), 0,
-                       rowOut.getOutputStream().size());
+        dataFile.write(outBuf, 0, nOutSize);
     }
 
     /**

data/platform/bb/Hsqldb/src/org/hsqldb/persist/HsqlDatabaseProperties.java

@@ -207,7 +207,7 @@ public class HsqlDatabaseProperties extends HsqlProperties {
     private static final String hsqldb_original_version =
         "hsqldb.original_version";
     public static final String hsqldb_script_format = "hsqldb.script_format";
-
+    public static final String hsqldb_encrypted =  "hsqldb.encrypted";
     //
     private static final String sql_compare_in_locale =
         "sql.compare_in_locale";

data/platform/bb/RubyVM/src/com/rho/RhoCrypto.java

@@ -0,0 +1,116 @@
+package com.rho;
+
+import net.rim.device.api.crypto.*;
+import net.rim.device.api.io.NoCopyByteArrayOutputStream;
+import java.io.ByteArrayInputStream;
+import net.rim.device.api.system.PersistentObject;
+import net.rim.device.api.system.PersistentStore;
+import net.rim.device.api.util.StringUtilities;
+import java.io.IOException;
+
+public class RhoCrypto 
+{
+	AESKey m_key;
+	NoCopyByteArrayOutputStream m_outEncrypt;
+	BlockEncryptor m_cryptoStream;
+	AESDecryptorEngine m_decryptEngine;
+	String m_strStorageKey;
+	int m_nAlgLen;
+	
+	public RhoCrypto(String strStorageKey, int nAlgLen )
+	{
+		m_strStorageKey = strStorageKey;
+		m_nAlgLen = nAlgLen;
+	}
+	
+	public void close()
+	{
+		try
+		{
+			if ( m_cryptoStream != null )
+				m_cryptoStream.close();
+			
+			if ( m_outEncrypt  != null )
+				m_outEncrypt.close();
+		}catch(IOException exc)
+		{
+			
+		}
+	}
+	
+	public static boolean isKeyExist(String strStorageKey)
+	{
+		long lKey = makeKeyHash(strStorageKey);
+		PersistentObject persInfo = PersistentStore.getPersistentObject(lKey);
+		byte[] keyData = (byte[])persInfo.getContents();
+		return keyData != null;		
+	}
+
+	private static long makeKeyHash(String strStorageKey)
+	{
+		String strInfoKey = strStorageKey + "rho_encrypt_key_706cf99e52031270f635657f0272b8b516a5ee721";
+		long lHash = StringUtilities.stringHashToLong(strInfoKey);
+		
+		//System.out.println("makeKeyHash: " + strInfoKey + ":" + lHash);
+		return lHash;
+	}
+	
+	private void init()throws Exception
+	{
+		if ( m_key != null )
+			return;
+		
+		long lKey = makeKeyHash(m_strStorageKey);
+		
+		PersistentObject persInfo = PersistentStore.getPersistentObject(lKey);
+		byte[] keyData = (byte[])persInfo.getContents();
+		if ( keyData == null )
+		{
+			m_key = new AESKey(m_nAlgLen);
+			keyData = m_key.getData();
+			persInfo.setContents(keyData);
+			persInfo.commit();
+		}else
+		{
+			m_key = new AESKey(keyData, 0, m_nAlgLen);
+		}
+		
+		m_outEncrypt = new NoCopyByteArrayOutputStream();
+		m_cryptoStream = new BlockEncryptor( new AESEncryptorEngine( m_key ), m_outEncrypt );
+		
+		m_decryptEngine = new AESDecryptorEngine( m_key );
+	}
+	
+	public void encrypt(byte[] plainText, int offset, int dataLength, byte[] cipherText, int outOffset )throws Exception
+	{
+		init();
+		
+    	m_outEncrypt.reset();
+        m_cryptoStream.write( plainText, offset, dataLength );
+        m_cryptoStream.flush();
+        
+        int finalLength = m_outEncrypt.size();
+        System.arraycopy( m_outEncrypt.getByteArray(), 0, cipherText, outOffset, finalLength );	        
+	}
+	
+	public void decrypt(byte[] cipherText, int offset, int dataLength, byte[] plainText, int outOffset)throws Exception
+	{
+		init();
+        // Create the input stream based on the ciphertext
+        ByteArrayInputStream in = new ByteArrayInputStream( cipherText, offset, dataLength );
+        
+        BlockDecryptor cryptoStream = null;
+        try
+        {
+        	cryptoStream = new BlockDecryptor( m_decryptEngine, in );
+	        cryptoStream.read( plainText, outOffset, dataLength );
+        }finally
+        {
+        	if ( cryptoStream != null )
+        		cryptoStream.close();
+        	
+        	if ( in != null )
+        		in.close();        	
+        }
+	}	
+}

data/platform/bb/RubyVM/src/com/rho/ThreadQueue.java

@@ -20,13 +20,16 @@ public abstract class ThreadQueue extends RhoThread
     {
         public abstract boolean equals(IQueueCommand cmd);
         public abstract String toString();
+        
+        public abstract void cancel();
     };
 
     private RhoClassFactory m_ptrFactory;
 	private int           m_nPollInterval;
 	private Object m_mxStackCommands;// = new Mutex();
    	private LinkedList	  m_stackCommands = new LinkedList();
-
+   	private IQueueCommand m_pCurCmd;
+   	
     boolean m_bNoThreaded;
 
     public abstract void processCommand(IQueueCommand pCmd);
@@ -42,6 +45,10 @@ public abstract class ThreadQueue extends RhoThread
     public int getLastPollInterval(){ return 0;}
     public boolean isSkipDuplicateCmd() { return false; }
 
+    protected Object getCommandLock(){ return m_mxStackCommands; }
+    protected IQueueCommand getCurCommand(){ return m_pCurCmd; }
+    protected LinkedList/*Ptr<IQueueCommand*>&*/ getCommands(){ return m_stackCommands; }
+    
     public ThreadQueue(RhoClassFactory factory)
     {
         super(factory);
@@ -89,6 +96,36 @@ public abstract class ThreadQueue extends RhoThread
     	    stopWait(); 
     }
     
+    public void stop(int nTimeoutToKill)
+    {
+        cancelCurrentCommand();
+        super.stop(nTimeoutToKill);
+    }
+
+    void cancelCurrentCommand()
+    {
+        synchronized(m_mxStackCommands)
+        {
+	        if ( m_pCurCmd != null )
+	            m_pCurCmd.cancel();
+        }
+    }
+
+    protected void processCommandBase(IQueueCommand pCmd)
+    {
+        synchronized(m_mxStackCommands)
+        {
+            m_pCurCmd = pCmd;
+        }
+
+        processCommand(pCmd);
+
+        synchronized(m_mxStackCommands)
+        {
+            m_pCurCmd = null;
+        }
+    }
+    
     public void run()
     {
 	    LOG.INFO("Starting main routine...");
@@ -155,7 +192,7 @@ public abstract class ThreadQueue extends RhoThread
     		    pCmd = (IQueueCommand)m_stackCommands.removeFirst();
     	    }
     		
-		    processCommand(pCmd);
+		    processCommandBase(pCmd);
 	    }
     }
 

data/platform/bb/RubyVM/src/com/rho/Tokenizer.java

@@ -15,17 +15,22 @@ public class Tokenizer {
 	}
 	
 	public String nextToken() {
-		eatDelimeters();
+		//eatDelimeters();
 		int start = m_position;
 		while (m_position<m_length && m_delims.indexOf(m_str.charAt(m_position))==-1) {
 			m_position++;
 		}
 		
-		return m_str.substring(start,m_position);
+		String strToken = m_str.substring(start,m_position);
+		eatDelimeters();
+		return strToken;
 	}
 	
-	public void eatDelimeters() {
-		while (m_position<m_length) {
+	public void eatDelimeters() 
+	{
+		if ( m_position == m_length )
+			m_position++;
+		else if (m_position<m_length) {
 			char c = m_str.charAt(m_position);
 			if (m_delims.indexOf(c)>=0) {
 				m_position++;		
@@ -37,8 +42,8 @@ public class Tokenizer {
 	}
 	
     public boolean hasMoreTokens() {
-    	eatDelimeters();
-    	return (m_position < m_length);
+    	//eatDelimeters();
+    	return (m_position <= m_length);
     }