Updated changes with optional corrupt database handler (ref: sqlcipher#169)

Author: Chris Brody

src/net/sqlcipher/DatabaseErrorHandler.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.sqlcipher.database;
+
+import net.sqlcipher.database.SQLiteDatabase;
+
+/**
+ * An interface to let the apps define the actions to take when the following errors are detected
+ *   database corruption
+ */
+public interface DatabaseErrorHandler {
+
+    /**
+     * defines the method to be invoked when database corruption is detected.
+     * @param dbObj the {@link SQLiteDatabase} object representing the database on which corruption
+     * is detected.
+     */
+    void onCorruption(SQLiteDatabase dbObj);
+}

src/net/sqlcipher/DefaultDatabaseErrorHandler.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.sqlcipher.database;
+
+import java.io.File;
+import java.util.List;
+
+import net.sqlcipher.database.SQLiteDatabase;
+import net.sqlcipher.database.SQLiteException;
+
+import android.util.Log;
+import android.util.Pair;
+
+/**
+ * Default class used to define the actions to take when the database corruption is reported
+ * by sqlite.
+ * <p>
+ * If null is specified for DatabaeErrorHandler param in the above calls, then this class is used
+ * as the default {@link DatabaseErrorHandler}.
+ */
+public final class DefaultDatabaseErrorHandler implements DatabaseErrorHandler {
+
+    private static final String TAG = "DefaultDatabaseErrorHandler";
+
+    /**
+     * defines the default method to be invoked when database corruption is detected.
+     * @param dbObj the {@link SQLiteDatabase} object representing the database on which corruption
+     * is detected.
+     */
+    public void onCorruption(SQLiteDatabase dbObj) {
+        Log.e(TAG, "Corruption reported by sqlite on database, deleting and re-creating: " + dbObj.getPath());
+
+        if (dbObj.isOpen()) {
+            Log.e(TAG, "Database object for corrupted database is open, not expected for this implementation");
+            try {
+                dbObj.close();
+            } catch (Exception e) {
+                /* ignore */
+                Log.e(TAG, "Exception closing Database object for corrupted database, ignored", e);
+            }
+        }
+
+        deleteDatabaseFile(dbObj.getPath());
+    }
+
+    private void deleteDatabaseFile(String fileName) {
+        if (fileName.equalsIgnoreCase(":memory:") || fileName.trim().length() == 0) {
+            return;
+        }
+        Log.e(TAG, "deleting the database file: " + fileName);
+        try {
+            new File(fileName).delete();
+        } catch (Exception e) {
+            /* print warning and ignore exception */
+            Log.w(TAG, "delete failed: " + e.getMessage());
+        }
+    }
+}

src/net/sqlcipher/database/SQLiteDatabase.java

@@ -444,6 +444,7 @@ protected void onAllReferencesReleased() {
      * @param lockingEnabled set to true to enable locks, false otherwise
      */
     public void setLockingEnabled(boolean lockingEnabled) {
+        /* XXX TBD check if open? */
         mLockingEnabled = lockingEnabled;
     }
 
@@ -741,6 +742,7 @@ public void setTransactionSuccessful() {
      * return true if there is a transaction pending
      */
     public boolean inTransaction() {
+        /* XXX TBD check if open? */
         return mLock.getHoldCount() > 0;
     }
 
@@ -750,6 +752,7 @@ public boolean inTransaction() {
      * @return true, if this thread is holding the database lock.
      */
     public boolean isDbLockedByCurrentThread() {
+        /* XXX TBD check if open? */
         return mLock.isHeldByCurrentThread();
     }
 
@@ -948,6 +951,7 @@ public static SQLiteDatabase openDatabase(String path, String password, CursorFa
       return openDatabase(path, password.toCharArray(), factory, flags, null);
     }
 
+<<<<<<< HEAD
     /**
      * Open the database according to the flags {@link #OPEN_READWRITE}
      * {@link #OPEN_READONLY} {@link #CREATE_IF_NECESSARY} and/or {@link #NO_LOCALIZED_COLLATORS}.
@@ -991,7 +995,7 @@ public static SQLiteDatabase openDatabase(String path, char[] password, CursorFa
      * @throws IllegalArgumentException if the database path is null
      */
     public static SQLiteDatabase openDatabase(String path, String password, CursorFactory factory, int flags, SQLiteDatabaseHook hook) {
-      return openDatabase(path, password.toCharArray(), factory, flags, hook);
+      return openDatabase(path, password.toCharArray(), factory, flags, hook, new DefaultDatabaseErrorHandler());
     }
 
     /**
@@ -1015,6 +1019,21 @@ public static SQLiteDatabase openDatabase(String path, String password, CursorFa
      * @throws IllegalArgumentException if the database path is null
      */
     public static SQLiteDatabase openDatabase(String path, char[] password, CursorFactory factory, int flags, SQLiteDatabaseHook hook) {
+        return openDatabase(path, password, factory, flags, hook, new DefaultDatabaseErrorHandler());
+    }
+
+    public static SQLiteDatabase openDatabase(String path, String password, CursorFactory factory, int flags,
+                                              SQLiteDatabaseHook databaseHook, DatabaseErrorHandler errorHandler) {
+      return openDatabase(path, password.toCharArray(), factory, flags, databaseHook, new DefaultDatabaseErrorHandler());
+    }
+
+    public static SQLiteDatabase openDatabase(String path, String password, CursorFactory factory, int flags,
+                                              SQLiteDatabaseHook databaseHook, DatabaseErrorHandler errorHandler) {
+      return openDatabase(path, password.toCharArray(), factory, flags, databaseHook, errorHandler);
+    }
+
+    public static SQLiteDatabase openDatabase(String path, char[] password, CursorFactory factory, int flags,
+                                              SQLiteDatabaseHook databaseHook, DatabaseErrorHandler errorHandler) {
         SQLiteDatabase sqliteDatabase = null;
 
         try {
@@ -1031,13 +1050,43 @@ public static SQLiteDatabase openDatabase(String path, char[] password, CursorFa
         } catch (SQLiteDatabaseCorruptException e) {
             // Try to recover from this, if we can.
             // TODO: should we do this for other open failures?
+
+            Log.e(TAG, "Calling error handler for corrupt database " + path, e);
+	    // XXX Chris TODO TODO:
+          try {
+            errorHandler.onCorruption(new SQLiteDatabase(path)); // HORRIBLE HACK to support DatabaseErrorHandler API
+          } catch (Exception e2) {
+            Log.e(TAG, "error handler failed with exception", e2);
+	    //throw e;
+
+        synchronized (sActiveDatabases) {
+            sActiveDatabases.put(sqliteDatabase, null);
+          }
+            sqliteDatabase = openDatabase(path, password, factory, flags, databaseHook, errorHandler);
+        }
+        return sqliteDatabase;
+    }
+
+<<<<<<< HEAD
+            // Try to recover from this, if we can.
+            // TODO: should we do this for other open failures?
             Log.e(TAG, "Deleting and re-creating corrupt database " + path, e);
             // EventLog.writeEvent(EVENT_DB_CORRUPT, path);
 
+=======
+            Log.e(TAG, "Calling error handler for corrupt database " + path, e);
+          try {
+            errorHandler.onCorruption(new SQLiteDatabase(path)); // HORRIBLE HACK to support DatabaseErrorHandler API
+          } catch (Exception e2) {
+            Log.e(TAG, "error handler failed with exception", e2);
+	    //throw e;
+>>>>>>> d3e4c49... Updated changes with optional corrupt database handler (ref: sqlcipher/android-database-sqlcipher#169)
             if (!path.equalsIgnoreCase(":memory")) {
                 // delete is only for non-memory database files
+                Log.e(TAG, "delete and recreate", e);
                 new File(path).delete();
             }
+<<<<<<< HEAD
 
             sqliteDatabase = new SQLiteDatabase(path, factory, flags);
 
@@ -1047,14 +1096,22 @@ public static SQLiteDatabase openDatabase(String path, char[] password, CursorFa
 
         synchronized (sActiveDatabases) {
             sActiveDatabases.put(sqliteDatabase, null);
+=======
+          }
+            sqliteDatabase = openDatabase(path, password, factory, flags, databaseHook, errorHandler);
+>>>>>>> d3e4c49... Updated changes with optional corrupt database handler (ref: sqlcipher/android-database-sqlcipher#169)
         }
         return sqliteDatabase;
     }
 
+<<<<<<< HEAD
     /**
      * Equivalent to openDatabase(file.getPath(), password, factory, CREATE_IF_NECESSARY, databaseHook).
      */
     public static SQLiteDatabase openOrCreateDatabase(File file, String password, CursorFactory factory, SQLiteDatabaseHook databaseHook){
+=======
+    public static SQLiteDatabase openOrCreateDatabase(File file, String password, CursorFactory factory, SQLiteDatabaseHook databaseHook) {
+>>>>>>> d3e4c49... Updated changes with optional corrupt database handler (ref: sqlcipher/android-database-sqlcipher#169)
         return openOrCreateDatabase(file.getPath(), password, factory, databaseHook);
     }
 
@@ -1065,13 +1122,31 @@ public static SQLiteDatabase openOrCreateDatabase(String path, String password,
         return openDatabase(path, password, factory, CREATE_IF_NECESSARY, databaseHook);
     }
 
+<<<<<<< HEAD
     /**
      * Equivalent to openDatabase(path, password, factory, CREATE_IF_NECESSARY, databaseHook).
      */
+=======
+    public static SQLiteDatabase openOrCreateDatabase(File file, String password, CursorFactory factory, SQLiteDatabaseHook databaseHook,
+                                                      DatabaseErrorHandler errorHandler) {
+        return openDatabase(file.getPath(), password.toCharArray(), factory, CREATE_IF_NECESSARY, databaseHook, errorHandler);
+    }
+
+    public static SQLiteDatabase openOrCreateDatabase(String path, String password, CursorFactory factory, SQLiteDatabaseHook databaseHook,
+                                                      DatabaseErrorHandler errorHandler) {
+        return openDatabase(path, password.toCharArray(), factory, CREATE_IF_NECESSARY, databaseHook, errorHandler);
+    }
+
+>>>>>>> d3e4c49... Updated changes with optional corrupt database handler (ref: sqlcipher/android-database-sqlcipher#169)
     public static SQLiteDatabase openOrCreateDatabase(String path, char[] password, CursorFactory factory, SQLiteDatabaseHook databaseHook) {
       return openDatabase(path, password, factory, CREATE_IF_NECESSARY, databaseHook);
     }
 
+    public static SQLiteDatabase openOrCreateDatabase(String path, char[] password, CursorFactory factory, SQLiteDatabaseHook databaseHook,
+                                                      DatabaseErrorHandler errorHandler) {
+        return openDatabase(path, password, factory, CREATE_IF_NECESSARY, databaseHook, errorHandler);
+    }
+
     /**
      * Equivalent to openDatabase(file.getPath(), password, factory, CREATE_IF_NECESSARY).
      */
@@ -1305,6 +1380,14 @@ public void setPageSize(long numBytes) {
      *          syncable table
      */
     public void markTableSyncable(String table, String deletedTable) {
+        // XXX TBD TODO:
+        /* Protect against HORRIBLE HACK to support DatabaseErrorHandler API: */
+        /*
+        if (!isOpen()) {
+            throw new IllegalStateException("database not open");
+        }
+        */
+
         markTableSyncable(table, "_id", table, deletedTable);
     }
 
@@ -1321,6 +1404,14 @@ public void markTableSyncable(String table, String deletedTable) {
      */
     public void markTableSyncable(String table, String foreignKey,
                                   String updateTable) {
+        // XXX TBD TODO:
+        /* Protect against HORRIBLE HACK to support DatabaseErrorHandler API: */
+        /*
+        if (!isOpen()) {
+            throw new IllegalStateException("database not open");
+        }
+        */
+
         markTableSyncable(table, foreignKey, updateTable, null);
     }
 
@@ -1870,7 +1961,7 @@ public long insertWithOnConflict(String table, String nullColumnHack,
             }
             return insertedRowId;
         } catch (SQLiteDatabaseCorruptException e) {
-            onCorruption();
+            onCorruptionFromInsert();
             throw e;
         } finally {
             if (statement != null) {
@@ -2237,6 +2328,20 @@ private void openDatabaseInternal(char[] password, SQLiteDatabaseHook databaseHo
         }
     }
 
+    /**
+     * Private constructor for HORRIBLE HACK to support DatabaseErrorHandler API
+     * (SQLiteDatabase from this [private] constructor will never connect to a real database)
+     *
+     * @param path The full path to the database (will be available for DatabaseErrorHandler)
+     */
+    private SQLiteDatabase(String path) {
+        mPath = path;
+        /* These other members _should_ project certain public functions from this HORRIBLE HACK. */
+        mFlags = OPEN_READONLY; /* treat corrupt database as "read-only" */
+        mSlowQueryThreshold = -1;
+        /* NOTE: mNativeHandle is expected to be and remain 0 to indicate this handle is (never) open. */
+    }
+
     private String getTime() {
         return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS ").format(System.currentTimeMillis());
     }
@@ -2257,6 +2362,7 @@ public boolean isOpen() {
     }
 
     public boolean needUpgrade(int newVersion) {
+        /* NOTE: getVersion() will throw if database is not open. */
         return newVersion > getVersion();
     }
 
@@ -2350,6 +2456,8 @@ private String getPathForLogs() {
         return mPathForLogs;
     }
 
+    // XXX TODO check HH??
+
     /**
      * Sets the locale for this database.  Does nothing if this database has
      * the NO_LOCALIZED_COLLATORS flag set or was opened read only.