new directory structure

8 files changed, 1320 insertions, 0 deletions

diff --git a/org_apg/src/org/apg/provider/Accounts.java b/org_apg/src/org/apg/provider/Accounts.java
new file mode 100644
index 000000000..b95f079df
--- /dev/null
+++ b/org_apg/src/org/apg/provider/Accounts.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2010 Thialfihar <thi@thialfihar.org>
+ *
+ * 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 org.apg.provider;
+
+import android.provider.BaseColumns;
+
+public class Accounts implements BaseColumns {
+    public static final String TABLE_NAME = "accounts";
+
+    public static final String _ID_type = "INTEGER PRIMARY KEY";
+    public static final String NAME = "c_name";
+    public static final String NAME_type = "TEXT";
+}
diff --git a/org_apg/src/org/apg/provider/ApgServiceBlobDatabase.java b/org_apg/src/org/apg/provider/ApgServiceBlobDatabase.java
new file mode 100644
index 000000000..70b9cd64f
--- /dev/null
+++ b/org_apg/src/org/apg/provider/ApgServiceBlobDatabase.java
@@ -0,0 +1,54 @@
+package org.apg.provider;
+
+import org.apg.ApgService;
+
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.net.Uri;
+import android.util.Log;
+
+public class ApgServiceBlobDatabase extends SQLiteOpenHelper {
+    
+    private static final String TAG = "ApgServiceBlobDatabase";
+
+    private static final int VERSION = 1;
+    private static final String NAME = "apg_service_blob_data";
+    private static final String TABLE = "data";
+        
+    public ApgServiceBlobDatabase(Context context) {
+        super(context, NAME, null, VERSION);
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "constructor called");
+    }
+
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "onCreate() called");
+        db.execSQL("create table " + TABLE + " ( _id integer primary key autoincrement," +
+        		"key text not null)");
+    }
+
+    @Override
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "onUpgrade() called");
+        // no upgrade necessary yet
+    }
+    
+    public Uri insert(ContentValues vals) {
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "insert() called");
+        SQLiteDatabase db = this.getWritableDatabase();
+        long newId = db.insert(TABLE, null, vals);
+        return ContentUris.withAppendedId(ApgServiceBlobProvider.CONTENT_URI, newId);
+    }
+    
+    public Cursor query(String id, String key) {
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "query() called");
+        SQLiteDatabase db = this.getReadableDatabase();
+        return db.query(TABLE, new String[] {"_id"},
+                "_id = ? and key = ?", new String[] {id, key},
+                null, null, null);
+    }
+}
diff --git a/org_apg/src/org/apg/provider/ApgServiceBlobProvider.java b/org_apg/src/org/apg/provider/ApgServiceBlobProvider.java
new file mode 100644
index 000000000..f2d5377a4
--- /dev/null
+++ b/org_apg/src/org/apg/provider/ApgServiceBlobProvider.java
@@ -0,0 +1,138 @@
+package org.apg.provider;
+
+import org.apg.ApgService;
+import org.apg.Constants;
+
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.ParcelFileDescriptor;
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.List;
+import java.util.UUID;
+
+public class ApgServiceBlobProvider extends ContentProvider {
+    
+    private static final String TAG = "ApgServiceBlobProvider";
+    
+    public static final Uri CONTENT_URI = Uri.parse("content://org.thialfihar.android.apg.provider.apgserviceblobprovider");
+    
+    private static final String COLUMN_KEY = "key";
+    
+    private static final String STORE_PATH = Constants.path.APP_DIR+"/ApgServiceBlobs";
+    
+    private ApgServiceBlobDatabase mDb = null;
+
+    public ApgServiceBlobProvider() {
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "Constructor called");
+        File dir = new File(STORE_PATH);
+        dir.mkdirs();
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "Constructor finished");
+    }
+
+    @Override
+    public int delete(Uri arg0, String arg1, String[] arg2) {
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "delete() called");
+        // TODO Auto-generated method stub
+        return 0;
+    }
+
+    @Override
+    public String getType(Uri arg0) {
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "getType() called");
+        // not needed for now
+        return null;
+    }
+
+    @Override
+    public Uri insert(Uri uri, ContentValues ignored) {
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "insert() called");
+        // ContentValues are actually ignored, because we want to store a blob with no more information 
+        // but have to create an record with the password generated here first
+        
+        ContentValues vals = new ContentValues();
+        
+        // Insert a random key in the database. This has to provided by the caller when updating or
+        // getting the blob
+        String password = UUID.randomUUID().toString();
+        vals.put(COLUMN_KEY, password);
+        
+        Uri insertedUri = mDb.insert(vals);
+        return Uri.withAppendedPath(insertedUri, password);
+    }
+
+    @Override
+    public boolean onCreate() {
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "onCreate() called");
+        mDb = new ApgServiceBlobDatabase(getContext());
+        // TODO Auto-generated method stub
+        return true;
+    }
+
+    @Override
+    public Cursor query(Uri arg0, String[] arg1, String arg2, String[] arg3, String arg4) {
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "query() called");
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public int update(Uri arg0, ContentValues arg1, String arg2, String[] arg3) {
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "update() called");
+        // TODO Auto-generated method stub
+        return 0;
+    }
+    
+    @Override
+    public ParcelFileDescriptor openFile(Uri uri, String mode) throws SecurityException, FileNotFoundException {
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "openFile() called");
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "... with uri: "+uri.toString());
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "... with mode: "+mode);
+        
+        List<String> segments = uri.getPathSegments();
+        if(segments.size() < 2) {
+            throw new SecurityException("Password not found in URI");
+        }
+        String id = segments.get(0);
+        String key = segments.get(1);
+        
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "... got id: "+id);
+        if(ApgService.LOCAL_LOGD) Log.d(TAG, "... and key: "+key);
+
+        // get the data
+        Cursor result = mDb.query(id, key);
+        
+        if(result.getCount() == 0) {
+            // either the key is wrong or no id exists
+            throw new FileNotFoundException("No file found with that ID and/or password");
+        }
+        
+        File targetFile = new File(STORE_PATH, id);
+        if(mode.equals("w")) {
+            if(ApgService.LOCAL_LOGD) Log.d(TAG, "... will try to open file w");
+            if( !targetFile.exists() ) {
+                try {
+                    targetFile.createNewFile();
+                } catch (IOException e) {
+                    Log.e(TAG, "... got IEOException on creating new file", e);
+                    throw new FileNotFoundException("Could not create file to write to");
+                }
+            }
+            return ParcelFileDescriptor.open(targetFile, ParcelFileDescriptor.MODE_WRITE_ONLY | ParcelFileDescriptor.MODE_TRUNCATE );
+        } else if(mode.equals("r")) {
+            if(ApgService.LOCAL_LOGD) Log.d(TAG, "... will try to open file r");
+            if( !targetFile.exists() ) {
+                throw new FileNotFoundException("Error: Could not find the file requested");
+            }
+            return ParcelFileDescriptor.open(targetFile, ParcelFileDescriptor.MODE_READ_ONLY);
+        }
+
+        return null;
+    }
+
+}
diff --git a/org_apg/src/org/apg/provider/DataProvider.java b/org_apg/src/org/apg/provider/DataProvider.java
new file mode 100644
index 000000000..a97851e58
--- /dev/null
+++ b/org_apg/src/org/apg/provider/DataProvider.java
@@ -0,0 +1,381 @@
+/*
+ * Copyright (C) 2010 Thialfihar <thi@thialfihar.org>
+ *
+ * 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 org.apg.provider;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.HashMap;
+
+import org.apg.Id;
+
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.database.sqlite.SQLiteQueryBuilder;
+import android.net.Uri;
+import android.os.ParcelFileDescriptor;
+import android.text.TextUtils;
+
+public class DataProvider extends ContentProvider {
+    public static final String AUTHORITY = "org.thialfihar.android.apg.provider";
+
+    private static final int PUBLIC_KEY_RING = 101;
+    private static final int PUBLIC_KEY_RING_ID = 102;
+    private static final int PUBLIC_KEY_RING_BY_KEY_ID = 103;
+    private static final int PUBLIC_KEY_RING_BY_EMAILS = 104;
+    private static final int PUBLIC_KEY_RING_KEY = 111;
+    private static final int PUBLIC_KEY_RING_KEY_RANK = 112;
+    private static final int PUBLIC_KEY_RING_USER_ID = 121;
+    private static final int PUBLIC_KEY_RING_USER_ID_RANK = 122;
+
+    private static final int SECRET_KEY_RING = 201;
+    private static final int SECRET_KEY_RING_ID = 202;
+    private static final int SECRET_KEY_RING_BY_KEY_ID = 203;
+    private static final int SECRET_KEY_RING_BY_EMAILS = 204;
+    private static final int SECRET_KEY_RING_KEY = 211;
+    private static final int SECRET_KEY_RING_KEY_RANK = 212;
+    private static final int SECRET_KEY_RING_USER_ID = 221;
+    private static final int SECRET_KEY_RING_USER_ID_RANK = 222;
+
+    private static final int DATA_STREAM = 301;
+
+    private static final String PUBLIC_KEY_RING_CONTENT_DIR_TYPE =
+            "vnd.android.cursor.dir/vnd.thialfihar.apg.public.key_ring";
+    private static final String PUBLIC_KEY_RING_CONTENT_ITEM_TYPE =
+            "vnd.android.cursor.item/vnd.thialfihar.apg.public.key_ring";
+
+    private static final String PUBLIC_KEY_CONTENT_DIR_TYPE =
+            "vnd.android.cursor.dir/vnd.thialfihar.apg.public.key";
+    private static final String PUBLIC_KEY_CONTENT_ITEM_TYPE =
+            "vnd.android.cursor.item/vnd.thialfihar.apg.public.key";
+
+    private static final String SECRET_KEY_RING_CONTENT_DIR_TYPE =
+            "vnd.android.cursor.dir/vnd.thialfihar.apg.secret.key_ring";
+    private static final String SECRET_KEY_RING_CONTENT_ITEM_TYPE =
+            "vnd.android.cursor.item/vnd.thialfihar.apg.secret.key_ring";
+
+    private static final String SECRET_KEY_CONTENT_DIR_TYPE =
+            "vnd.android.cursor.dir/vnd.thialfihar.apg.secret.key";
+    private static final String SECRET_KEY_CONTENT_ITEM_TYPE =
+            "vnd.android.cursor.item/vnd.thialfihar.apg.secret.key";
+
+    private static final String USER_ID_CONTENT_DIR_TYPE =
+            "vnd.android.cursor.dir/vnd.thialfihar.apg.user_id";
+    private static final String USER_ID_CONTENT_ITEM_TYPE =
+            "vnd.android.cursor.item/vnd.thialfihar.apg.user_id";
+
+    public static final String _ID = "_id";
+    public static final String MASTER_KEY_ID = "master_key_id";
+    public static final String KEY_ID = "key_id";
+    public static final String USER_ID = "user_id";
+
+    private static final UriMatcher mUriMatcher;
+
+    private Database mDb;
+
+    static {
+        mUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+        mUriMatcher.addURI(AUTHORITY, "key_rings/public/key_id/*", PUBLIC_KEY_RING_BY_KEY_ID);
+        mUriMatcher.addURI(AUTHORITY, "key_rings/public/emails/*", PUBLIC_KEY_RING_BY_EMAILS);
+
+        mUriMatcher.addURI(AUTHORITY, "key_rings/public/*/keys", PUBLIC_KEY_RING_KEY);
+        mUriMatcher.addURI(AUTHORITY, "key_rings/public/*/keys/#", PUBLIC_KEY_RING_KEY_RANK);
+
+        mUriMatcher.addURI(AUTHORITY, "key_rings/public/*/user_ids", PUBLIC_KEY_RING_USER_ID);
+        mUriMatcher.addURI(AUTHORITY, "key_rings/public/*/user_ids/#", PUBLIC_KEY_RING_USER_ID_RANK);
+
+        mUriMatcher.addURI(AUTHORITY, "key_rings/public", PUBLIC_KEY_RING);
+        mUriMatcher.addURI(AUTHORITY, "key_rings/public/*", PUBLIC_KEY_RING_ID);
+
+        mUriMatcher.addURI(AUTHORITY, "key_rings/secret/key_id/*", SECRET_KEY_RING_BY_KEY_ID);
+        mUriMatcher.addURI(AUTHORITY, "key_rings/secret/emails/*", SECRET_KEY_RING_BY_EMAILS);
+
+        mUriMatcher.addURI(AUTHORITY, "key_rings/secret/*/keys", SECRET_KEY_RING_KEY);
+        mUriMatcher.addURI(AUTHORITY, "key_rings/secret/*/keys/#", SECRET_KEY_RING_KEY_RANK);
+
+        mUriMatcher.addURI(AUTHORITY, "key_rings/secret/*/user_ids", SECRET_KEY_RING_USER_ID);
+        mUriMatcher.addURI(AUTHORITY, "key_rings/secret/*/user_ids/#", SECRET_KEY_RING_USER_ID_RANK);
+
+        mUriMatcher.addURI(AUTHORITY, "key_rings/secret", SECRET_KEY_RING);
+        mUriMatcher.addURI(AUTHORITY, "key_rings/secret/*", SECRET_KEY_RING_ID);
+
+        mUriMatcher.addURI(AUTHORITY, "data/*", DATA_STREAM);
+    }
+
+    @Override
+    public boolean onCreate() {
+        mDb = new Database(getContext());
+        return true;
+    }
+
+    @Override
+    public Cursor query(Uri uri, String[] projection, String selection,
+                        String[] selectionArgs, String sortOrder) {
+        // TODO: implement the others, then use them for the lists
+        SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
+        HashMap<String, String> projectionMap = new HashMap<String, String>();
+
+        int match = mUriMatcher.match(uri);
+        int type;
+        switch (match) {
+            case PUBLIC_KEY_RING:
+            case PUBLIC_KEY_RING_ID:
+            case PUBLIC_KEY_RING_BY_KEY_ID:
+            case PUBLIC_KEY_RING_BY_EMAILS:
+            case PUBLIC_KEY_RING_KEY:
+            case PUBLIC_KEY_RING_KEY_RANK:
+            case PUBLIC_KEY_RING_USER_ID:
+            case PUBLIC_KEY_RING_USER_ID_RANK:
+                type = Id.database.type_public;
+                break;
+
+            case SECRET_KEY_RING:
+            case SECRET_KEY_RING_ID:
+            case SECRET_KEY_RING_BY_KEY_ID:
+            case SECRET_KEY_RING_BY_EMAILS:
+            case SECRET_KEY_RING_KEY:
+            case SECRET_KEY_RING_KEY_RANK:
+            case SECRET_KEY_RING_USER_ID:
+            case SECRET_KEY_RING_USER_ID_RANK:
+                type = Id.database.type_secret;
+                break;
+
+            default: {
+                throw new IllegalArgumentException("Unknown URI " + uri);
+            }
+        }
+
+        qb.appendWhere(KeyRings.TABLE_NAME + "." + KeyRings.TYPE + " = " + type);
+
+        switch (match) {
+            case PUBLIC_KEY_RING_ID:
+            case SECRET_KEY_RING_ID: {
+                qb.appendWhere(" AND " +
+                               KeyRings.TABLE_NAME + "." + KeyRings.MASTER_KEY_ID + " = ");
+                qb.appendWhereEscapeString(uri.getPathSegments().get(2));
+
+                // break omitted intentionally
+            }
+
+            case PUBLIC_KEY_RING:
+            case SECRET_KEY_RING: {
+                qb.setTables(KeyRings.TABLE_NAME + " INNER JOIN " + Keys.TABLE_NAME + " ON " +
+                             "(" + KeyRings.TABLE_NAME + "." + KeyRings._ID + " = " +
+                             Keys.TABLE_NAME + "." + Keys.KEY_RING_ID + " AND " +
+                             Keys.TABLE_NAME + "." + Keys.IS_MASTER_KEY + " = '1'" +
+                             ") " +
+                             " INNER JOIN " + UserIds.TABLE_NAME + " ON " +
+                             "(" + Keys.TABLE_NAME + "." + Keys._ID + " = " +
+                             UserIds.TABLE_NAME + "." + UserIds.KEY_ID + " AND " +
+                             UserIds.TABLE_NAME + "." + UserIds.RANK + " = '0') ");
+
+                projectionMap.put(_ID,
+                                  KeyRings.TABLE_NAME + "." + KeyRings._ID);
+                projectionMap.put(MASTER_KEY_ID,
+                                  KeyRings.TABLE_NAME + "." + KeyRings.MASTER_KEY_ID);
+                projectionMap.put(USER_ID,
+                                  UserIds.TABLE_NAME + "." + UserIds.USER_ID);
+
+                if (TextUtils.isEmpty(sortOrder)) {
+                    sortOrder = UserIds.TABLE_NAME + "." + UserIds.USER_ID + " ASC";
+                }
+
+                break;
+            }
+
+            case SECRET_KEY_RING_BY_KEY_ID:
+            case PUBLIC_KEY_RING_BY_KEY_ID: {
+                qb.setTables(Keys.TABLE_NAME + " AS tmp INNER JOIN " +
+                             KeyRings.TABLE_NAME + " ON (" +
+                             KeyRings.TABLE_NAME + "." + KeyRings._ID + " = " +
+                             "tmp." + Keys.KEY_RING_ID + ")" +
+                             " INNER JOIN " + Keys.TABLE_NAME + " ON " +
+                             "(" + KeyRings.TABLE_NAME + "." + KeyRings._ID + " = " +
+                             Keys.TABLE_NAME + "." + Keys.KEY_RING_ID + " AND " +
+                             Keys.TABLE_NAME + "." + Keys.IS_MASTER_KEY + " = '1'" +
+                             ") " +
+                             " INNER JOIN " + UserIds.TABLE_NAME + " ON " +
+                             "(" + Keys.TABLE_NAME + "." + Keys._ID + " = " +
+                             UserIds.TABLE_NAME + "." + UserIds.KEY_ID + " AND " +
+                             UserIds.TABLE_NAME + "." + UserIds.RANK + " = '0') ");
+
+                projectionMap.put(_ID,
+                                  KeyRings.TABLE_NAME + "." + KeyRings._ID);
+                projectionMap.put(MASTER_KEY_ID,
+                                  KeyRings.TABLE_NAME + "." + KeyRings.MASTER_KEY_ID);
+                projectionMap.put(USER_ID,
+                                  UserIds.TABLE_NAME + "." + UserIds.USER_ID);
+
+                qb.appendWhere(" AND tmp." + Keys.KEY_ID + " = ");
+                qb.appendWhereEscapeString(uri.getPathSegments().get(3));
+
+                break;
+            }
+
+            case SECRET_KEY_RING_BY_EMAILS:
+            case PUBLIC_KEY_RING_BY_EMAILS: {
+                qb.setTables(KeyRings.TABLE_NAME + " INNER JOIN " + Keys.TABLE_NAME + " ON " +
+                             "(" + KeyRings.TABLE_NAME + "." + KeyRings._ID + " = " +
+                             Keys.TABLE_NAME + "." + Keys.KEY_RING_ID + " AND " +
+                             Keys.TABLE_NAME + "." + Keys.IS_MASTER_KEY + " = '1'" +
+                             ") " +
+                             " INNER JOIN " + UserIds.TABLE_NAME + " ON " +
+                             "(" + Keys.TABLE_NAME + "." + Keys._ID + " = " +
+                             UserIds.TABLE_NAME + "." + UserIds.KEY_ID + " AND " +
+                             UserIds.TABLE_NAME + "." + UserIds.RANK + " = '0') ");
+
+                projectionMap.put(_ID,
+                                  KeyRings.TABLE_NAME + "." + KeyRings._ID);
+                projectionMap.put(MASTER_KEY_ID,
+                                  KeyRings.TABLE_NAME + "." + KeyRings.MASTER_KEY_ID);
+                projectionMap.put(USER_ID,
+                                  UserIds.TABLE_NAME + "." + UserIds.USER_ID);
+
+                String emails = uri.getPathSegments().get(3);
+                String chunks[] = emails.split(" *, *");
+                boolean gotCondition = false;
+                String emailWhere = "";
+                for (int i = 0; i < chunks.length; ++i) {
+                    if (chunks[i].length() == 0) {
+                        continue;
+                    }
+                    if (i != 0) {
+                        emailWhere += " OR ";
+                    }
+                    emailWhere += "tmp." + UserIds.USER_ID + " LIKE ";
+                    // match '*<email>', so it has to be at the *end* of the user id
+                    emailWhere += DatabaseUtils.sqlEscapeString("%<" + chunks[i] + ">");
+                    gotCondition = true;
+                }
+
+                if (gotCondition) {
+                    qb.appendWhere(" AND EXISTS (SELECT tmp." + UserIds._ID +
+                                     " FROM " + UserIds.TABLE_NAME +
+                                       " AS tmp WHERE tmp." + UserIds.KEY_ID + " = " +
+                                           Keys.TABLE_NAME + "." + Keys._ID +
+                                       " AND (" + emailWhere + "))");
+                }
+
+                break;
+            }
+
+            default: {
+                throw new IllegalArgumentException("Unknown URI " + uri);
+            }
+        }
+
+        qb.setProjectionMap(projectionMap);
+
+        // If no sort order is specified use the default
+        String orderBy;
+        if (TextUtils.isEmpty(sortOrder)) {
+            orderBy = null;
+        } else {
+            orderBy = sortOrder;
+        }
+
+        //System.out.println(qb.buildQuery(projection, selection, selectionArgs, null, null, sortOrder, null).replace("WHERE", "WHERE\n"));
+        Cursor c = qb.query(mDb.db(), projection, selection, selectionArgs, null, null, orderBy);
+
+        // Tell the cursor what uri to watch, so it knows when its source data changes
+        c.setNotificationUri(getContext().getContentResolver(), uri);
+        return c;
+    }
+
+    @Override
+    public String getType(Uri uri) {
+        switch (mUriMatcher.match(uri)) {
+            case PUBLIC_KEY_RING:
+            case PUBLIC_KEY_RING_BY_EMAILS:
+                return PUBLIC_KEY_RING_CONTENT_DIR_TYPE;
+
+            case PUBLIC_KEY_RING_ID:
+                return PUBLIC_KEY_RING_CONTENT_ITEM_TYPE;
+
+            case PUBLIC_KEY_RING_BY_KEY_ID:
+                return PUBLIC_KEY_RING_CONTENT_ITEM_TYPE;
+
+            case PUBLIC_KEY_RING_KEY:
+                return PUBLIC_KEY_CONTENT_DIR_TYPE;
+
+            case PUBLIC_KEY_RING_KEY_RANK:
+                return PUBLIC_KEY_CONTENT_ITEM_TYPE;
+
+            case PUBLIC_KEY_RING_USER_ID:
+                return USER_ID_CONTENT_DIR_TYPE;
+
+            case PUBLIC_KEY_RING_USER_ID_RANK:
+                return USER_ID_CONTENT_ITEM_TYPE;
+
+            case SECRET_KEY_RING:
+            case SECRET_KEY_RING_BY_EMAILS:
+                return SECRET_KEY_RING_CONTENT_DIR_TYPE;
+
+            case SECRET_KEY_RING_ID:
+                return SECRET_KEY_RING_CONTENT_ITEM_TYPE;
+
+            case SECRET_KEY_RING_BY_KEY_ID:
+                return SECRET_KEY_RING_CONTENT_ITEM_TYPE;
+
+            case SECRET_KEY_RING_KEY:
+                return SECRET_KEY_CONTENT_DIR_TYPE;
+
+            case SECRET_KEY_RING_KEY_RANK:
+                return SECRET_KEY_CONTENT_ITEM_TYPE;
+
+            case SECRET_KEY_RING_USER_ID:
+                return USER_ID_CONTENT_DIR_TYPE;
+
+            case SECRET_KEY_RING_USER_ID_RANK:
+                return USER_ID_CONTENT_ITEM_TYPE;
+
+            default:
+                throw new IllegalArgumentException("Unknown URI " + uri);
+        }
+    }
+
+    @Override
+    public Uri insert(Uri uri, ContentValues initialValues) {
+        // not supported
+        return null;
+    }
+
+    @Override
+    public int delete(Uri uri, String where, String[] whereArgs) {
+        // not supported
+        return 0;
+    }
+
+    @Override
+    public int update(Uri uri, ContentValues values, String where, String[] whereArgs) {
+        // not supported
+        return 0;
+    }
+
+    @Override
+    public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
+        int match = mUriMatcher.match(uri);
+        if (match != DATA_STREAM) {
+            throw new FileNotFoundException();
+        }
+        String fileName = uri.getPathSegments().get(1);
+        File file = new File(getContext().getFilesDir().getAbsolutePath(), fileName);
+        return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
+    }
+}
diff --git a/org_apg/src/org/apg/provider/Database.java b/org_apg/src/org/apg/provider/Database.java
new file mode 100644
index 000000000..8b1aaa9e7
--- /dev/null
+++ b/org_apg/src/org/apg/provider/Database.java
@@ -0,0 +1,605 @@
+package org.apg.provider;
+
+import org.apg.Apg;
+import org.apg.Id;
+import org.apg.util.IterableIterator;
+import org.spongycastle.openpgp.PGPException;
+import org.spongycastle.openpgp.PGPPublicKey;
+import org.spongycastle.openpgp.PGPPublicKeyRing;
+import org.spongycastle.openpgp.PGPSecretKey;
+import org.spongycastle.openpgp.PGPSecretKeyRing;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.util.Log;
+
+import java.io.IOException;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Vector;
+
+public class Database extends SQLiteOpenHelper {
+    public static class GeneralException extends Exception {
+        static final long serialVersionUID = 0xf812773343L;
+
+        public GeneralException(String message) {
+            super(message);
+        }
+    }
+
+    private static final String DATABASE_NAME = "apg";
+    private static final int DATABASE_VERSION = 2;
+
+    public static final String AUTHORITY = "org.thialfihar.android.apg.database";
+
+    public static HashMap<String, String> sKeyRingsProjection;
+    public static HashMap<String, String> sKeysProjection;
+    public static HashMap<String, String> sUserIdsProjection;
+
+    private SQLiteDatabase mDb = null;
+    private int mStatus = 0;
+
+    static {
+        sKeyRingsProjection = new HashMap<String, String>();
+        sKeyRingsProjection.put(KeyRings._ID, KeyRings._ID);
+        sKeyRingsProjection.put(KeyRings.MASTER_KEY_ID, KeyRings.MASTER_KEY_ID);
+        sKeyRingsProjection.put(KeyRings.TYPE, KeyRings.TYPE);
+        sKeyRingsProjection.put(KeyRings.WHO_ID, KeyRings.WHO_ID);
+        sKeyRingsProjection.put(KeyRings.KEY_RING_DATA, KeyRings.KEY_RING_DATA);
+
+        sKeysProjection = new HashMap<String, String>();
+        sKeysProjection.put(Keys._ID, Keys._ID);
+        sKeysProjection.put(Keys.KEY_ID, Keys.KEY_ID);
+        sKeysProjection.put(Keys.TYPE, Keys.TYPE);
+        sKeysProjection.put(Keys.IS_MASTER_KEY, Keys.IS_MASTER_KEY);
+        sKeysProjection.put(Keys.ALGORITHM, Keys.ALGORITHM);
+        sKeysProjection.put(Keys.KEY_SIZE, Keys.KEY_SIZE);
+        sKeysProjection.put(Keys.CAN_SIGN, Keys.CAN_SIGN);
+        sKeysProjection.put(Keys.CAN_ENCRYPT, Keys.CAN_ENCRYPT);
+        sKeysProjection.put(Keys.IS_REVOKED, Keys.IS_REVOKED);
+        sKeysProjection.put(Keys.CREATION, Keys.CREATION);
+        sKeysProjection.put(Keys.EXPIRY, Keys.EXPIRY);
+        sKeysProjection.put(Keys.KEY_DATA, Keys.KEY_DATA);
+        sKeysProjection.put(Keys.RANK, Keys.RANK);
+
+        sUserIdsProjection = new HashMap<String, String>();
+        sUserIdsProjection.put(UserIds._ID, UserIds._ID);
+        sUserIdsProjection.put(UserIds.KEY_ID, UserIds.KEY_ID);
+        sUserIdsProjection.put(UserIds.USER_ID, UserIds.USER_ID);
+        sUserIdsProjection.put(UserIds.RANK, UserIds.RANK);
+    }
+
+    public Database(Context context) {
+        super(context, DATABASE_NAME, null, DATABASE_VERSION);
+        // force upgrade to test things
+        //onUpgrade(getWritableDatabase(), 1, 2);
+        mDb = getWritableDatabase();
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        mDb.close();
+        super.finalize();
+    }
+
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+        db.execSQL("CREATE TABLE " + KeyRings.TABLE_NAME + " (" +
+                   KeyRings._ID + " " + KeyRings._ID_type + "," +
+                   KeyRings.MASTER_KEY_ID + " " + KeyRings.MASTER_KEY_ID_type + ", " +
+                   KeyRings.TYPE + " " + KeyRings.TYPE_type + ", " +
+                   KeyRings.WHO_ID + " " + KeyRings.WHO_ID_type + ", " +
+                   KeyRings.KEY_RING_DATA + " " + KeyRings.KEY_RING_DATA_type + ");");
+
+        db.execSQL("CREATE TABLE " + Keys.TABLE_NAME + " (" +
+                   Keys._ID + " " + Keys._ID_type + "," +
+                   Keys.KEY_ID + " " + Keys.KEY_ID_type + ", " +
+                   Keys.TYPE + " " + Keys.TYPE_type + ", " +
+                   Keys.IS_MASTER_KEY + " " + Keys.IS_MASTER_KEY_type + ", " +
+                   Keys.ALGORITHM + " " + Keys.ALGORITHM_type + ", " +
+                   Keys.KEY_SIZE + " " + Keys.KEY_SIZE_type + ", " +
+                   Keys.CAN_SIGN + " " + Keys.CAN_SIGN_type + ", " +
+                   Keys.CAN_ENCRYPT + " " + Keys.CAN_ENCRYPT_type + ", " +
+                   Keys.IS_REVOKED + " " + Keys.IS_REVOKED_type + ", " +
+                   Keys.CREATION + " " + Keys.CREATION_type + ", " +
+                   Keys.EXPIRY + " " + Keys.EXPIRY_type + ", " +
+                   Keys.KEY_RING_ID + " " + Keys.KEY_RING_ID_type + ", " +
+                   Keys.KEY_DATA + " " + Keys.KEY_DATA_type +
+                   Keys.RANK + " " + Keys.RANK_type + ");");
+
+        db.execSQL("CREATE TABLE " + UserIds.TABLE_NAME + " (" +
+                   UserIds._ID + " " + UserIds._ID_type + "," +
+                   UserIds.KEY_ID + " " + UserIds.KEY_ID_type + "," +
+                   UserIds.USER_ID + " " + UserIds.USER_ID_type + "," +
+                   UserIds.RANK + " " + UserIds.RANK_type + ");");
+
+        db.execSQL("CREATE TABLE " + Accounts.TABLE_NAME + " (" +
+                   Accounts._ID + " " + Accounts._ID_type + "," +
+                   Accounts.NAME + " " + Accounts.NAME_type + ");");
+    }
+
+    @Override
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        mDb = db;
+        for (int version = oldVersion; version < newVersion; ++version) {
+            switch (version) {
+                case 1: { // upgrade 1 to 2
+                    db.execSQL("DROP TABLE IF EXISTS " + KeyRings.TABLE_NAME + ";");
+                    db.execSQL("DROP TABLE IF EXISTS " + Keys.TABLE_NAME + ";");
+                    db.execSQL("DROP TABLE IF EXISTS " + UserIds.TABLE_NAME + ";");
+
+                    db.execSQL("CREATE TABLE " + KeyRings.TABLE_NAME + " (" +
+                               KeyRings._ID + " " + KeyRings._ID_type + "," +
+                               KeyRings.MASTER_KEY_ID + " " + KeyRings.MASTER_KEY_ID_type + ", " +
+                               KeyRings.TYPE + " " + KeyRings.TYPE_type + ", " +
+                               KeyRings.WHO_ID + " " + KeyRings.WHO_ID_type + ", " +
+                               KeyRings.KEY_RING_DATA + " " + KeyRings.KEY_RING_DATA_type + ");");
+
+                    db.execSQL("CREATE TABLE " + Keys.TABLE_NAME + " (" +
+                               Keys._ID + " " + Keys._ID_type + "," +
+                               Keys.KEY_ID + " " + Keys.KEY_ID_type + ", " +
+                               Keys.TYPE + " " + Keys.TYPE_type + ", " +
+                               Keys.IS_MASTER_KEY + " " + Keys.IS_MASTER_KEY_type + ", " +
+                               Keys.ALGORITHM + " " + Keys.ALGORITHM_type + ", " +
+                               Keys.KEY_SIZE + " " + Keys.KEY_SIZE_type + ", " +
+                               Keys.CAN_SIGN + " " + Keys.CAN_SIGN_type + ", " +
+                               Keys.CAN_ENCRYPT + " " + Keys.CAN_ENCRYPT_type + ", " +
+                               Keys.IS_REVOKED + " " + Keys.IS_REVOKED_type + ", " +
+                               Keys.CREATION + " " + Keys.CREATION_type + ", " +
+                               Keys.EXPIRY + " " + Keys.EXPIRY_type + ", " +
+                               Keys.KEY_RING_ID + " " + Keys.KEY_RING_ID_type + ", " +
+                               Keys.KEY_DATA + " " + Keys.KEY_DATA_type +
+                               Keys.RANK + " " + Keys.RANK_type + ");");
+
+                    db.execSQL("CREATE TABLE " + UserIds.TABLE_NAME + " (" +
+                               UserIds._ID + " " + UserIds._ID_type + "," +
+                               UserIds.KEY_ID + " " + UserIds.KEY_ID_type + "," +
+                               UserIds.USER_ID + " " + UserIds.USER_ID_type + "," +
+                               UserIds.RANK + " " + UserIds.RANK_type + ");");
+
+                    Cursor cursor = db.query("public_keys", new String[] { "c_key_data" },
+                                             null, null, null, null, null);
+                    if (cursor != null && cursor.moveToFirst()) {
+                        do {
+                            byte[] data = cursor.getBlob(0);
+                            try {
+                                PGPPublicKeyRing keyRing = new PGPPublicKeyRing(data);
+                                saveKeyRing(keyRing);
+                            } catch (IOException e) {
+                                Log.e("apg.db.upgrade", "key import failed: " + e);
+                            } catch (GeneralException e) {
+                                Log.e("apg.db.upgrade", "key import failed: " + e);
+                            }
+                        } while (cursor.moveToNext());
+                    }
+
+                    if (cursor != null) {
+                        cursor.close();
+                    }
+
+                    cursor = db.query("secret_keys", new String[]{ "c_key_data" },
+                                      null, null, null, null, null);
+                    if (cursor != null && cursor.moveToFirst()) {
+                        do {
+                            byte[] data = cursor.getBlob(0);
+                            try {
+                                PGPSecretKeyRing keyRing = new PGPSecretKeyRing(data);
+                                saveKeyRing(keyRing);
+                            } catch (IOException e) {
+                                Log.e("apg.db.upgrade", "key import failed: " + e);
+                            } catch (PGPException e) {
+                                Log.e("apg.db.upgrade", "key import failed: " + e);
+                            } catch (GeneralException e) {
+                                Log.e("apg.db.upgrade", "key import failed: " + e);
+                            }
+                        } while (cursor.moveToNext());
+                    }
+
+                    if (cursor != null) {
+                        cursor.close();
+                    }
+
+                    db.execSQL("DROP TABLE IF EXISTS public_keys;");
+                    db.execSQL("DROP TABLE IF EXISTS secret_keys;");
+
+                    break;
+                }
+
+                default: {
+                    break;
+                }
+            }
+        }
+        mDb = null;
+    }
+
+    public int saveKeyRing(PGPPublicKeyRing keyRing) throws IOException, GeneralException {
+        mDb.beginTransaction();
+        ContentValues values = new ContentValues();
+        PGPPublicKey masterKey = keyRing.getPublicKey();
+        long masterKeyId = masterKey.getKeyID();
+
+        values.put(KeyRings.MASTER_KEY_ID, masterKeyId);
+        values.put(KeyRings.TYPE, Id.database.type_public);
+        values.put(KeyRings.KEY_RING_DATA, keyRing.getEncoded());
+
+        long rowId = insertOrUpdateKeyRing(values);
+        int returnValue = mStatus;
+
+        if (rowId == -1) {
+            throw new GeneralException("saving public key ring " + masterKeyId + " failed");
+        }
+
+        Vector<Integer> seenIds = new Vector<Integer>();
+        int rank = 0;
+        for (PGPPublicKey key : new IterableIterator<PGPPublicKey>(keyRing.getPublicKeys())) {
+            seenIds.add(saveKey(rowId, key, rank));
+            ++rank;
+        }
+
+        String seenIdsStr = "";
+        for (Integer id : seenIds) {
+            if (seenIdsStr.length() > 0) {
+                seenIdsStr += ",";
+            }
+            seenIdsStr += id;
+        }
+        mDb.delete(Keys.TABLE_NAME,
+                   Keys.KEY_RING_ID + " = ? AND " +
+                   Keys._ID + " NOT IN (" + seenIdsStr + ")",
+                   new String[] { "" + rowId });
+
+        mDb.setTransactionSuccessful();
+        mDb.endTransaction();
+        return returnValue;
+    }
+
+    public int saveKeyRing(PGPSecretKeyRing keyRing) throws IOException, GeneralException {
+        mDb.beginTransaction();
+        ContentValues values = new ContentValues();
+        PGPSecretKey masterKey = keyRing.getSecretKey();
+        long masterKeyId = masterKey.getKeyID();
+
+        values.put(KeyRings.MASTER_KEY_ID, masterKeyId);
+        values.put(KeyRings.TYPE, Id.database.type_secret);
+        values.put(KeyRings.KEY_RING_DATA, keyRing.getEncoded());
+
+        long rowId = insertOrUpdateKeyRing(values);
+        int returnValue = mStatus;
+
+        if (rowId == -1) {
+            throw new GeneralException("saving secret key ring " + masterKeyId + " failed");
+        }
+
+        Vector<Integer> seenIds = new Vector<Integer>();
+        int rank = 0;
+        for (PGPSecretKey key : new IterableIterator<PGPSecretKey>(keyRing.getSecretKeys())) {
+            seenIds.add(saveKey(rowId, key, rank));
+            ++rank;
+        }
+
+        String seenIdsStr = "";
+        for (Integer id : seenIds) {
+            if (seenIdsStr.length() > 0) {
+                seenIdsStr += ",";
+            }
+            seenIdsStr += id;
+        }
+        mDb.delete(Keys.TABLE_NAME,
+                   Keys.KEY_RING_ID + " = ? AND " +
+                   Keys._ID + " NOT IN (" + seenIdsStr + ")",
+                   new String[] { "" + rowId });
+
+        mDb.setTransactionSuccessful();
+        mDb.endTransaction();
+        return returnValue;
+    }
+
+    private int saveKey(long keyRingId, PGPPublicKey key, int rank)
+            throws IOException, GeneralException {
+        ContentValues values = new ContentValues();
+
+        values.put(Keys.KEY_ID, key.getKeyID());
+        values.put(Keys.TYPE, Id.database.type_public);
+        values.put(Keys.IS_MASTER_KEY, key.isMasterKey());
+        values.put(Keys.ALGORITHM, key.getAlgorithm());
+        values.put(Keys.KEY_SIZE, key.getBitStrength());
+        values.put(Keys.CAN_SIGN, Apg.isSigningKey(key));
+        values.put(Keys.CAN_ENCRYPT, Apg.isEncryptionKey(key));
+        values.put(Keys.IS_REVOKED, key.isRevoked());
+        values.put(Keys.CREATION, Apg.getCreationDate(key).getTime() / 1000);
+        Date expiryDate = Apg.getExpiryDate(key);
+        if (expiryDate != null) {
+            values.put(Keys.EXPIRY, expiryDate.getTime() / 1000);
+        }
+        values.put(Keys.KEY_RING_ID, keyRingId);
+        values.put(Keys.KEY_DATA, key.getEncoded());
+        values.put(Keys.RANK, rank);
+
+        long rowId = insertOrUpdateKey(values);
+
+        if (rowId == -1) {
+            throw new GeneralException("saving public key " + key.getKeyID() + " failed");
+        }
+
+        Vector<Integer> seenIds = new Vector<Integer>();
+        int userIdRank = 0;
+        for (String userId : new IterableIterator<String>(key.getUserIDs())) {
+            seenIds.add(saveUserId(rowId, userId, userIdRank));
+            ++userIdRank;
+        }
+
+        String seenIdsStr = "";
+        for (Integer id : seenIds) {
+            if (seenIdsStr.length() > 0) {
+                seenIdsStr += ",";
+            }
+            seenIdsStr += id;
+        }
+        mDb.delete(UserIds.TABLE_NAME,
+                   UserIds.KEY_ID + " = ? AND " +
+                   UserIds._ID + " NOT IN (" + seenIdsStr + ")",
+                   new String[] { "" + rowId });
+
+        return (int)rowId;
+    }
+
+    private int saveKey(long keyRingId, PGPSecretKey key, int rank)
+            throws IOException, GeneralException {
+        ContentValues values = new ContentValues();
+
+        values.put(Keys.KEY_ID, key.getPublicKey().getKeyID());
+        values.put(Keys.TYPE, Id.database.type_secret);
+        values.put(Keys.IS_MASTER_KEY, key.isMasterKey());
+        values.put(Keys.ALGORITHM, key.getPublicKey().getAlgorithm());
+        values.put(Keys.KEY_SIZE, key.getPublicKey().getBitStrength());
+        values.put(Keys.CAN_SIGN, Apg.isSigningKey(key));
+        values.put(Keys.CAN_ENCRYPT, Apg.isEncryptionKey(key));
+        values.put(Keys.IS_REVOKED, key.getPublicKey().isRevoked());
+        values.put(Keys.CREATION, Apg.getCreationDate(key).getTime() / 1000);
+        Date expiryDate = Apg.getExpiryDate(key);
+        if (expiryDate != null) {
+            values.put(Keys.EXPIRY, expiryDate.getTime() / 1000);
+        }
+        values.put(Keys.KEY_RING_ID, keyRingId);
+        values.put(Keys.KEY_DATA, key.getEncoded());
+        values.put(Keys.RANK, rank);
+
+        long rowId = insertOrUpdateKey(values);
+
+        if (rowId == -1) {
+            throw new GeneralException("saving secret key " + key.getPublicKey().getKeyID() + " failed");
+        }
+
+        Vector<Integer> seenIds = new Vector<Integer>();
+        int userIdRank = 0;
+        for (String userId : new IterableIterator<String>(key.getUserIDs())) {
+            seenIds.add(saveUserId(rowId, userId, userIdRank));
+            ++userIdRank;
+        }
+
+        String seenIdsStr = "";
+        for (Integer id : seenIds) {
+            if (seenIdsStr.length() > 0) {
+                seenIdsStr += ",";
+            }
+            seenIdsStr += id;
+        }
+        mDb.delete(UserIds.TABLE_NAME,
+                   UserIds.KEY_ID + " = ? AND " +
+                   UserIds._ID + " NOT IN (" + seenIdsStr + ")",
+                   new String[] { "" + rowId });
+
+        return (int)rowId;
+    }
+
+    private int saveUserId(long keyId, String userId, int rank) throws GeneralException {
+        ContentValues values = new ContentValues();
+
+        values.put(UserIds.KEY_ID, keyId);
+        values.put(UserIds.USER_ID, userId);
+        values.put(UserIds.RANK, rank);
+
+        long rowId = insertOrUpdateUserId(values);
+
+        if (rowId == -1) {
+            throw new GeneralException("saving user id " + userId + " failed");
+        }
+
+        return (int)rowId;
+    }
+
+    private long insertOrUpdateKeyRing(ContentValues values) {
+        Cursor c = mDb.query(KeyRings.TABLE_NAME, new String[] { KeyRings._ID },
+                             KeyRings.MASTER_KEY_ID + " = ? AND " + KeyRings.TYPE + " = ?",
+                             new String[] {
+                                 values.getAsString(KeyRings.MASTER_KEY_ID),
+                                 values.getAsString(KeyRings.TYPE),
+                             },
+                             null, null, null);
+        long rowId = -1;
+        if (c != null && c.moveToFirst()) {
+            rowId = c.getLong(0);
+            mDb.update(KeyRings.TABLE_NAME, values,
+                       KeyRings._ID + " = ?", new String[] { "" + rowId });
+            mStatus = Id.return_value.updated;
+        } else {
+            rowId = mDb.insert(KeyRings.TABLE_NAME, KeyRings.WHO_ID, values);
+            mStatus = Id.return_value.ok;
+        }
+
+        if (c != null) {
+            c.close();
+        }
+
+        return rowId;
+    }
+
+    private long insertOrUpdateKey(ContentValues values) {
+        Cursor c = mDb.query(Keys.TABLE_NAME, new String[] { Keys._ID },
+                             Keys.KEY_ID + " = ? AND " + Keys.TYPE + " = ?",
+                             new String[] {
+                                 values.getAsString(Keys.KEY_ID),
+                                 values.getAsString(Keys.TYPE),
+                             },
+                             null, null, null);
+        long rowId = -1;
+        if (c != null && c.moveToFirst()) {
+            rowId = c.getLong(0);
+            mDb.update(Keys.TABLE_NAME, values,
+                       Keys._ID + " = ?", new String[] { "" + rowId });
+        } else {
+            rowId = mDb.insert(Keys.TABLE_NAME, Keys.KEY_DATA, values);
+        }
+
+        if (c != null) {
+            c.close();
+        }
+
+        return rowId;
+    }
+
+    private long insertOrUpdateUserId(ContentValues values) {
+        Cursor c = mDb.query(UserIds.TABLE_NAME, new String[] { UserIds._ID },
+                             UserIds.KEY_ID + " = ? AND " + UserIds.USER_ID + " = ?",
+                             new String[] {
+                                 values.getAsString(UserIds.KEY_ID),
+                                 values.getAsString(UserIds.USER_ID),
+                             },
+                             null, null, null);
+        long rowId = -1;
+        if (c != null && c.moveToFirst()) {
+            rowId = c.getLong(0);
+            mDb.update(UserIds.TABLE_NAME, values,
+                       UserIds._ID + " = ?", new String[] { "" + rowId });
+        } else {
+            rowId = mDb.insert(UserIds.TABLE_NAME, UserIds.USER_ID, values);
+        }
+
+        if (c != null) {
+            c.close();
+        }
+
+        return rowId;
+    }
+
+    public Object getKeyRing(int keyRingId) {
+        Cursor c = mDb.query(KeyRings.TABLE_NAME,
+                             new String[] { KeyRings.KEY_RING_DATA, KeyRings.TYPE },
+                             KeyRings._ID + " = ?",
+                             new String[] {
+                                 "" + keyRingId,
+                             },
+                             null, null, null);
+        byte[] data = null;
+        Object keyRing = null;
+        if (c != null && c.moveToFirst()) {
+            data = c.getBlob(0);
+            if (data != null) {
+                try {
+                    if (c.getInt(1) == Id.database.type_public) {
+                        keyRing = new PGPPublicKeyRing(data);
+                    } else {
+                        keyRing = new PGPSecretKeyRing(data);
+                    }
+                } catch (IOException e) {
+                    // can't load it, then
+                } catch (PGPException e) {
+                    // can't load it, then
+                }
+            }
+        }
+
+        if (c != null) {
+            c.close();
+        }
+
+        return keyRing;
+    }
+
+    public byte[] getKeyRingDataFromKeyId(int type, long keyId) {
+        Cursor c = mDb.query(Keys.TABLE_NAME + " INNER JOIN " + KeyRings.TABLE_NAME + " ON (" +
+                             KeyRings.TABLE_NAME + "." + KeyRings._ID + " = " +
+                             Keys.TABLE_NAME + "." + Keys.KEY_RING_ID + ")",
+                             new String[] { KeyRings.TABLE_NAME + "." + KeyRings.KEY_RING_DATA },
+                             Keys.TABLE_NAME + "." + Keys.KEY_ID + " = ? AND " +
+                             KeyRings.TABLE_NAME + "." + KeyRings.TYPE + " = ?",
+                             new String[] {
+                                 "" + keyId,
+                                 "" + type,
+                             },
+                             null, null, null);
+
+        byte[] data = null;
+        if (c != null && c.moveToFirst()) {
+            data = c.getBlob(0);
+        }
+
+        if (c != null) {
+            c.close();
+        }
+
+        return data;
+    }
+
+    public byte[] getKeyDataFromKeyId(int type, long keyId) {
+        Cursor c = mDb.query(Keys.TABLE_NAME, new String[] { Keys.KEY_DATA },
+                             Keys.KEY_ID + " = ? AND " + Keys.TYPE + " = ?",
+                             new String[] {
+                                 "" + keyId,
+                                 "" + type,
+                             },
+                             null, null, null);
+        byte[] data = null;
+        if (c != null && c.moveToFirst()) {
+            data = c.getBlob(0);
+        }
+
+        if (c != null) {
+            c.close();
+        }
+
+        return data;
+    }
+
+    public void deleteKeyRing(int keyRingId) {
+        mDb.beginTransaction();
+        mDb.delete(KeyRings.TABLE_NAME,
+                   KeyRings._ID + " = ?", new String[] { "" + keyRingId });
+
+        Cursor c = mDb.query(Keys.TABLE_NAME, new String[] { Keys._ID },
+                             Keys.KEY_RING_ID + " = ?",
+                             new String[] {
+                                 "" + keyRingId,
+                             },
+                                    null, null, null);
+        if (c != null && c.moveToFirst()) {
+            do {
+                int keyId = c.getInt(0);
+                deleteKey(keyId);
+            } while (c.moveToNext());
+        }
+
+        if (c != null) {
+            c.close();
+        }
+
+        mDb.setTransactionSuccessful();
+        mDb.endTransaction();
+    }
+
+    private void deleteKey(int keyId) {
+        mDb.delete(Keys.TABLE_NAME,
+                   Keys._ID + " = ?", new String[] { "" + keyId });
+
+        mDb.delete(UserIds.TABLE_NAME,
+                   UserIds.KEY_ID + " = ?", new String[] { "" + keyId });
+    }
+
+    public SQLiteDatabase db() {
+        return mDb;
+    }
+}
diff --git a/org_apg/src/org/apg/provider/KeyRings.java b/org_apg/src/org/apg/provider/KeyRings.java
new file mode 100644
index 000000000..304afd24f
--- /dev/null
+++ b/org_apg/src/org/apg/provider/KeyRings.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2010 Thialfihar <thi@thialfihar.org>
+ *
+ * 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 org.apg.provider;
+
+import android.provider.BaseColumns;
+
+public class KeyRings implements BaseColumns {
+    public static final String TABLE_NAME = "key_rings";
+
+    public static final String _ID_type = "INTEGER PRIMARY KEY";
+    public static final String MASTER_KEY_ID = "c_master_key_id";
+    public static final String MASTER_KEY_ID_type = "INT64";
+    public static final String TYPE = "c_type";
+    public static final String TYPE_type = "INTEGER";
+    public static final String WHO_ID = "c_who_id";
+    public static final String WHO_ID_type = "INTEGER";
+    public static final String KEY_RING_DATA = "c_key_ring_data";
+    public static final String KEY_RING_DATA_type = "BLOB";
+}
diff --git a/org_apg/src/org/apg/provider/Keys.java b/org_apg/src/org/apg/provider/Keys.java
new file mode 100644
index 000000000..63eaee54f
--- /dev/null
+++ b/org_apg/src/org/apg/provider/Keys.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2010 Thialfihar <thi@thialfihar.org>
+ *
+ * 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 org.apg.provider;
+
+import android.provider.BaseColumns;
+
+public class Keys implements BaseColumns {
+    public static final String TABLE_NAME = "keys";
+
+    public static final String _ID_type = "INTEGER PRIMARY KEY";
+    public static final String KEY_ID = "c_key_id";
+    public static final String KEY_ID_type = "INT64";
+    public static final String TYPE = "c_type";
+    public static final String TYPE_type = "INTEGER";
+    public static final String IS_MASTER_KEY = "c_is_master_key";
+    public static final String IS_MASTER_KEY_type = "INTEGER";
+    public static final String ALGORITHM = "c_algorithm";
+    public static final String ALGORITHM_type = "INTEGER";
+    public static final String KEY_SIZE = "c_key_size";
+    public static final String KEY_SIZE_type = "INTEGER";
+    public static final String CAN_SIGN = "c_can_sign";
+    public static final String CAN_SIGN_type = "INTEGER";
+    public static final String CAN_ENCRYPT = "c_can_encrypt";
+    public static final String CAN_ENCRYPT_type = "INTEGER";
+    public static final String IS_REVOKED = "c_is_revoked";
+    public static final String IS_REVOKED_type = "INTEGER";
+    public static final String CREATION = "c_creation";
+    public static final String CREATION_type = "INTEGER";
+    public static final String EXPIRY = "c_expiry";
+    public static final String EXPIRY_type = "INTEGER";
+    public static final String KEY_RING_ID = "c_key_ring_id";
+    public static final String KEY_RING_ID_type = "INTEGER";
+    public static final String KEY_DATA = "c_key_data";
+    public static final String KEY_DATA_type = "BLOB";
+    public static final String RANK = "c_key_data";
+    public static final String RANK_type = "INTEGER";
+}
diff --git a/org_apg/src/org/apg/provider/UserIds.java b/org_apg/src/org/apg/provider/UserIds.java
new file mode 100644
index 000000000..e8ddc677d
--- /dev/null
+++ b/org_apg/src/org/apg/provider/UserIds.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2010 Thialfihar <thi@thialfihar.org>
+ *
+ * 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 org.apg.provider;
+
+import android.provider.BaseColumns;
+
+public class UserIds implements BaseColumns {
+    public static final String TABLE_NAME = "user_ids";
+
+    public static final String _ID_type = "INTEGER PRIMARY KEY";
+    public static final String KEY_ID = "c_key_id";
+    public static final String KEY_ID_type = "INTEGER";
+    public static final String USER_ID = "c_user_id";
+    public static final String USER_ID_type = "TEXT";
+    public static final String RANK = "c_rank";
+    public static final String RANK_type = "INTEGER";
+}