diff --git a/services/syncbase/bridge/cgo/jni.go b/services/syncbase/bridge/cgo/jni.go
index 8e6dd82..c55c593 100644
--- a/services/syncbase/bridge/cgo/jni.go
+++ b/services/syncbase/bridge/cgo/jni.go
@@ -8,14 +8,21 @@
 package main
 
 import (
+	"fmt"
+	"os"
 	"unsafe"
 )
 
+// #include <stdlib.h>
 // #include "jni_wrapper.h"
+// #include "lib.h"
 import "C"
 
 var (
-	jVM *C.JavaVM
+	jVM            *C.JavaVM
+	arrayListClass jArrayListClass
+	idClass        jIdClass
+	verrorClass    jVErrorClass
 )
 
 // JNI_OnLoad is called when System.loadLibrary is called. We need to cache the
@@ -31,7 +38,26 @@
 		return C.JNI_ERR
 	}
 	jVM = vm
+
 	v23_syncbase_Init()
+
+	// We don't bother throwing errors in here because attempting to create
+	// an exception can also fail.
+	if arrayListClass.Init(env) != nil {
+		fmt.Fprintln(os.Stderr, "Error caching the ArrayList class")
+		return C.JNI_ERR
+	}
+
+	if idClass.Init(env) != nil {
+		fmt.Fprintln(os.Stderr, "Error caching the ID class")
+		return C.JNI_ERR
+	}
+
+	if verrorClass.Init(env) != nil {
+		fmt.Fprintln(os.Stderr, "Error caching the VError class")
+		return C.JNI_ERR
+	}
+
 	return C.JNI_VERSION_1_6
 }
 
@@ -39,8 +65,15 @@
 	return nil
 }
 func Java_io_v_syncbase_internal_Service_SetPermissions(env *C.JNIEnv, cls C.jclass, obj C.jobject) {}
+
+//export Java_io_v_syncbase_internal_Service_ListDatabases
 func Java_io_v_syncbase_internal_Service_ListDatabases(env *C.JNIEnv, cls C.jclass) C.jobject {
-	return nil
+	var cIds C.v23_syncbase_Ids
+	var cErr C.v23_syncbase_VError
+	v23_syncbase_ServiceListDatabases(&cIds, &cErr)
+	obj := C.NewObjectA(env, arrayListClass.class, arrayListClass.init, nil)
+	// TODO(razvanm): populate the obj based on the data from cIds.
+	return obj
 }
 
 func Java_io_v_syncbase_internal_Database_GetPermissions(env *C.JNIEnv, cls C.jclass, name C.jstring) C.jobject {
@@ -48,7 +81,35 @@
 }
 func Java_io_v_syncbase_internal_Database_SetPermissions(env *C.JNIEnv, cls C.jclass, name C.jstring, perms C.jobject) {
 }
+
+func throwException(env *C.JNIEnv, cErr *C.v23_syncbase_VError) {
+	obj := C.NewObjectA(env, verrorClass.class, verrorClass.init, nil)
+	if s, err := V23SStringToJString(env, cErr.id); err == nil {
+		C.SetObjectField(env, obj, verrorClass.id, s)
+	}
+	C.SetLongField(env, obj, verrorClass.actionCode, C.jlong(cErr.actionCode))
+	if s, err := V23SStringToJString(env, cErr.msg); err == nil {
+		C.SetObjectField(env, obj, verrorClass.message, s)
+	}
+	if s, err := V23SStringToJString(env, cErr.stack); err == nil {
+		C.SetObjectField(env, obj, verrorClass.stack, s)
+	}
+	C.Throw(env, obj)
+}
+
+//export Java_io_v_syncbase_internal_Database_Create
 func Java_io_v_syncbase_internal_Database_Create(env *C.JNIEnv, cls C.jclass, name C.jstring, perms C.jobject) {
+	cName, err := JStringToV23SString(env, name)
+	if err != nil {
+		return
+	}
+	var cErr C.v23_syncbase_VError
+	// TODO(razvanm): construct a proper C.v23_syncbase_Permissions based on
+	// the perms object.
+	v23_syncbase_DbCreate(cName, C.v23_syncbase_Permissions{}, &cErr)
+	if cErr.id.p != nil {
+		throwException(env, &cErr)
+	}
 }
 func Java_io_v_syncbase_internal_Database_Destroy(env *C.JNIEnv, cls C.jclass, name C.jstring) {}
 func Java_io_v_syncbase_internal_Database_Exists(env *C.JNIEnv, cls C.jclass, name C.jstring) C.jboolean {
diff --git a/services/syncbase/bridge/cgo/jni_lib.go b/services/syncbase/bridge/cgo/jni_lib.go
new file mode 100644
index 0000000..1c4e4c2
--- /dev/null
+++ b/services/syncbase/bridge/cgo/jni_lib.go
@@ -0,0 +1,89 @@
+// Copyright 2016 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build java android
+// +build cgo
+
+package main
+
+// #include <stdlib.h>
+// #include "jni_wrapper.h"
+// #include "lib.h"
+import "C"
+
+type jArrayListClass struct {
+	class C.jclass
+	init  C.jmethodID
+}
+
+func (c *jArrayListClass) Init(env *C.JNIEnv) error {
+	var err error
+	c.class, c.init, err = initClass(env, "java/util/ArrayList")
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+type jIdClass struct {
+	class C.jclass
+	init  C.jmethodID
+}
+
+func (c *jIdClass) Init(env *C.JNIEnv) error {
+	var err error
+	c.class, c.init, err = initClass(env, "io/v/syncbase/internal/Id")
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+type jVErrorClass struct {
+	class      C.jclass
+	init       C.jmethodID
+	id         C.jfieldID
+	actionCode C.jfieldID
+	message    C.jfieldID
+	stack      C.jfieldID
+}
+
+func (c *jVErrorClass) Init(env *C.JNIEnv) error {
+	var err error
+	c.class, c.init, err = initClass(env, "io/v/syncbase/internal/VError")
+	if err != nil {
+		return err
+	}
+	c.id, err = JGetFieldID(env, c.class, "id", "Ljava/lang/String;")
+	if err != nil {
+		return err
+	}
+	c.actionCode, err = JGetFieldID(env, c.class, "actionCode", "J")
+	if err != nil {
+		return err
+	}
+	c.message, err = JGetFieldID(env, c.class, "message", "Ljava/lang/String;")
+	if err != nil {
+		return err
+	}
+	c.stack, err = JGetFieldID(env, c.class, "stack", "Ljava/lang/String;")
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// initClass returns the jclass and the jmethodID of the default constructor for
+// a class.
+func initClass(env *C.JNIEnv, name string) (C.jclass, C.jmethodID, error) {
+	cls, err := JFindClass(env, name)
+	if err != nil {
+		return nil, nil, err
+	}
+	init, err := JGetMethodID(env, cls, "<init>", "()V")
+	if err != nil {
+		return nil, nil, err
+	}
+	return cls, init, nil
+}
diff --git a/services/syncbase/bridge/cgo/jni_util.go b/services/syncbase/bridge/cgo/jni_util.go
new file mode 100644
index 0000000..8d9c68a
--- /dev/null
+++ b/services/syncbase/bridge/cgo/jni_util.go
@@ -0,0 +1,133 @@
+// Copyright 2016 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build java android
+// +build cgo
+
+package main
+
+import (
+	"fmt"
+	"unsafe"
+)
+
+// #include <stdlib.h>
+// #include "jni_wrapper.h"
+// #include "lib.h"
+import "C"
+
+func JFindClass(env *C.JNIEnv, name string) (C.jclass, error) {
+	cName := C.CString(name)
+	defer C.free(unsafe.Pointer(cName))
+
+	class := C.FindClass(env, cName)
+	if C.ExceptionOccurred(env) != nil {
+		return nil, fmt.Errorf("couldn't find class %s", name)
+	}
+
+	globalRef := C.jclass(C.NewGlobalRef(env, class))
+	if globalRef == nil {
+		return nil, fmt.Errorf("couldn't allocate a global reference for class %s", name)
+	}
+	return globalRef, nil
+}
+
+func JGetMethodID(env *C.JNIEnv, cls C.jclass, name, sig string) (C.jmethodID, error) {
+	cName := C.CString(name)
+	defer C.free(unsafe.Pointer(cName))
+
+	cSig := C.CString(sig)
+	defer C.free(unsafe.Pointer(cSig))
+
+	method := C.GetMethodID(env, cls, cName, cSig)
+	if method == nil {
+		return nil, fmt.Errorf("couldn't get method %q with signature %s", name, sig)
+	}
+
+	// Note: the validity of the method is bounded by the lifetime of the
+	// ClassLoader that did the loading of the class.
+	return method, nil
+}
+
+func JGetFieldID(env *C.JNIEnv, cls C.jclass, name, sig string) (C.jfieldID, error) {
+	cName := C.CString(name)
+	defer C.free(unsafe.Pointer(cName))
+
+	cSig := C.CString(sig)
+	defer C.free(unsafe.Pointer(cSig))
+
+	field := C.GetFieldID(env, cls, cName, cSig)
+	if field == nil {
+		return nil, fmt.Errorf("couldn't get field %q with signature ", name, sig)
+	}
+
+	// Note: the validity of the field is bounded by the lifetime of the
+	// ClassLoader that did the loading of the class.
+	return field, nil
+}
+
+// V23SStringToJString constructs a C.jstring from a C.v23_syncbase_String. The
+// code is somewhat complicated and inefficient because the NewStringUTF from
+// JNI only works with modified UTF-8 strings (inner nulls are encoded as 0xC0,
+// 0x80 and the string is terminated with a null).
+func V23SStringToJString(env *C.JNIEnv, src C.v23_syncbase_String) (C.jstring, error) {
+	n := int(src.n)
+	srcPtr := uintptr(unsafe.Pointer(src.p))
+	numNulls := 0
+	for i := 0; i < n; i++ {
+		if *(*byte)(unsafe.Pointer(srcPtr + uintptr(i))) == 0 {
+			numNulls++
+		}
+	}
+	tmp := C.malloc(C.size_t(n + numNulls + 1))
+	defer C.free(tmp)
+	tmpPtr := uintptr(tmp)
+	j := 0
+	for i := 0; i < n; i, j = i+1, j+1 {
+		if *(*byte)(unsafe.Pointer(srcPtr + uintptr(i))) != 0 {
+			*(*byte)(unsafe.Pointer(tmpPtr + uintptr(j))) = *(*byte)(unsafe.Pointer(srcPtr + uintptr(i)))
+			continue
+		}
+		*(*byte)(unsafe.Pointer(tmpPtr + uintptr(j))) = 0xC0
+		j++
+		*(*byte)(unsafe.Pointer(tmpPtr + uintptr(j))) = 0x80
+	}
+	*(*byte)(unsafe.Pointer(tmpPtr + uintptr(j))) = 0
+	r := C.NewStringUTF(env, (*C.char)(tmp))
+	if C.ExceptionOccurred(env) != nil {
+		panic("NewStringUTF OutOfMemoryError exception")
+	}
+	return r, nil
+}
+
+// JStringToV23SString creates a v23_syncbase_String from a jstring. This is the
+// revert of the V23SStringToJString.
+func JStringToV23SString(env *C.JNIEnv, s C.jstring) (C.v23_syncbase_String, error) {
+	r := C.v23_syncbase_String{}
+	r.n = C.int(C.GetStringUTFLength(env, s))
+	r.p = (*C.char)(C.malloc(C.size_t(r.n)))
+	p := uintptr(unsafe.Pointer(r.p))
+	// Note that GetStringUTFLength does not include a trailing zero.
+	n := int(C.GetStringUTFLength(env, s))
+	C.GetStringUTFRegion(env, s, 0, C.GetStringLength(env, s), r.p)
+	// We don't have to check for exceptions because GetStringUTFRegion can
+	// only throw StringIndexOutOfBoundsException and we know the requested
+	// amount of characters is valid.
+	j := 0
+	for i := 0; i < n; i, j = i+1, j+1 {
+		if i+1 < n && *(*byte)(unsafe.Pointer(p + uintptr(i))) == 0xC0 && *(*byte)(unsafe.Pointer(p + uintptr(i+1))) == 0x80 {
+			*(*byte)(unsafe.Pointer(p + uintptr(j))) = 0
+			i++
+			continue
+		}
+
+		if j == i {
+			continue
+		}
+
+		*(*byte)(unsafe.Pointer(p + uintptr(j))) = *(*byte)(unsafe.Pointer(p + uintptr(i)))
+	}
+	r.p = (*C.char)(C.realloc(unsafe.Pointer(r.p), (C.size_t)(j)))
+	return r, nil
+}
diff --git a/services/syncbase/bridge/cgo/jni_wrapper.c b/services/syncbase/bridge/cgo/jni_wrapper.c
index 65d0bfd..d3cb147 100644
--- a/services/syncbase/bridge/cgo/jni_wrapper.c
+++ b/services/syncbase/bridge/cgo/jni_wrapper.c
@@ -6,6 +6,66 @@
 
 #include "jni_wrapper.h"
 
+void ExceptionClear(JNIEnv *env) {
+  (*env)->ExceptionClear(env);
+}
+
+jthrowable ExceptionOccurred(JNIEnv* env) {
+  return (*env)->ExceptionOccurred(env);
+}
+
+jclass FindClass(JNIEnv* env, const char* name) {
+  return (*env)->FindClass(env, name);
+}
+
 jint GetEnv(JavaVM* jvm, JNIEnv** env, jint version) {
-    return (*jvm)->GetEnv(jvm, (void**)env, version);
+  return (*jvm)->GetEnv(jvm, (void**)env, version);
+}
+
+jfieldID GetFieldID(JNIEnv *env, jclass cls, const char *name, const char *sig) {
+  return (*env)->GetFieldID(env, cls, name, sig);
+}
+
+jmethodID GetMethodID(JNIEnv* env, jclass cls, const char* name, const char* args) {
+  return (*env)->GetMethodID(env, cls, name, args);
+}
+
+jsize GetStringLength(JNIEnv *env, jstring string) {
+  return (*env)->GetStringLength(env, string);
+}
+
+jsize GetStringUTFLength(JNIEnv *env, jstring string) {
+  return (*env)->GetStringLength(env, string);
+}
+
+void GetStringUTFRegion(JNIEnv *env, jstring str, jsize start, jsize len, char *buf) {
+  (*env)->GetStringUTFRegion(env, str, start, len, buf);
+}
+
+jobject NewGlobalRef(JNIEnv* env, jobject obj) {
+  return (*env)->NewGlobalRef(env, obj);
+}
+
+jobject NewObjectA(JNIEnv *env, jclass cls, jmethodID methodID, jvalue *args) {
+  return (*env)->NewObjectA(env, cls, methodID, args);
+}
+
+void SetLongField(JNIEnv *env, jobject obj, jfieldID fieldID, jlong value) {
+  (*env)->SetLongField(env, obj, fieldID, value);
+}
+
+jstring NewStringUTF(JNIEnv *env, const char *bytes) {
+  return (*env)->NewStringUTF(env, bytes);
+}
+
+void SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value) {
+  (*env)->SetObjectField(env, obj, fieldID, value);
+}
+
+jint Throw(JNIEnv *env, jthrowable obj) {
+  return (*env)->Throw(env, obj);
+}
+
+jint ThrowNew(JNIEnv *env, jclass cls, const char *message) {
+  return (*env)->ThrowNew(env, cls, message);
 }
\ No newline at end of file
diff --git a/services/syncbase/bridge/cgo/jni_wrapper.h b/services/syncbase/bridge/cgo/jni_wrapper.h
index 9300020..ab15784 100644
--- a/services/syncbase/bridge/cgo/jni_wrapper.h
+++ b/services/syncbase/bridge/cgo/jni_wrapper.h
@@ -4,6 +4,25 @@
 
 // +build java android cgo
 
+// All JNI functions are function pointers of a JNIEnv variable. Go language
+// cannot call function pointers so we need use some wrapper functions to do
+// that.
+
 #include "jni.h"
 
-jint GetEnv(JavaVM* jvm, JNIEnv** env, jint version);
\ No newline at end of file
+void ExceptionClear(JNIEnv *env);
+jthrowable ExceptionOccurred(JNIEnv* env);
+jclass FindClass(JNIEnv* env, const char* name);
+jint GetEnv(JavaVM* jvm, JNIEnv** env, jint version);
+jfieldID GetFieldID(JNIEnv *env, jclass cls, const char *name, const char *sig);
+jmethodID GetMethodID(JNIEnv* env, jclass cls, const char* name, const char* sig);
+jsize GetStringLength(JNIEnv *env, jstring string);
+jsize GetStringUTFLength(JNIEnv *env, jstring string);
+void GetStringUTFRegion(JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
+jobject NewGlobalRef(JNIEnv* env, jobject obj);
+jobject NewObjectA(JNIEnv *env, jclass cls, jmethodID methodID, jvalue *args);
+jstring NewStringUTF(JNIEnv *env, const char *bytes);
+void SetLongField(JNIEnv *env, jobject obj, jfieldID fieldID, jlong value);
+void SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value);
+jint Throw(JNIEnv *env, jthrowable obj);
+jint ThrowNew(JNIEnv *env, jclass cls, const char *message);
\ No newline at end of file