track union/struct change. (pas_book_queue_remove_card): same.

2002-03-07  Chris Toshok  <toshok@ximian.com>

	* backend/pas/pas-book.c (pas_book_queue_create_card): track
	union/struct change.
	(pas_book_queue_remove_card): same.
	(pas_book_queue_modify_card): same.
	(pas_book_queue_get_cursor): same.
	(pas_book_queue_get_vcard): same.
	(pas_book_queue_authenticate_user): same.
	(pas_book_queue_get_book_view): same.
	(pas_book_queue_get_changes): same.
	(pas_book_free_request): new function - free everything we need to
	for each type of request.
	(pas_book_destroy): call pas_book_free_request here instead of
	just freeing 3 elements of the old struct.  yay plugging memleaks.

	* backend/pas/pas-book.h: make PASRequest a union and split out
	members into structs, so it's a little clearer which fields are
	used by which requests.  Also, add prototype for
	pas_book_free_request so backends can just free everything at once
	(usually in their requests_queued signal func.)

	* backend/pas/pas-backend-file.c
	(pas_backend_file_process_create_card): track struct/union change.
	(pas_backend_file_process_remove_card): same.
	(pas_backend_file_process_modify_card): same.
	(pas_backend_file_build_cards_list): same.
	(pas_backend_file_process_get_vcard): same.
	(pas_backend_file_process_get_cursor): same.
	(pas_backend_file_process_get_book_view): same.
	(pas_backend_file_process_get_changes): same.
	(pas_backend_file_process_check_connection): same.
	(pas_backend_file_process_authenticate_user): same.
	(pas_backend_file_process_get_supported_fields): same.
	(pas_backend_file_process_client_requests): case the union to the
	specific struct and pass it to the process_* functions.  also,
	call pas_book_free_request here, instead of relying on each of the
	functions to free their stuff.

svn path=/trunk/; revision=15987

4 files changed, 1097 insertions, 713 deletions

diff --git a/addressbook/backend/pas/pas-backend-file.c b/addressbook/backend/pas/pas-backend-file.c
index 057012ddaa..acca404ad8 100644
--- a/addressbook/backend/pas/pas-backend-file.c
+++ b/addressbook/backend/pas/pas-backend-file.c
@@ -535,7 +535,7 @@ do_create(PASBackend *backend,
 static void
 pas_backend_file_process_create_card (PASBackend *backend,
 				      PASBook    *book,
-				      PASRequest *req)
+				      PASCreateCardRequest *req)
 {
 	char *id;
 	char *vcard;
@@ -577,7 +577,7 @@ pas_backend_file_process_create_card (PASBackend *backend,
 static void
 pas_backend_file_process_remove_card (PASBackend *backend,
 				      PASBook    *book,
-				      PASRequest *req)
+				      PASRemoveCardRequest *req)
 {
 	PASBackendFile *bf = PAS_BACKEND_FILE (backend);
 	DB             *db = bf->priv->file_db;
@@ -636,7 +636,7 @@ pas_backend_file_process_remove_card (PASBackend *backend,
 static void
 pas_backend_file_process_modify_card (PASBackend *backend,
 				      PASBook    *book,
-				      PASRequest *req)
+				      PASModifyCardRequest *req)
 {
 	PASBackendFile *bf = PAS_BACKEND_FILE (backend);
 	DB             *db = bf->priv->file_db;
@@ -671,7 +671,6 @@ pas_backend_file_process_modify_card (PASBackend *backend,
 		pas_book_respond_modify (
 				 book,
 				 GNOME_Evolution_Addressbook_BookListener_CardNotFound);
-		g_free (req->id);
 		return;
 	}
 	old_vcard_string = g_strdup(vcard_dbt.data);
@@ -728,8 +727,8 @@ pas_backend_file_process_modify_card (PASBackend *backend,
 
 static void
 pas_backend_file_build_cards_list(PASBackend *backend,
-				      PASBackendFileCursorPrivate *cursor_data,
-				      char *search)
+				  PASBackendFileCursorPrivate *cursor_data,
+				  char *search)
 {
 	PASBackendFile *bf = PAS_BACKEND_FILE (backend);
 	DB             *db = bf->priv->file_db;
@@ -788,7 +787,7 @@ pas_backend_file_build_cards_list(PASBackend *backend,
 static void
 pas_backend_file_process_get_vcard (PASBackend *backend,
 				    PASBook    *book,
-				    PASRequest *req)
+				    PASGetVCardRequest *req)
 {
 	PASBackendFile *bf;
 	DB             *db;
@@ -821,7 +820,7 @@ pas_backend_file_process_get_vcard (PASBackend *backend,
 static void
 pas_backend_file_process_get_cursor (PASBackend *backend,
 				     PASBook    *book,
-				     PASRequest *req)
+				     PASGetCursorRequest *req)
 {
 	/*
 	  PASBackendFile *bf = PAS_BACKEND_FILE (backend);
@@ -871,10 +870,9 @@ pas_backend_file_process_get_cursor (PASBackend *backend,
 static void
 pas_backend_file_process_get_book_view (PASBackend *backend,
 					PASBook    *book,
-					PASRequest *req)
+					PASGetBookViewRequest *req)
 {
 	PASBackendFile *bf = PAS_BACKEND_FILE (backend);
-	CORBA_Environment ev;
 	PASBookView       *book_view;
 	PASBackendFileBookView view;
 	EIterator *iterator;
@@ -889,7 +887,7 @@ pas_backend_file_process_get_book_view (PASBackend *backend,
 			   GTK_SIGNAL_FUNC(view_destroy), book);
 
 	view.book_view = book_view;
-	view.search = req->search;
+	view.search = g_strdup (req->search);
 	view.card_sexp = NULL;
 	view.change_id = NULL;
 	view.change_context = NULL;	
@@ -906,25 +904,12 @@ pas_backend_file_process_get_book_view (PASBackend *backend,
 	e_iterator_last(iterator);
 	pas_backend_file_search (bf, book, e_iterator_get(iterator));
 	gtk_object_unref(GTK_OBJECT(iterator));
-
-	g_free(req->search);
-	CORBA_exception_init(&ev);
-
-	bonobo_object_unref (BONOBO_OBJECT (book_view));
-	bonobo_object_release_unref (req->listener, &ev);
-	
-	if (ev._major != CORBA_NO_EXCEPTION) {
-		g_warning("pas_backend_file_process_get_book_view: Exception unreffing "
-			  "listener.\n");
-	}
-
-	CORBA_exception_free(&ev);
 }
 
 static void
 pas_backend_file_process_get_changes (PASBackend *backend,
 				      PASBook    *book,
-				      PASRequest *req)
+				      PASGetChangesRequest *req)
 {
 	PASBackendFile *bf = PAS_BACKEND_FILE (backend);
 	CORBA_Environment ev;
@@ -967,7 +952,7 @@ pas_backend_file_process_get_changes (PASBackend *backend,
 	pas_backend_file_changes (bf, book, e_iterator_get(iterator));
 	gtk_object_unref(GTK_OBJECT(iterator));
 
-	g_free(req->search);
+	g_free(req->change_id);
 	CORBA_exception_init(&ev);
 	bonobo_object_release_unref (req->listener, &ev);
 	
@@ -982,7 +967,7 @@ pas_backend_file_process_get_changes (PASBackend *backend,
 static void
 pas_backend_file_process_check_connection (PASBackend *backend,
 					   PASBook    *book,
-					   PASRequest *req)
+					   PASCheckConnectionRequest *req)
 {
 	PASBackendFile *bf = PAS_BACKEND_FILE (backend);
 
@@ -1000,7 +985,7 @@ pas_backend_file_extract_path_from_uri (const char *uri)
 static void
 pas_backend_file_process_authenticate_user (PASBackend *backend,
 					    PASBook    *book,
-					    PASRequest *req)
+					    PASAuthenticateUserRequest *req)
 {
 	pas_book_respond_authenticate_user (book,
 					    GNOME_Evolution_Addressbook_BookListener_Success);
@@ -1009,7 +994,7 @@ pas_backend_file_process_authenticate_user (PASBackend *backend,
 static void
 pas_backend_file_process_get_supported_fields (PASBackend *backend,
 					       PASBook    *book,
-					       PASRequest *req)
+					       PASGetSupportedFieldsRequest *req)
 {
 	EList *fields = e_list_new ((EListCopyFunc)g_strdup, (EListFreeFunc)g_free, NULL);
 	ECardSimple *simple;
@@ -1047,47 +1032,47 @@ pas_backend_file_process_client_requests (PASBook *book)
 
 	switch (req->op) {
 	case CreateCard:
-		pas_backend_file_process_create_card (backend, book, req);
+		pas_backend_file_process_create_card (backend, book, (PASCreateCardRequest*)req);
 		break;
 
 	case RemoveCard:
-		pas_backend_file_process_remove_card (backend, book, req);
+		pas_backend_file_process_remove_card (backend, book, (PASRemoveCardRequest*)req);
 		break;
 
 	case ModifyCard:
-		pas_backend_file_process_modify_card (backend, book, req);
+		pas_backend_file_process_modify_card (backend, book, (PASModifyCardRequest*)req);
 		break;
 
 	case CheckConnection:
-		pas_backend_file_process_check_connection (backend, book, req);
+		pas_backend_file_process_check_connection (backend, book, (PASCheckConnectionRequest*)req);
 		break;
 
 	case GetVCard:
-		pas_backend_file_process_get_vcard (backend, book, req);
+		pas_backend_file_process_get_vcard (backend, book, (PASGetVCardRequest*)req);
 		break;
 		
 	case GetCursor:
-		pas_backend_file_process_get_cursor (backend, book, req);
+		pas_backend_file_process_get_cursor (backend, book, (PASGetCursorRequest*)req);
 		break;
 		
 	case GetBookView:
-		pas_backend_file_process_get_book_view (backend, book, req);
+		pas_backend_file_process_get_book_view (backend, book, (PASGetBookViewRequest*)req);
 		break;
 
 	case GetChanges:
-		pas_backend_file_process_get_changes (backend, book, req);
+		pas_backend_file_process_get_changes (backend, book, (PASGetChangesRequest*)req);
 		break;
 
 	case AuthenticateUser:
-		pas_backend_file_process_authenticate_user (backend, book, req);
+		pas_backend_file_process_authenticate_user (backend, book, (PASAuthenticateUserRequest*)req);
 		break;
 
 	case GetSupportedFields:
-		pas_backend_file_process_get_supported_fields (backend, book, req);
+		pas_backend_file_process_get_supported_fields (backend, book, (PASGetSupportedFieldsRequest*)req);
 		break;
 	}
 
-	g_free (req);
+	pas_book_free_request (req);
 }
 
 static void
diff --git a/addressbook/backend/pas/pas-backend-ldap.c b/addressbook/backend/pas/pas-backend-ldap.c
index 6a98246257..aebe05d98d 100644
--- a/addressbook/backend/pas/pas-backend-ldap.c
+++ b/addressbook/backend/pas/pas-backend-ldap.c
@@ -10,8 +10,6 @@
 
 #include "config.h"  
 #include <fcntl.h>
-#include <time.h>
-#include <lber.h>
 #include <gtk/gtksignal.h>
 
 #include <libgnome/gnome-defs.h>
@@ -33,7 +31,7 @@
 #endif
 
 #ifdef OPENLDAP2
-#include "ldap_schema.h"
+#include <ldap_schema.h>
 #endif
 
 #include <sys/time.h>
@@ -49,8 +47,6 @@
 #include <stdlib.h>
 
 
-#define LDAP_MAX_SEARCH_RESPONSES 100
-
 /* interval for our poll_ldap timeout */
 #define LDAP_POLL_INTERVAL 20
 
@@ -85,11 +81,16 @@ struct _PASBackendLDAPPrivate {
 	char     *uri;
 	gboolean connected;
 	GList    *clients;
-	gchar    *ldap_host;
-	gchar    *ldap_rootdn;
-	int      ldap_port;
-	int      ldap_scope;
-	int      ldap_limit;
+
+	gchar    *ldap_host;   /* the hostname of the server */
+	int      ldap_port;    /* the port of the server */
+	char     *schema_dn;   /* the base dn for schema information */
+	gchar    *ldap_rootdn; /* the base dn of our searches */
+	int      ldap_scope;   /* the scope used for searches */
+	int      ldap_limit;   /* the search limit */
+
+	gboolean ldap_v3;      /* TRUE if the server supports protocol
+                                  revision 3 (necessary for TLS) */
 	GList    *book_views;
 
 	LDAP     *ldap;
@@ -99,14 +100,14 @@ struct _PASBackendLDAPPrivate {
 	/* whether or not there's support for the objectclass we need
            to store all our additional fields */
 	gboolean evolutionPersonSupported;
-	gboolean evolutionPersonChecked;
+	gboolean schema_checked;
 
 	gboolean writable;
 
-	/* whether or not there's a request in process on our LDAP* */
-	LDAPOp *current_op;
-	GList *pending_ops;
-	int op_idle;
+	/* our operations */
+	GHashTable *id_to_op;
+	int active_ops;
+	int                   poll_timeout;
 };
 
 struct _PASBackendLDAPCursorPrivate {
@@ -122,25 +123,12 @@ struct _PASBackendLDAPBookView {
 	PASBackendLDAPPrivate *blpriv;
 	gchar                 *search;
 	PASBackendCardSExp    *card_sexp;
-	int                   search_timeout;
-	int                   search_msgid;
-	LDAPOp                *search_op;
-
-	/* grouping stuff */
 
-	GList    *pending_adds;        /* the cards we're sending */
-	int       num_pending_adds;    /* the number waiting to be sent */
-	int       target_pending_adds; /* the cutoff that forces a flush to the client, if it happens before the timeout */
-	int       num_sent_this_time;  /* the number of cards we sent to the client before the most recent timeout */
-	int       num_sent_last_time;  /* the number of cards we sent to the client before the previous timeout */
-	glong     grouping_time_start;
-	
-	/* used by poll_ldap to only send the status messages once */
-	gboolean notified_receiving_results;
+	LDAPOp                *search_op;
 };
 
-typedef gboolean (*LDAPOpHandler)(PASBackend *backend, LDAPOp *op);
-typedef void (*LDAPOpDtor)(PASBackend *backend, LDAPOp *op);
+typedef void (*LDAPOpHandler)(LDAPOp *op, LDAPMessage *res);
+typedef void (*LDAPOpDtor)(LDAPOp *op);
 
 struct LDAPOp {
 	LDAPOpHandler handler;
@@ -148,15 +136,17 @@ struct LDAPOp {
 	PASBackend    *backend;
 	PASBook       *book;
 	PASBookView   *view;
+	int            id;
 };
 
-static void     ldap_op_init (LDAPOp *op, PASBackend *backend, PASBook *book, PASBookView *view, LDAPOpHandler handler, LDAPOpDtor dtor);
-static void     ldap_op_process_current (PASBackend *backend);
-static void     ldap_op_process (LDAPOp *op);
-static void     ldap_op_restart (LDAPOp *op);
-static gboolean ldap_op_process_on_idle (PASBackend *backend);
+static void     ldap_op_add (LDAPOp *op, PASBackend *backend, PASBook *book,
+			     PASBookView *view, int id, LDAPOpHandler handler, LDAPOpDtor dtor);
 static void     ldap_op_finished (LDAPOp *op);
 
+static void     ldap_search_op_timeout (LDAPOp *op, glong cur_millis);
+
+static gboolean poll_ldap (PASBackendLDAP *bl);
+
 static ECardSimple *build_card_from_entry (LDAP *ldap, LDAPMessage *e, GList **existing_objectclasses);
 
 static void email_populate (ECardSimple *card, char **values);
@@ -274,6 +264,13 @@ struct prop_info {
 static int num_prop_infos = sizeof(prop_info) / sizeof(prop_info[0]);
 
 static void
+remove_view (int msgid, LDAPOp *op, PASBookView *view)
+{
+	if (op->view == view)
+		op->view = NULL;
+}
+
+static void
 view_destroy(GtkObject *object, gpointer data)
 {
 	CORBA_Environment ev;
@@ -286,26 +283,13 @@ view_destroy(GtkObject *object, gpointer data)
 	for (list = bl->priv->book_views; list; list = g_list_next(list)) {
 		PASBackendLDAPBookView *view = list->data;
 		if (view->book_view == PAS_BOOK_VIEW(object)) {
-			if (view->search_timeout != 0) {
-				/* we have a search running on the
-				   ldap connection.  remove the timeout
-				   handler and anbandon the msg id */
-				g_source_remove(view->search_timeout);
-				if (view->search_msgid != -1)
-					ldap_abandon (bl->priv->ldap, view->search_msgid);
-
-				/* if the search op is the current op,
-				   finish it. else, remove it from the
-				   list and nuke it ourselves. */
-				if (view->search_op == bl->priv->current_op)
-					ldap_op_finished (view->search_op);
-				else {
-					bl->priv->pending_ops = g_list_remove (bl->priv->pending_ops,
-									       view->search_op);
-					view->search_op->dtor (view->search_op->backend,
-							       view->search_op);
-				}
-			}
+			/* if we have an active search, interrupt it */
+			if (view->search_op)
+				ldap_op_finished (view->search_op);
+			/* and remove us as the view for any other
+                           operations that might be using us to spew
+                           status messages to the gui */
+			g_hash_table_foreach (bl->priv->id_to_op, (GHFunc)remove_view, view->book_view);
 			g_free (view->search);
 			gtk_object_unref (GTK_OBJECT (view->card_sexp));
 			g_free (view);
@@ -379,12 +363,15 @@ check_schema_support (PASBackendLDAP *bl)
 	LDAPMessage *resp;
 	LDAP *ldap = bl->priv->ldap;
 
-	bl->priv->evolutionPersonChecked = TRUE;
+	if (!bl->priv->schema_dn)
+		return;
+
+	bl->priv->schema_checked = TRUE;
 
 	attrs[0] = "objectClasses";
 	attrs[1] = NULL;
 
-	if (ldap_search_ext_s (ldap, "cn=Subschema", LDAP_SCOPE_BASE,
+	if (ldap_search_ext_s (ldap, bl->priv->schema_dn, LDAP_SCOPE_BASE,
 			       "(objectClass=subschema)", attrs, 0,
 			       NULL, NULL, NULL, 0, &resp) == LDAP_SUCCESS) {
 		char **values;
@@ -422,6 +409,120 @@ check_schema_support (PASBackendLDAP *bl)
 }
 
 static void
+get_ldap_library_info ()
+{
+	LDAPAPIInfo info;
+	LDAP *ldap;
+
+	if (LDAP_SUCCESS != ldap_create (&ldap)) {
+		g_warning ("couldn't create LDAP* for getting at the client lib api info");
+		return;
+	}
+
+	info.ldapai_info_version = LDAP_API_INFO_VERSION;
+
+	if (LDAP_OPT_SUCCESS != ldap_get_option (ldap, LDAP_OPT_API_INFO, &info)) {
+		g_warning ("couldn't get ldap api info");
+	}
+	else {
+		int i;
+		g_message ("libldap vendor/version: %s %2d.%02d.%02d",
+			   info.ldapai_vendor_name,
+			   info.ldapai_vendor_version / 10000,
+			   (info.ldapai_vendor_version % 10000) / 1000,
+			   info.ldapai_vendor_version % 1000);
+
+		g_message ("extensions present:");
+		for (i = 0; info.ldapai_extensions[i]; i++) {
+			char *extension = info.ldapai_extensions[i];
+			g_message (extension);
+		}
+	}
+
+	ldap_unbind_ext_s (ldap, NULL, NULL);
+}
+
+static void
+query_ldap_root_dse (PASBackendLDAP *bl)
+{
+#define MAX_DSE_ATTRS 20
+	LDAP *ldap = bl->priv->ldap;
+	LDAPMessage *resp;
+	int ldap_error;
+	char *attrs[MAX_DSE_ATTRS], **values;
+	int i = 0;
+	struct timeval timeout;
+
+	attrs[i++] = "supportedControl";
+	attrs[i++] = "supportedExtension";
+	attrs[i++] = "supportedFeatures";
+	attrs[i++] = "supportedSASLMechanisms";
+	attrs[i++] = "supportedLDAPVersion";
+	attrs[i++] = "subschemaSubentry"; /* OpenLDAP's dn for schema information */
+	attrs[i++] = "schemaNamingContext"; /* Active directory's dn for schema information */
+	attrs[i] = NULL;
+
+	timeout.tv_sec = 0;
+	timeout.tv_usec = LDAP_RESULT_TIMEOUT_MILLIS * 1000;
+
+	ldap_error = ldap_search_ext_s (ldap,
+					LDAP_ROOT_DSE, LDAP_SCOPE_BASE,
+					"(objectclass=*)",
+					attrs, 0, NULL, NULL, NULL, 0, &resp);
+	if (ldap_error != LDAP_SUCCESS) {
+		g_warning ("could not perform query on Root DSE");
+		return;
+	}
+
+	values = ldap_get_values (ldap, resp, "supportedControl");
+	if (values) {
+		for (i = 0; values[i]; i++)
+			g_message ("supported server control: %s", values[i]);
+		ldap_value_free (values);
+	}
+
+	values = ldap_get_values (ldap, resp, "supportedExtension");
+	if (values) {
+		for (i = 0; values[i]; i++) {
+			g_message ("supported server extension: %s", values[i]);
+			if (!strcmp (values[i], LDAP_EXOP_START_TLS)) {
+				g_message ("server reports LDAP_EXOP_START_TLS");
+			}
+		}
+		ldap_value_free (values);
+	}
+
+	values = ldap_get_values (ldap, resp, "supportedSASLMechanisms");
+	if (values) {
+		for (i = 0; values[i]; i++)
+			g_message ("supported SASL mechanism: %s", values[i]);
+		ldap_value_free (values);
+	}
+
+
+	values = ldap_get_values (ldap, resp, "supportedLDAPVersion");
+	if (values) {
+		for (i = 0; values[i]; i++)
+			if (LDAP_VERSION3 == atoi (values[i]))
+				bl->priv->ldap_v3 = TRUE;
+		ldap_value_free (values);
+	}
+
+	values = ldap_get_values (ldap, resp, "subschemaSubentry");
+	if (!values || !values[0])
+		values = ldap_get_values (ldap, resp, "schemaNamingContext");
+	if (values || values[0]) {
+		bl->priv->schema_dn = g_strdup (values[0]);
+	}
+	else {
+		g_warning ("could not determine location of schema information on LDAP server");
+	}
+	if (values)
+		ldap_value_free (values);
+
+}
+
+static void
 pas_backend_ldap_connect (PASBackendLDAP *bl)
 {
 	PASBackendLDAPPrivate *blpriv = bl->priv;
@@ -433,14 +534,42 @@ pas_backend_ldap_connect (PASBackendLDAP *bl)
 	blpriv->ldap = ldap_init (blpriv->ldap_host, blpriv->ldap_port);
 #ifdef DEBUG
 	{
-		int debug_level = ~0;
+		int debug_level = 4;
 		ldap_set_option (blpriv->ldap, LDAP_OPT_DEBUG_LEVEL, &debug_level);
 	}
 #endif
 
 	if (NULL != blpriv->ldap) {
-		ldap_simple_bind_s(blpriv->ldap,
-				   NULL /*binddn*/, NULL /*passwd*/);
+		int ldap_error;
+		query_ldap_root_dse (bl);
+
+		if (bl->priv->ldap_v3) {
+			int protocol_version = LDAP_VERSION3;
+			ldap_error = ldap_set_option (blpriv->ldap, LDAP_OPT_PROTOCOL_VERSION, &protocol_version);
+			if (LDAP_OPT_SUCCESS != ldap_error) {
+				g_warning ("failed to set protocol version to LDAPv3");
+				bl->priv->ldap_v3 = FALSE;
+			}
+		}
+
+#if notyet
+		if (TRUE /* the user wants to use TLS */) {
+			if (bl->priv->ldap_v3 /* the server supports v3 */) {
+				ldap_error = ldap_start_tls_s (blpriv->ldap, NULL, NULL);
+				if (LDAP_SUCCESS != ldap_error) {
+					g_warning ("ldap_start_tls_s failed with ldap_error 0x%2x (%s)",
+						   ldap_error,
+						   ldap_err2string (ldap_error));
+				}
+				else
+					g_message ("TLS active");
+			}
+			else {
+				g_warning ("user wants to use TLS, but server doesn't support LDAPv3");
+			}
+		}
+#endif
+
 		blpriv->connected = TRUE;
 
 		/* check to see if evolutionPerson is supported, if we can (me
@@ -456,141 +585,67 @@ pas_backend_ldap_connect (PASBackendLDAP *bl)
 			   blpriv->ldap_rootdn ? blpriv->ldap_rootdn : "");
 		blpriv->connected = FALSE;
 	}
-
-}
-
-static ECardSimple *
-search_for_dn_with_objectclasses (PASBackendLDAP *bl, const char *dn, GList **existing_objectclasses)
-{
-	LDAP *ldap = bl->priv->ldap;
-	LDAPMessage    *res, *e;
-	ECardSimple *result = NULL;
-
-	if (ldap_search_s (ldap,
-			   dn,
-			   LDAP_SCOPE_BASE,
-			   "(objectclass=*)",
-			   NULL, 0, &res) == LDAP_SUCCESS) {
-		e = ldap_first_entry (ldap, res);
-		while (NULL != e) {
-			if (!strcmp (ldap_get_dn (ldap, e), dn)) {
-				printf ("found it\n");
-				result = build_card_from_entry (ldap, e, existing_objectclasses);
-				break;
-			}
-			e = ldap_next_entry (ldap, e);
-		}
-
-		ldap_msgfree(res);
-	}
-
-	return result;
-}
-
-static ECardSimple *
-search_for_dn (PASBackendLDAP *bl, const char *dn)
-{
-	return search_for_dn_with_objectclasses (bl, dn, NULL);
 }
 
 static void
-ldap_op_init (LDAPOp *op, PASBackend *backend,
-	      PASBook *book, PASBookView *view,
-	      LDAPOpHandler handler, LDAPOpDtor dtor)
+ldap_op_add (LDAPOp *op, PASBackend *backend,
+	     PASBook *book, PASBookView *view,
+	     int id,
+	     LDAPOpHandler handler, LDAPOpDtor dtor)
 {
+	PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
+
 	op->backend = backend;
 	op->book = book;
 	op->view = view;
+	op->id = id;
 	op->handler = handler;
 	op->dtor = dtor;
-}
-
-static void
-ldap_op_process_current (PASBackend *backend)
-{
-	PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
-	LDAPOp *op = bl->priv->current_op;
 
-	if (!bl->priv->connected) {
-		if (op->view)
-			pas_book_view_notify_status_message (op->view, _("Connecting to LDAP server..."));
-		pas_backend_ldap_connect(bl);
-	}
+	g_hash_table_insert (bl->priv->id_to_op,
+			     &op->id, op);
 
-	if (bl->priv->connected) {
-		if (op->handler (backend, op))
-			ldap_op_finished (op);
-	}
-	else {
-		if (op->view) {
-			pas_book_view_notify_status_message (op->view, _("Unable to connect to LDAP server."));
-			pas_book_view_notify_complete (op->view);
-		}
+	bl->priv->active_ops ++;
 
-		ldap_op_finished (op);
-	}
+	if (bl->priv->poll_timeout == -1)
+		bl->priv->poll_timeout = g_timeout_add (LDAP_POLL_INTERVAL,
+							(GSourceFunc) poll_ldap,
+							bl);
 }
 
 static void
-ldap_op_process (LDAPOp *op)
-{
-	PASBackendLDAP *bl = PAS_BACKEND_LDAP (op->backend);
-
-	if (bl->priv->current_op) {
-		/* operation in progress.  queue this op for later and return. */
-		if (op->view)
-			pas_book_view_notify_status_message (op->view, _("Waiting for connection to LDAP server..."));
-		bl->priv->pending_ops = g_list_append (bl->priv->pending_ops, op);
-	}
-	else {
-		/* nothing going on, do this op now */
-		bl->priv->current_op = op;
-		ldap_op_process_current (op->backend);
-	}
-}
-
-static gboolean
-ldap_op_process_on_idle (PASBackend *backend)
+ldap_op_finished (LDAPOp *op)
 {
+	PASBackend *backend = op->backend;
 	PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
 
-	bl->priv->op_idle = 0;
-
-	ldap_op_process_current (backend);
-
-	return FALSE;
-}
+	g_hash_table_remove (bl->priv->id_to_op, &op->id);
 
-static void
-ldap_op_restart (LDAPOp *op)
-{
-	PASBackend *backend = op->backend;
-	PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
+	/* should handle errors here */
+	ldap_abandon (bl->priv->ldap, op->id);
 
-	g_return_if_fail (op == bl->priv->current_op);
+	op->dtor (op);
 
-	bl->priv->op_idle = g_idle_add((GSourceFunc)ldap_op_process_on_idle, backend);
+	bl->priv->active_ops--;
+	if (bl->priv->active_ops == 0) {
+		if (bl->priv->poll_timeout != -1)
+			g_source_remove (bl->priv->poll_timeout);
+		bl->priv->poll_timeout = -1;
+	}
 }
 
 static void
-ldap_op_finished (LDAPOp *op)
+ldap_op_change_id (LDAPOp *op, int msg_id)
 {
 	PASBackend *backend = op->backend;
 	PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
 
-	g_return_if_fail (op == bl->priv->current_op);
-
-	op->dtor (backend, op);
+	g_hash_table_remove (bl->priv->id_to_op, &op->id);
 
-	if (bl->priv->pending_ops) {
-		bl->priv->current_op = bl->priv->pending_ops->data;
-		bl->priv->pending_ops = g_list_remove_link (bl->priv->pending_ops, bl->priv->pending_ops);
+	op->id = msg_id;
 
-		bl->priv->op_idle = g_idle_add((GSourceFunc)ldap_op_process_on_idle, backend);
-	}
-	else {
-		bl->priv->current_op = NULL;
-	}
+	g_hash_table_insert (bl->priv->id_to_op,
+			     &op->id, op);
 }
 
 static int
@@ -867,49 +922,128 @@ add_objectclass_mod (PASBackendLDAP *bl, GPtrArray *mod_array, GList *existing_o
 
 typedef struct {
 	LDAPOp op;
-	char *vcard;
+	char *dn;
+	ECardSimple *new_card;
 } LDAPCreateOp;
 
-static gboolean
-create_card_handler (PASBackend *backend, LDAPOp *op)
+static void
+create_card_handler (LDAPOp *op, LDAPMessage *res)
 {
 	LDAPCreateOp *create_op = (LDAPCreateOp*)op;
+	PASBackendLDAP *bl = PAS_BACKEND_LDAP (op->backend);
+	LDAP *ldap = bl->priv->ldap;
+	int ldap_error;
+	int response;
+
+	if (LDAP_RES_ADD != ldap_msgtype (res)) {
+		g_warning ("incorrect msg type %d passed to create_card_handler", ldap_msgtype (res));
+		pas_book_respond_create (op->book,
+					 GNOME_Evolution_Addressbook_BookListener_OtherError,
+					 create_op->dn);
+		ldap_op_finished (op);
+		return;
+	}
+
+	ldap_parse_result (ldap, res, &ldap_error,
+			   NULL, NULL, NULL, NULL, 0);
+
+	if (ldap_error == LDAP_SUCCESS) {
+		/* the card was created, let's let the views know about it */
+		GList *l;
+		for (l = bl->priv->book_views; l; l = l->next) {
+			CORBA_Environment ev;
+			gboolean match;
+			PASBackendLDAPBookView *view = l->data; 
+
+			CORBA_exception_init(&ev);
+
+			bonobo_object_dup_ref(bonobo_object_corba_objref(BONOBO_OBJECT(view->book_view)), &ev);
+
+			match = pas_backend_card_sexp_match_vcard (view->card_sexp,
+								   e_card_simple_get_vcard_assume_utf8 (create_op->new_card));
+			if (match) {
+				char *vcard = e_card_simple_get_vcard_assume_utf8 (create_op->new_card);
+				pas_book_view_notify_add_1 (view->book_view,
+							    vcard);
+				g_free (vcard);
+			}
+			pas_book_view_notify_complete (view->book_view);
+
+			bonobo_object_release_unref(bonobo_object_corba_objref(BONOBO_OBJECT(view->book_view)), &ev);
+		}
+	}
+	else {
+		ldap_perror (ldap, "create_card");
+	}
+
+	if (op->view)
+		pas_book_view_notify_complete (op->view);
+
+	/* and lastly respond */
+	response = ldap_error_to_response (ldap_error);
+	pas_book_respond_create (op->book,
+				 response,
+				 create_op->dn);
+
+	ldap_op_finished (op);
+}
+
+static void
+create_card_dtor (LDAPOp *op)
+{
+	LDAPCreateOp *create_op = (LDAPCreateOp*)op;
+
+	g_free (create_op->dn);
+	gtk_object_unref (GTK_OBJECT (create_op->new_card));
+	g_free (create_op);
+}
+
+static void
+pas_backend_ldap_process_create_card (PASBackend *backend,
+				      PASBook    *book,
+				      PASRequest *req)
+{
+	LDAPCreateOp *create_op = g_new (LDAPCreateOp, 1);
 	PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
+	PASBookView *book_view = NULL;
+	int create_card_msgid;
 	ECard *new_ecard;
-	ECardSimple *new_card;
-	char *dn;
 	int response;
-	int            ldap_error;
+	int err;
 	GPtrArray *mod_array;
 	LDAPMod **ldap_mods;
 	LDAP *ldap;
 
-	printf ("vcard = %s\n", create_op->vcard);
+	if (bl->priv->book_views) {
+		PASBackendLDAPBookView *v = bl->priv->book_views->data;
+		book_view = v->book_view;
+	}
+
+	printf ("vcard = %s\n", req->create.vcard);
 
-	new_ecard = e_card_new (create_op->vcard);
-	new_card = e_card_simple_new (new_ecard);
+	new_ecard = e_card_new (req->create.vcard);
+	create_op->new_card = e_card_simple_new (new_ecard);
 
-	dn = create_dn_from_ecard (new_card, bl->priv->ldap_rootdn);
-	e_card_simple_set_id (new_card, dn); /* for the notification code below */
+	create_op->dn = create_dn_from_ecard (create_op->new_card, bl->priv->ldap_rootdn);
+	e_card_simple_set_id (create_op->new_card, create_op->dn); /* for the notification code below */
 
 	ldap = bl->priv->ldap;
 
 	/* build our mods */
-	mod_array = build_mods_from_ecards (bl, NULL, new_card, NULL);
+	mod_array = build_mods_from_ecards (bl, NULL, create_op->new_card, NULL);
 
 #if 0
 	if (!mod_array) {
 		/* there's an illegal field in there.  report
                    UnsupportedAttribute back */
-		g_free (dn);
-
-		gtk_object_unref (GTK_OBJECT(new_card));
-
-		pas_book_respond_create (create_op->op.book,
+		pas_book_respond_create (book,
 					 GNOME_Evolution_Addressbook_BookListener_UnsupportedField,
-					 dn);
+					 create_op->dn);
 
-		return TRUE;
+		g_free (create_op->dn);
+		gtk_object_unref (GTK_OBJECT(create_op->new_card));
+		g_free (create_op);
+		return;
 	}
 #endif
 
@@ -959,90 +1093,29 @@ create_card_handler (PASBackend *backend, LDAPOp *op)
 
 	ldap_mods = (LDAPMod**)mod_array->pdata;
 
-	if (op->view)
-		pas_book_view_notify_status_message (op->view, _("Adding card to LDAP server..."));
-
-	/* actually perform the ldap add */
-	ldap_error = ldap_add_s (ldap, dn, ldap_mods);
-
-	if (ldap_error == LDAP_SUCCESS) {
-		/* the card was created, let's let the views know about it */
-		GList *l;
-		for (l = bl->priv->book_views; l; l = l->next) {
-			CORBA_Environment ev;
-			gboolean match;
-			PASBackendLDAPBookView *view = l->data; 
-					
-			CORBA_exception_init(&ev);
-
-			bonobo_object_dup_ref(bonobo_object_corba_objref(BONOBO_OBJECT(view->book_view)), &ev);
-
-			match = pas_backend_card_sexp_match_vcard (view->card_sexp,
-								   e_card_simple_get_vcard_assume_utf8 (new_card));
-			if (match)
-				pas_book_view_notify_add_1 (view->book_view, e_card_simple_get_vcard_assume_utf8 (new_card));
-			pas_book_view_notify_complete (view->book_view);
-
-			bonobo_object_release_unref(bonobo_object_corba_objref(BONOBO_OBJECT(view->book_view)), &ev);
-		}
-	}
-	else {
-		ldap_perror (ldap, "ldap_add_s");
-	}
+	if (book_view)
+		pas_book_view_notify_status_message (book_view, _("Adding card to LDAP server..."));
 
-	if (op->view)
-		pas_book_view_notify_complete (op->view);
+	err = ldap_add_ext (ldap, create_op->dn, ldap_mods,
+			    NULL, NULL, &create_card_msgid);
 
 	/* and clean up */
 	free_mods (mod_array);
-	g_free (dn);
-
-	gtk_object_unref (GTK_OBJECT(new_card));
-
-	/* and lastly respond */
-	response = ldap_error_to_response (ldap_error);
-	pas_book_respond_create (create_op->op.book,
-				 response,
-				 dn);
-
-	/* we're synchronous */
-	return TRUE;
-}
 
-static void
-create_card_dtor (PASBackend *backend, LDAPOp *op)
-{
-	LDAPCreateOp *create_op = (LDAPCreateOp*)op;
-
-	if (op->view)
-		bonobo_object_release_unref(bonobo_object_corba_objref(BONOBO_OBJECT(op->view)), NULL);
-
-	g_free (create_op->vcard);
-	g_free (create_op);
-}
-
-static void
-pas_backend_ldap_process_create_card (PASBackend *backend,
-				      PASBook    *book,
-				      PASRequest *req)
-{
-	LDAPCreateOp *create_op = g_new (LDAPCreateOp, 1);
-	PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
-	PASBookView *book_view = NULL;
-
-	if (bl->priv->book_views) {
-		PASBackendLDAPBookView *v = bl->priv->book_views->data;
-		book_view = v->book_view;
-		bonobo_object_dup_ref(bonobo_object_corba_objref(BONOBO_OBJECT(book_view)), NULL);
+	if (LDAP_SUCCESS != err) {
+		response = ldap_error_to_response (err);
+		pas_book_respond_create (create_op->op.book,
+					 response,
+					 create_op->dn);
+		create_card_dtor ((LDAPOp*)create_op);
+		return;
+	}
+	else {
+		g_print ("ldap_add_ext returned %d\n", err);
+		ldap_op_add ((LDAPOp*)create_op, backend, book,
+			     book_view, create_card_msgid,
+			     create_card_handler, create_card_dtor);
 	}
-
-	ldap_op_init ((LDAPOp*)create_op, backend, book,
-		      book_view,
-		      create_card_handler, create_card_dtor);
-
-	create_op->vcard = req->vcard;
-
-	ldap_op_process ((LDAPOp*)create_op);
 }
 
 
@@ -1051,71 +1124,56 @@ typedef struct {
 	char *id;
 } LDAPRemoveOp;
 
-static gboolean
-remove_card_handler (PASBackend *backend, LDAPOp *op)
+static void
+remove_card_handler (LDAPOp *op, LDAPMessage *res)
 {
 	LDAPRemoveOp *remove_op = (LDAPRemoveOp*)op;
-	PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
-	int response;
+	PASBackendLDAP *bl = PAS_BACKEND_LDAP (op->backend);
 	int ldap_error;
-	ECardSimple *simple;
-
-	if (op->view)
-		pas_book_view_notify_status_message (op->view, _("Removing card from LDAP server..."));
 
-	simple = search_for_dn (bl, remove_op->id);
+	if (LDAP_RES_DELETE != ldap_msgtype (res)) {
+		g_warning ("incorrect msg type %d passed to remove_card_handler", ldap_msgtype (res));
+		pas_book_respond_remove (op->book,
+					 GNOME_Evolution_Addressbook_BookListener_OtherError);
+		ldap_op_finished (op);
+		return;
+	}
 
-	if (simple) {
-		ldap_error = ldap_delete_s (bl->priv->ldap, remove_op->id);
+	ldap_parse_result (bl->priv->ldap, res, &ldap_error,
+			   NULL, NULL, NULL, NULL, 0);
 
-		if (ldap_error == LDAP_SUCCESS) {
-			/* the card was removed, let's let the views know about it */
-			GList *l;
-			for (l = bl->priv->book_views; l; l = l->next) {
-				CORBA_Environment ev;
-				gboolean match;
-				PASBackendLDAPBookView *view = l->data; 
+	if (ldap_error == LDAP_SUCCESS) {
+		/* the card was removed, let's let the views know about it */
+		GList *l;
+		for (l = bl->priv->book_views; l; l = l->next) {
+			CORBA_Environment ev;
+			PASBackendLDAPBookView *view = l->data; 
 					
-				CORBA_exception_init(&ev);
+			CORBA_exception_init(&ev);
 
-				bonobo_object_dup_ref(bonobo_object_corba_objref(BONOBO_OBJECT(view->book_view)), &ev);
+			bonobo_object_dup_ref(bonobo_object_corba_objref(BONOBO_OBJECT(view->book_view)), &ev);
 
-				match = pas_backend_card_sexp_match_vcard (view->card_sexp,
-									   e_card_simple_get_vcard_assume_utf8 (simple));
-				if (match)
-					pas_book_view_notify_remove (view->book_view, remove_op->id);
-				pas_book_view_notify_complete (view->book_view);
+			pas_book_view_notify_remove (view->book_view, remove_op->id);
 
-				bonobo_object_release_unref(bonobo_object_corba_objref(BONOBO_OBJECT(view->book_view)), &ev);
-			}
-		}
-		else {
-			ldap_perror (bl->priv->ldap, "ldap_delete_s");
+			bonobo_object_release_unref(bonobo_object_corba_objref(BONOBO_OBJECT(view->book_view)), &ev);
 		}
-
-		response = ldap_error_to_response (ldap_error);
 	}
-	else
-		response = GNOME_Evolution_Addressbook_BookListener_CardNotFound;
+	else {
+		ldap_perror (bl->priv->ldap, "remove_card");
+	}
 
 	pas_book_respond_remove (remove_op->op.book,
-				 response);
+				 ldap_error_to_response (ldap_error));
 
 	if (op->view)
 		pas_book_view_notify_complete (op->view);
-
-	/* we're synchronous */
-	return TRUE;
 }
 
 static void
-remove_card_dtor (PASBackend *backend, LDAPOp *op)
+remove_card_dtor (LDAPOp *op)
 {
 	LDAPRemoveOp *remove_op = (LDAPRemoveOp*)op;
 
-	if (op->view)
-		bonobo_object_release_unref(bonobo_object_corba_objref(BONOBO_OBJECT(op->view)), NULL);
-
 	g_free (remove_op->id);
 	g_free (remove_op);
 }
@@ -1128,67 +1186,175 @@ pas_backend_ldap_process_remove_card (PASBackend *backend,
 	LDAPRemoveOp *remove_op = g_new (LDAPRemoveOp, 1);
 	PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
 	PASBookView *book_view = NULL;
+	int remove_msgid;
+	int ldap_error;
 
 	if (bl->priv->book_views) {
 		PASBackendLDAPBookView *v = bl->priv->book_views->data;
 		book_view = v->book_view;
-		bonobo_object_dup_ref(bonobo_object_corba_objref(BONOBO_OBJECT(book_view)), NULL);
 	}
 
-	ldap_op_init ((LDAPOp*)remove_op, backend, book,
-		      book_view,
-		      remove_card_handler, remove_card_dtor);
+	remove_op->id = g_strdup (req->remove.id);
+
+	if (book_view)
+		pas_book_view_notify_status_message (book_view, _("Removing card from LDAP server..."));
 
-	remove_op->id = req->id;
+	ldap_error = ldap_delete_ext (bl->priv->ldap,
+				      remove_op->id,
+				      NULL, NULL, &remove_msgid);
 
-	ldap_op_process ((LDAPOp*)remove_op);
+	if (ldap_error != LDAP_SUCCESS) {
+		pas_book_respond_remove (remove_op->op.book,
+					 ldap_error_to_response (ldap_error));
+		remove_card_dtor ((LDAPOp*)remove_op);
+		return;
+	}
+	else {
+		g_print ("ldap_delete_ext returned %d\n", ldap_error);
+		ldap_op_add ((LDAPOp*)remove_op, backend, book,
+			     book_view, remove_msgid,
+			     remove_card_handler, remove_card_dtor);
+	}
 }
 
 
+/*
+** MODIFY
+**
+** The modification request is actually composed of 2 separate
+** requests.  Since we need to get a list of theexisting objectclasses
+** used by the ldap server for the entry, and since the UI only sends
+** us the current card, we need to query the ldap server for the
+** existing card.
+**
+*/
+
 typedef struct {
 	LDAPOp op;
-	char *vcard;
+	const char *id; /* the id of the card we're modifying */
+	char *current_vcard; /* current in the LDAP db */
+	ECardSimple *current_card;
+	char *vcard;         /* the VCard we want to store */
+	ECardSimple *card;
+	GList *existing_objectclasses;
 } LDAPModifyOp;
 
-static gboolean
-modify_card_handler (PASBackend *backend, LDAPOp *op)
+static void
+modify_card_modify_handler (LDAPOp *op, LDAPMessage *res)
 {
 	LDAPModifyOp *modify_op = (LDAPModifyOp*)op;
-	PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
-	ECard *new_ecard;
-	const char *id;
-	int response;
-	int            ldap_error = LDAP_SUCCESS;
-	GPtrArray *mod_array;
-	LDAPMod **ldap_mods;
-	LDAP *ldap;
-	ECardSimple *current_card;
-	GList *existing_objectclasses = NULL;
+	PASBackendLDAP *bl = PAS_BACKEND_LDAP (op->backend);
+	LDAP *ldap = bl->priv->ldap;
+	int ldap_error;
 
-	new_ecard = e_card_new (modify_op->vcard);
-	id = e_card_get_id(new_ecard);
+	if (LDAP_RES_MODIFY != ldap_msgtype (res)) {
+		g_warning ("incorrect msg type %d passed to modify_card_handler", ldap_msgtype (res));
+		pas_book_respond_modify (op->book,
+					 GNOME_Evolution_Addressbook_BookListener_OtherError);
+		ldap_op_finished (op);
+		return;
+	}
 
-	ldap = bl->priv->ldap;
+	ldap_parse_result (ldap, res, &ldap_error,
+			   NULL, NULL, NULL, NULL, 0);
 
-	if (op->view)
-		pas_book_view_notify_status_message (op->view, _("Modifying card from LDAP server..."));
+	if (ldap_error == LDAP_SUCCESS) {
+		/* the card was modified, let's let the views know about it */
+		GList *l;
+		for (l = bl->priv->book_views; l; l = l->next) {
+			CORBA_Environment ev;
+			gboolean old_match, new_match;
+			PASBackendLDAPBookView *view = l->data; 
+					
+			CORBA_exception_init(&ev);
+
+			bonobo_object_dup_ref(bonobo_object_corba_objref(BONOBO_OBJECT(view->book_view)), &ev);
 
-	current_card = search_for_dn_with_objectclasses (bl, id, &existing_objectclasses);
+			old_match = pas_backend_card_sexp_match_vcard (view->card_sexp,
+								       modify_op->current_vcard);
+			new_match = pas_backend_card_sexp_match_vcard (view->card_sexp,
+								       modify_op->vcard);
+			if (old_match && new_match)
+				pas_book_view_notify_change_1 (view->book_view, modify_op->vcard);
+			else if (new_match)
+				pas_book_view_notify_add_1 (view->book_view, modify_op->vcard);
+			else /* if (old_match) */
+				pas_book_view_notify_remove (view->book_view, e_card_simple_get_id (modify_op->card));
+			pas_book_view_notify_complete (view->book_view);
 
-	if (current_card) {
-		ECardSimple *new_card = e_card_simple_new (new_ecard);
+			bonobo_object_release_unref(bonobo_object_corba_objref(BONOBO_OBJECT(view->book_view)), &ev);
+		}
+	}
+	else {
+		ldap_perror (ldap, "ldap_modify_s");
+	}
+
+	/* and lastly respond */
+	pas_book_respond_modify (op->book,
+				 ldap_error_to_response (ldap_error));
+	ldap_op_finished (op);
+}
+
+static void
+modify_card_search_handler (LDAPOp *op, LDAPMessage *res)
+{
+	LDAPModifyOp *modify_op = (LDAPModifyOp*)op;
+	PASBackendLDAP *bl = PAS_BACKEND_LDAP (op->backend);
+	LDAP *ldap = bl->priv->ldap;
+	int msg_type;
+
+	/* if it's successful, we should get called with a
+	   RES_SEARCH_ENTRY and a RES_SEARCH_RESULT.  if it's
+	   unsuccessful, we should only see a RES_SEARCH_RESULT */
+
+	msg_type = ldap_msgtype (res);
+	if (msg_type == LDAP_RES_SEARCH_ENTRY) {
+		LDAPMessage *e = ldap_first_entry(ldap, res);
+
+		if (!e) {
+			g_warning ("uh, this shouldn't happen");
+			pas_book_respond_modify (op->book,
+						 GNOME_Evolution_Addressbook_BookListener_OtherError);
+			ldap_op_finished (op);
+			return;
+		}
+
+		modify_op->current_card = build_card_from_entry (ldap, e,
+								 &modify_op->existing_objectclasses);
+		modify_op->current_vcard = e_card_simple_get_vcard_assume_utf8 (modify_op->current_card);
+	}
+	else if (msg_type == LDAP_RES_SEARCH_RESULT) {
+		int ldap_error;
+		LDAPMod **ldap_mods;
+		GPtrArray *mod_array;
+		gboolean differences;
 		gboolean need_new_dn;
+		int modify_card_msgid;
+
+		/* grab the result code, and set up the actual modify
+                   if it was successful */
+		ldap_parse_result (bl->priv->ldap, res, &ldap_error,
+				   NULL, NULL, NULL, NULL, 0);
+
+		if (ldap_error != LDAP_SUCCESS) {
+			/* more here i'm sure */
+			pas_book_respond_modify (op->book,
+						 ldap_error_to_response (ldap_error));
+			ldap_op_finished (op);
+			return;
+		}
 
 		/* build our mods */
-		mod_array = build_mods_from_ecards (bl, current_card, new_card, &need_new_dn);
-		if (mod_array->len > 0) {
+		mod_array = build_mods_from_ecards (bl, modify_op->current_card, modify_op->card, &need_new_dn);
+		differences = mod_array->len > 0;
 
+		if (differences) {
 			/* remove the NULL at the end */
 			g_ptr_array_remove (mod_array, NULL);
 
 			/* add our objectclass(es), making sure
-                           evolutionPerson is there if it's supported */
-			add_objectclass_mod (bl, mod_array, existing_objectclasses);
+			   evolutionPerson is there if it's supported */
+			add_objectclass_mod (bl, mod_array, modify_op->existing_objectclasses);
 
 			/* then put the NULL back */
 			g_ptr_array_add (mod_array, NULL);
@@ -1196,74 +1362,47 @@ modify_card_handler (PASBackend *backend, LDAPOp *op)
 			ldap_mods = (LDAPMod**)mod_array->pdata;
 
 			/* actually perform the ldap modify */
-			ldap_error = ldap_modify_ext_s (ldap, id, ldap_mods, NULL, NULL);
-			if (ldap_error == LDAP_SUCCESS) {
+			ldap_error = ldap_modify_ext (ldap, modify_op->id, ldap_mods,
+						      NULL, NULL, &modify_card_msgid);
 
-				/* the card was modified, let's let the views know about it */
-				GList *l;
-				for (l = bl->priv->book_views; l; l = l->next) {
-					CORBA_Environment ev;
-					gboolean old_match, new_match;
-					PASBackendLDAPBookView *view = l->data; 
-					
-					CORBA_exception_init(&ev);
-
-					bonobo_object_dup_ref(bonobo_object_corba_objref(BONOBO_OBJECT(view->book_view)), &ev);
-
-					old_match = pas_backend_card_sexp_match_vcard (view->card_sexp,
-										       e_card_simple_get_vcard_assume_utf8 (current_card));
-					new_match = pas_backend_card_sexp_match_vcard (view->card_sexp,
-										       modify_op->vcard);
-					if (old_match && new_match)
-						pas_book_view_notify_change_1 (view->book_view, modify_op->vcard);
-					else if (new_match)
-						pas_book_view_notify_add_1 (view->book_view, modify_op->vcard);
-					else /* if (old_match) */
-						pas_book_view_notify_remove (view->book_view, e_card_simple_get_id (new_card));
-					pas_book_view_notify_complete (view->book_view);
-
-					bonobo_object_release_unref(bonobo_object_corba_objref(BONOBO_OBJECT(view->book_view)), &ev);
-				}
+			if (ldap_error == LDAP_SUCCESS) {
+				op->handler = modify_card_modify_handler;
+				ldap_op_change_id ((LDAPOp*)modify_op,
+						   modify_card_msgid);
 			}
 			else {
-				ldap_perror (ldap, "ldap_modify_s");
+				g_warning ("ldap_modify_ext returned %d\n", ldap_error);
+				pas_book_respond_modify (op->book,
+							 ldap_error_to_response (ldap_error));
+				ldap_op_finished (op);
+				return;
 			}
 		}
-		else {
-			g_print ("modify list empty.  no modification sent\n");
-		}
 
 		/* and clean up */
 		free_mods (mod_array);
-		g_list_foreach (existing_objectclasses, (GFunc)g_free, NULL);
-		g_list_free (existing_objectclasses);
-		gtk_object_unref (GTK_OBJECT(new_card));
-		gtk_object_unref (GTK_OBJECT(current_card));
 	}
 	else {
-		g_print ("didn't find original card\n");
+		g_warning ("unhandled result type %d returned", msg_type);
+		pas_book_respond_modify (op->book,
+					 GNOME_Evolution_Addressbook_BookListener_OtherError);
+		ldap_op_finished (op);
 	}
-
-	response = ldap_error_to_response (ldap_error);
-	pas_book_respond_modify (modify_op->op.book,
-				 response);
-
-	if (op->view)
-		pas_book_view_notify_complete (op->view);
-
-	/* we're synchronous */
-	return TRUE;
 }
 
 static void
-modify_card_dtor (PASBackend *backend, LDAPOp *op)
+modify_card_dtor (LDAPOp *op)
 {
 	LDAPModifyOp *modify_op = (LDAPModifyOp*)op;
 
-	if (op->view)
-		bonobo_object_release_unref(bonobo_object_corba_objref(BONOBO_OBJECT(op->view)), NULL);
-
+	g_list_foreach (modify_op->existing_objectclasses, (GFunc)g_free, NULL);
+	g_list_free (modify_op->existing_objectclasses);
+	g_free (modify_op->current_vcard);
+	if (modify_op->current_card)
+		gtk_object_unref (GTK_OBJECT (modify_op->current_card));
 	g_free (modify_op->vcard);
+	if (modify_op->card)
+		gtk_object_unref (GTK_OBJECT (modify_op->card));
 	g_free (modify_op);
 }
 
@@ -1272,55 +1411,154 @@ pas_backend_ldap_process_modify_card (PASBackend *backend,
 				      PASBook    *book,
 				      PASRequest *req)
 {
-	LDAPModifyOp *modify_op = g_new (LDAPModifyOp, 1);
+	LDAPModifyOp *modify_op = g_new0 (LDAPModifyOp, 1);
 	PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
+	ECard *new_ecard;
+	int ldap_error;
+	LDAP *ldap;
+	int modify_card_msgid;
 	PASBookView *book_view = NULL;
 
 	if (bl->priv->book_views) {
 		PASBackendLDAPBookView *v = bl->priv->book_views->data;
 		book_view = v->book_view;
-		bonobo_object_dup_ref(bonobo_object_corba_objref(BONOBO_OBJECT(book_view)), NULL);
 	}
 
-	ldap_op_init ((LDAPOp*)modify_op, backend, book,
-		      book_view,
-		      modify_card_handler, modify_card_dtor);
+	modify_op->vcard = g_strdup (req->modify.vcard);
+	new_ecard = e_card_new (modify_op->vcard);
+	modify_op->card = e_card_simple_new (new_ecard);
+	gtk_object_unref (GTK_OBJECT (new_ecard));
+	modify_op->id = e_card_simple_get_id(modify_op->card);
+
+	ldap = bl->priv->ldap;
+
+	if (book_view)
+		pas_book_view_notify_status_message (book_view, _("Modifying card from LDAP server..."));
 
-	modify_op->vcard = req->vcard;
+	ldap_error = ldap_search_ext (ldap, modify_op->id,
+				      LDAP_SCOPE_BASE,
+				      "(objectclass=*)",
+				      NULL, 0, NULL, NULL,
+				      NULL, /* XXX timeout */
+				      1, &modify_card_msgid);
 
-	ldap_op_process ((LDAPOp*)modify_op);
+	if (ldap_error == LDAP_SUCCESS) {
+		ldap_op_add ((LDAPOp*)modify_op, backend, book,
+			     book_view, modify_card_msgid,
+			     modify_card_search_handler, modify_card_dtor);
+	}
+	else {
+		g_warning ("ldap_search_ext returned %d\n", ldap_error);
+		pas_book_respond_modify (book,
+					 GNOME_Evolution_Addressbook_BookListener_OtherError);
+		modify_card_dtor ((LDAPOp*)modify_op);
+	}
 }
 
 
+typedef struct {
+	LDAPOp op;
+} LDAPGetVCardOp;
+
+static void
+get_vcard_handler (LDAPOp *op, LDAPMessage *res)
+{
+	PASBackendLDAP *bl = PAS_BACKEND_LDAP (op->backend);
+	int msg_type;
+
+	/* the msg_type will be either SEARCH_ENTRY (if we're
+	   successful) or SEARCH_RESULT (if we're not), so we finish
+	   the op after either */
+	msg_type = ldap_msgtype (res);
+	if (msg_type == LDAP_RES_SEARCH_ENTRY) {
+		LDAPMessage *e = ldap_first_entry(bl->priv->ldap, res);
+		ECardSimple *simple;
+		char *vcard;
+
+		if (!e) {
+			g_warning ("uh, this shouldn't happen");
+			pas_book_respond_get_vcard (op->book,
+						    GNOME_Evolution_Addressbook_BookListener_OtherError,
+						    "");
+			ldap_op_finished (op);
+			return;
+		}
+
+		simple = build_card_from_entry (bl->priv->ldap, e, NULL);
+		vcard = e_card_simple_get_vcard_assume_utf8 (simple);
+		pas_book_respond_get_vcard (op->book,
+					    GNOME_Evolution_Addressbook_BookListener_Success,
+					    vcard);
+		g_free (vcard);
+		gtk_object_unref (GTK_OBJECT (simple));
+		ldap_op_finished (op);
+	}
+	else if (msg_type == LDAP_RES_SEARCH_RESULT) {
+		int ldap_error;
+		ldap_parse_result (bl->priv->ldap, res, &ldap_error,
+				   NULL, NULL, NULL, NULL, 0);
+		pas_book_respond_get_vcard (op->book, ldap_error_to_response (ldap_error), "");
+		ldap_op_finished (op);
+	}
+	else {
+		g_warning ("unhandled result type %d returned", msg_type);
+		pas_book_respond_get_vcard (op->book, GNOME_Evolution_Addressbook_BookListener_OtherError,
+					    "");
+		ldap_op_finished (op);
+	}
+
+}
+
+static void
+get_vcard_dtor (LDAPOp *op)
+{
+	LDAPGetVCardOp *get_vcard_op = (LDAPGetVCardOp*)op;
+
+	g_free (get_vcard_op);
+}
+
 static void
 pas_backend_ldap_process_get_vcard (PASBackend *backend,
 				    PASBook *book,
 				    PASRequest *req)
 {
-	PASBackendLDAP *bl;
-	ECardSimple *simple;
-
-	bl = PAS_BACKEND_LDAP (pas_book_get_backend (book));
+	LDAPGetVCardOp *get_vcard_op = g_new0 (LDAPGetVCardOp, 1);
+	PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
+	LDAP *ldap = bl->priv->ldap;
+	int get_vcard_msgid;
+	PASBookView *book_view = NULL;
+	int ldap_error;
 
-	simple = search_for_dn (bl, req->id);
+	if (bl->priv->book_views) {
+		PASBackendLDAPBookView *v = bl->priv->book_views->data;
+		book_view = v->book_view;
+	}
+	
+	ldap_error = ldap_search_ext (ldap, req->get_vcard.id,
+				      LDAP_SCOPE_BASE,
+				      "(objectclass=*)",
+				      NULL, 0, NULL, NULL,
+				      NULL, /* XXX timeout */
+				      1, &get_vcard_msgid);
 
-	if (simple) {
-		pas_book_respond_get_vcard (book,
-					    GNOME_Evolution_Addressbook_BookListener_Success,
-					    e_card_simple_get_vcard_assume_utf8 (simple));
-		gtk_object_unref (GTK_OBJECT (simple));
+	if (ldap_error == LDAP_SUCCESS) {
+		ldap_op_add ((LDAPOp*)get_vcard_op, backend, book,
+			     book_view, get_vcard_msgid,
+			     get_vcard_handler, get_vcard_dtor);
 	}
 	else {
 		pas_book_respond_get_vcard (book,
-					    GNOME_Evolution_Addressbook_BookListener_CardNotFound,
+					    ldap_error_to_response (ldap_error),
 					    "");
+		get_vcard_dtor ((LDAPOp*)get_vcard_op);
 	}
 }
 
 
 typedef struct {
 	LDAPOp op;
-	PASBook *book;
+	PASBackendLDAPCursorPrivate *cursor_data;
+	gboolean responded; /* if FALSE, we need to free cursor_data in the dtor */
 } LDAPGetCursorOp;
 
 static long
@@ -1344,22 +1582,25 @@ get_nth(PASCardCursor *cursor, long n, gpointer data)
 static void
 cursor_destroy(GtkObject *object, gpointer data)
 {
-	CORBA_Environment ev;
-	GNOME_Evolution_Addressbook_Book corba_book;
 	PASBackendLDAPCursorPrivate *cursor_data = (PASBackendLDAPCursorPrivate *) data;
 
-	corba_book = bonobo_object_corba_objref(BONOBO_OBJECT(cursor_data->book));
+	if (cursor_data->book) {
+		CORBA_Environment ev;
+		GNOME_Evolution_Addressbook_Book corba_book;
 
-	CORBA_exception_init(&ev);
+		corba_book = bonobo_object_corba_objref(BONOBO_OBJECT(cursor_data->book));
 
-	GNOME_Evolution_Addressbook_Book_unref(corba_book, &ev);
+		CORBA_exception_init(&ev);
+
+		GNOME_Evolution_Addressbook_Book_unref(corba_book, &ev);
 	
-	if (ev._major != CORBA_NO_EXCEPTION) {
-		g_warning("cursor_destroy: Exception unreffing "
-			  "corba book.\n");
-	}
+		if (ev._major != CORBA_NO_EXCEPTION) {
+			g_warning("cursor_destroy: Exception unreffing "
+				  "corba book.\n");
+		}
 
-	CORBA_exception_free(&ev);
+		CORBA_exception_free(&ev);
+	}
 
 	/* free the ldap specific cursor information */
 	g_list_foreach (cursor_data->elements, (GFunc)g_free, NULL);
@@ -1369,97 +1610,72 @@ cursor_destroy(GtkObject *object, gpointer data)
 }
 
 static void
-pas_backend_ldap_build_all_cards_list(PASBackend *backend,
-				      PASBackendLDAPCursorPrivate *cursor_data)
+get_cursor_handler (LDAPOp *op, LDAPMessage *res)
 {
-	PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
-	LDAP           *ldap = bl->priv->ldap;
-	int            ldap_error;
-	LDAPMessage    *res, *e;
-
-	if ((ldap_error = ldap_search_s (ldap,
-					 bl->priv->ldap_rootdn,
-					 bl->priv->ldap_scope,
-					 "(objectclass=*)",
-					 NULL, 0, &res)) != LDAP_SUCCESS) {
-		g_warning ("ldap error '%s' in "
-			   "pas_backend_ldap_build_all_cards_list\n",
-			   ldap_err2string(ldap_error));
-	}
+	LDAPGetCursorOp *cursor_op = (LDAPGetCursorOp*)op;
+	PASBackendLDAP *bl = PAS_BACKEND_LDAP (op->backend);
+	LDAP *ldap = bl->priv->ldap;
+	int msg_type;
 
-	cursor_data->elements = NULL;
+	msg_type = ldap_msgtype (res);
+	if (msg_type == LDAP_RES_SEARCH_ENTRY) {
+		LDAPMessage *e;
 
-	cursor_data->num_elements = ldap_count_entries (ldap, res);
+		e = ldap_first_entry (ldap, res);
+		while (e) {
+			ECardSimple *simple;
+
+			simple = build_card_from_entry (ldap, e, NULL);
+			if (simple) {
+				char *vcard = e_card_simple_get_vcard_assume_utf8 (simple);
+				cursor_op->cursor_data->num_elements ++;
+				cursor_op->cursor_data->elements = g_list_prepend (cursor_op->cursor_data->elements,
+										   vcard);
+				gtk_object_unref (GTK_OBJECT (simple));
+			}
+		}
+	}
+	else if (msg_type == LDAP_RES_SEARCH_RESULT) {
+		PASCardCursor *cursor = CORBA_OBJECT_NIL;
+		int ldap_error;
+		ldap_parse_result (bl->priv->ldap, res, &ldap_error,
+				   NULL, NULL, NULL, NULL, 0);
 
-	e = ldap_first_entry(ldap, res);
+		if (ldap_error == LDAP_SUCCESS) {
+			cursor = pas_card_cursor_new(get_length,
+						     get_nth,
+						     cursor_op->cursor_data);
 
-	while (NULL != e) {
+			gtk_signal_connect(GTK_OBJECT(cursor), "destroy",
+					   GTK_SIGNAL_FUNC(cursor_destroy), cursor_op->cursor_data);
 
-		/* for now just make a list of the dn's */
-#if 0
-		for ( a = ldap_first_attribute( ldap, e, &ber ); a != NULL;
-		      a = ldap_next_attribute( ldap, e, ber ) ) {
+			cursor_op->responded = TRUE;
 		}
-#else
-		cursor_data->elements = g_list_prepend(cursor_data->elements,
-						       g_strdup(ldap_get_dn(ldap, e)));
-#endif
 
-		e = ldap_next_entry(ldap, e);
-	}
+		pas_book_respond_get_cursor (cursor_op->cursor_data->book,
+					     ldap_error_to_response (ldap_error),
+					     cursor);
 
-	ldap_msgfree(res);
+		ldap_op_finished (op);
+	}
+	else {
+		g_warning ("unhandled result type %d returned", msg_type);
+		pas_book_respond_get_cursor (op->book,
+					     GNOME_Evolution_Addressbook_BookListener_OtherError,
+					     CORBA_OBJECT_NIL);
+		ldap_op_finished (op);
+	}
 }
 
-
-static gboolean
-get_cursor_handler (PASBackend *backend, LDAPOp *op)
+static void
+get_cursor_dtor (LDAPOp *op)
 {
 	LDAPGetCursorOp *cursor_op = (LDAPGetCursorOp*)op;
-	CORBA_Environment ev;
-	int            ldap_error = 0;
-	PASCardCursor *cursor;
-	GNOME_Evolution_Addressbook_Book corba_book;
-	PASBackendLDAPCursorPrivate *cursor_data;
-	PASBook *book = cursor_op->book;
-
-	cursor_data = g_new(PASBackendLDAPCursorPrivate, 1);
-	cursor_data->backend = backend;
-	cursor_data->book = book;
-
-	pas_backend_ldap_build_all_cards_list(backend, cursor_data);
-
-	corba_book = bonobo_object_corba_objref(BONOBO_OBJECT(book));
 
-	CORBA_exception_init(&ev);
-
-	GNOME_Evolution_Addressbook_Book_ref(corba_book, &ev);
-	
-	if (ev._major != CORBA_NO_EXCEPTION) {
-		g_warning("pas_backend_file_process_get_cursor: Exception reffing "
-			  "corba book.\n");
+	if (!cursor_op->responded) {
+		cursor_destroy (NULL, cursor_op->cursor_data);
 	}
 
-	CORBA_exception_free(&ev);
-	
-	cursor = pas_card_cursor_new(get_length,
-				     get_nth,
-				     cursor_data);
-
-	gtk_signal_connect(GTK_OBJECT(cursor), "destroy",
-			   GTK_SIGNAL_FUNC(cursor_destroy), cursor_data);
-	
-	pas_book_respond_get_cursor (book,
-				     ldap_error_to_response (ldap_error),
-				     cursor);
-
-	/* we're synchronous */
-	return TRUE;
-}
-
-static void
-get_cursor_dtor (PASBackend *backend, LDAPOp *op)
-{
 	g_free (op);
 }
 
@@ -1468,11 +1684,53 @@ pas_backend_ldap_process_get_cursor (PASBackend *backend,
 				     PASBook    *book,
 				     PASRequest *req)
 {
-	LDAPGetCursorOp *op = g_new (LDAPGetCursorOp, 1);
+	PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
+	LDAP           *ldap = bl->priv->ldap;
+	int            ldap_error;
+	int            get_cursor_msgid;
+	LDAPGetCursorOp *cursor_op;
+
+	cursor_op = g_new0 (LDAPGetCursorOp, 1);
+	cursor_op->cursor_data = g_new0 (PASBackendLDAPCursorPrivate, 1);
+
+	ldap_error = ldap_search_ext (ldap,
+				      bl->priv->ldap_rootdn,
+				      bl->priv->ldap_scope,
+				      "(objectclass=*)",
+				      NULL, 0,
+				      NULL, NULL, NULL, /* timeout */
+				      bl->priv->ldap_limit, &get_cursor_msgid);
+
+	if (ldap_error == LDAP_SUCCESS) {
+		CORBA_Environment ev;
+		GNOME_Evolution_Addressbook_Book corba_book;
+
+		corba_book = bonobo_object_corba_objref(BONOBO_OBJECT(book));
+
+		CORBA_exception_init(&ev);
 
-	ldap_op_init ((LDAPOp*)op, backend, book, NULL, get_cursor_handler, get_cursor_dtor);
+		GNOME_Evolution_Addressbook_Book_ref(corba_book, &ev);
 
-	ldap_op_process ((LDAPOp*)op);
+		cursor_op->cursor_data->backend = backend;
+		cursor_op->cursor_data->book = book;
+			
+		if (ev._major != CORBA_NO_EXCEPTION) {
+			g_warning("pas_backend_ldap_process_get_cursor: Exception reffing "
+				  "corba book.\n");
+		}
+
+		CORBA_exception_free(&ev);
+	
+
+		ldap_op_add ((LDAPOp*)cursor_op, backend, book,
+			     NULL, get_cursor_msgid, get_cursor_handler, get_cursor_dtor);
+	}
+	else {
+		pas_book_respond_get_cursor (book,
+					     ldap_error_to_response (ldap_error),
+					     CORBA_OBJECT_NIL);
+		get_cursor_dtor ((LDAPOp*)cursor_op);
+	}
 }
 
 
@@ -2191,9 +2449,18 @@ query_prop_to_ldap(gchar *query_prop)
 
 typedef struct {
 	LDAPOp op;
-	char *ldap_query;
-	PASBackendLDAP *bl;
 	PASBackendLDAPBookView *view;
+
+	/* grouping stuff */
+	GList    *pending_adds;        /* the cards we're sending */
+	int       num_pending_adds;    /* the number waiting to be sent */
+	int       target_pending_adds; /* the cutoff that forces a flush to the client, if it happens before the timeout */
+	int       num_sent_this_time;  /* the number of cards we sent to the client before the most recent timeout */
+	int       num_sent_last_time;  /* the number of cards we sent to the client before the previous timeout */
+	glong     grouping_time_start;
+	
+	/* used by search_handler to only send the status messages once */
+	gboolean notified_receiving_results;
 } LDAPSearchOp;
 
 static ECardSimple *
@@ -2263,25 +2530,13 @@ build_card_from_entry (LDAP *ldap, LDAPMessage *e, GList **existing_objectclasse
 	return card;
 }
 
-static void
-send_pending_adds (PASBackendLDAPBookView *view)
-{
-	view->num_sent_this_time += view->num_pending_adds;
-	pas_book_view_notify_add (view->book_view, view->pending_adds);
-	g_list_foreach (view->pending_adds, (GFunc)g_free, NULL);
-	view->pending_adds = NULL;
-	view->num_pending_adds = 0;
-}
-
 static gboolean
-poll_ldap (LDAPSearchOp *op)
+poll_ldap (PASBackendLDAP *bl)
 {
-	PASBackendLDAPBookView *view = op->view;
-	PASBackendLDAP *bl = op->bl;
+	GList *list;
 	LDAP           *ldap = bl->priv->ldap;
 	int            rc;
-	LDAPMessage    *res, *e;
-	static int received = 0;
+	LDAPMessage    *res;
 	GTimeVal cur_time;
 	glong cur_millis;
 	struct timeval timeout;
@@ -2289,13 +2544,9 @@ poll_ldap (LDAPSearchOp *op)
 	timeout.tv_sec = 0;
 	timeout.tv_usec = LDAP_RESULT_TIMEOUT_MILLIS * 1000;
 
-	if (!view->notified_receiving_results) {
-		view->notified_receiving_results = TRUE;
-		pas_book_view_notify_status_message (view->book_view, _("Receiving LDAP search results..."));
-	}
-
-	rc = ldap_result (ldap, view->search_msgid, 0, &timeout, &res);
+	rc = ldap_result (ldap, LDAP_RES_ANY, 0, &timeout, &res);
 	if (rc != 0) {/* rc == 0 means timeout exceeded */
+#if 0
 		if (rc == -1 && received == 0) {
 			pas_book_view_notify_status_message (view->book_view, _("Restarting search."));
 			/* connection went down and we never got any. */
@@ -2305,139 +2556,134 @@ poll_ldap (LDAPSearchOp *op)
 			ldap_op_restart ((LDAPOp*)op);
 			return FALSE;
 		}
-
-		if (rc != LDAP_RES_SEARCH_ENTRY) {
-			view->search_timeout = 0;
-			if (view->num_pending_adds)
-				send_pending_adds (view);
-			pas_book_view_notify_complete (view->book_view);
-			ldap_op_finished ((LDAPOp*)op);
-			received = 0;
-			return FALSE;
+#endif
+		if (rc == -1) {
+			g_warning ("ldap_result returned -1");
 		}
+		else {
+			int msgid = ldap_msgid (res);
+			LDAPOp *op;
 
-		received = 1;
-
-		e = ldap_first_entry(ldap, res);
-
-		while (NULL != e) {
-			ECardSimple *card = build_card_from_entry (ldap, e, NULL);
-
-			view->pending_adds = g_list_append (view->pending_adds,
-							    e_card_simple_get_vcard_assume_utf8 (card));
-			view->num_pending_adds ++;
+			op = g_hash_table_lookup (bl->priv->id_to_op, &msgid);
+			if (!op)
+				g_error ("unknown operation, msgid = %d", msgid);
 
-			gtk_object_unref (GTK_OBJECT(card));
+			op->handler (op, res);
 
-			e = ldap_next_entry(ldap, e);
+			ldap_msgfree(res);
 		}
-
-		ldap_msgfree(res);
 	}
 
 	g_get_current_time (&cur_time);
 	cur_millis = TV_TO_MILLIS (cur_time);
+       
+	for (list = bl->priv->book_views; list; list = g_list_next(list)) {
+		PASBackendLDAPBookView *view = list->data;
+		if (view->search_op)
+			ldap_search_op_timeout (view->search_op, cur_millis);
+	}
+
+	return TRUE;
+}
+
+static void
+send_pending_adds (LDAPSearchOp *search_op)
+{
+	search_op->num_sent_this_time += search_op->num_pending_adds;
+	pas_book_view_notify_add (search_op->op.view, search_op->pending_adds);
+	g_list_foreach (search_op->pending_adds, (GFunc)g_free, NULL);
+	search_op->pending_adds = NULL;
+	search_op->num_pending_adds = 0;
+}
 
-	if (cur_millis - view->grouping_time_start > GROUPING_MINIMUM_WAIT) {
+static void
+ldap_search_op_timeout (LDAPOp *op, glong cur_millis)
+{
+	LDAPSearchOp *search_op = (LDAPSearchOp*)op;
+
+	if (cur_millis - search_op->grouping_time_start > GROUPING_MINIMUM_WAIT) {
 
-		if (view->num_pending_adds >= view->target_pending_adds)
-			send_pending_adds (view);
+		if (search_op->num_pending_adds >= search_op->target_pending_adds)
+			send_pending_adds (search_op);
 
-		if (cur_millis - view->grouping_time_start > GROUPING_MAXIMUM_WAIT) {
+		if (cur_millis - search_op->grouping_time_start > GROUPING_MAXIMUM_WAIT) {
 			GTimeVal new_start;
 
-			if (view->num_pending_adds)
-				send_pending_adds (view);
-			view->target_pending_adds = MIN (GROUPING_MAXIMUM_SIZE,
-							 (view->num_sent_this_time + view->num_sent_last_time) / 2);
-			view->target_pending_adds = MAX (view->target_pending_adds, 1);
+			if (search_op->num_pending_adds)
+				send_pending_adds (search_op);
+			search_op->target_pending_adds = MIN (GROUPING_MAXIMUM_SIZE,
+							 (search_op->num_sent_this_time + search_op->num_sent_last_time) / 2);
+			search_op->target_pending_adds = MAX (search_op->target_pending_adds, 1);
 
 #ifdef PERFORMANCE_SPEW
 			printf ("num sent this time %d, last time %d, target pending adds set to %d\n",
-				view->num_sent_this_time,
-				view->num_sent_last_time,
-				view->target_pending_adds);
+				search_op->num_sent_this_time,
+				search_op->num_sent_last_time,
+				search_op->target_pending_adds);
 #endif
 			g_get_current_time (&new_start);
-			view->grouping_time_start = TV_TO_MILLIS (new_start); 
-			view->num_sent_last_time = view->num_sent_this_time;
-			view->num_sent_this_time = 0;
+			search_op->grouping_time_start = TV_TO_MILLIS (new_start); 
+			search_op->num_sent_last_time = search_op->num_sent_this_time;
+			search_op->num_sent_this_time = 0;
 		}
 	}
-
-	return TRUE;
 }
 
-static gboolean
-ldap_search_handler (PASBackend *backend, LDAPOp *op)
+static void
+ldap_search_handler (LDAPOp *op, LDAPMessage *res)
 {
-	LDAPSearchOp *search_op = (LDAPSearchOp*) op;
-
-	if (op->view)
-		pas_book_view_notify_status_message (op->view, _("Searching..."));
+	LDAPSearchOp *search_op = (LDAPSearchOp*)op;
+	PASBackendLDAP *bl = PAS_BACKEND_LDAP (op->backend);
+	LDAP *ldap = bl->priv->ldap;
+	LDAPMessage *e;
+	int msg_type;
 
-	/* it might not be NULL if we've been restarted */
-	if (search_op->ldap_query == NULL)
-		search_op->ldap_query = pas_backend_ldap_build_query(PAS_BACKEND_LDAP (backend), search_op->view->search);
+	if (!search_op->notified_receiving_results) {
+		search_op->notified_receiving_results = TRUE;
+		pas_book_view_notify_status_message (op->view, _("Receiving LDAP search results..."));
+	}
 
-	if (search_op->ldap_query != NULL) {
-		PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
-		PASBackendLDAPBookView *view = search_op->view;
-		LDAP *ldap = bl->priv->ldap;
-		int ldap_err;
-		GTimeVal search_start;
+	msg_type = ldap_msgtype (res);
+	if (msg_type == LDAP_RES_SEARCH_ENTRY) {
+		e = ldap_first_entry(ldap, res);
 
-		view->pending_adds = NULL;
-		view->num_pending_adds = 0;
-		view->target_pending_adds = GROUPING_INITIAL_SIZE;
+		while (NULL != e) {
+			ECardSimple *card = build_card_from_entry (ldap, e, NULL);
 
-		g_get_current_time (&search_start);
-		view->grouping_time_start = TV_TO_MILLIS (search_start);
-		view->num_sent_last_time = 0;
-		view->num_sent_this_time = 0;
-		view->notified_receiving_results = FALSE;
+			search_op->pending_adds = g_list_append (search_op->pending_adds,
+								 e_card_simple_get_vcard_assume_utf8 (card));
+			search_op->num_pending_adds ++;
 
-		ldap_err = ldap_search_ext (ldap, bl->priv->ldap_rootdn,
-					    bl->priv->ldap_scope,
-					    search_op->ldap_query,
-					    NULL, 0,
-					    NULL, /* XXX */
-					    NULL, /* XXX */
-					    NULL,
-					    bl->priv->ldap_limit, &view->search_msgid);
-
-		if (ldap_err != LDAP_SUCCESS) {
-			pas_book_view_notify_status_message (view->book_view, ldap_err2string(ldap_err));
-			return TRUE; /* act synchronous in this case */
-		}
+			gtk_object_unref (GTK_OBJECT(card));
 
-		if (view->search_msgid == -1) {
-			pas_book_view_notify_status_message (view->book_view, ldap_err2string(ldap_err));
-			return TRUE; /* act synchronous in this case */
-		}
-		else {
-			view->search_timeout = g_timeout_add (LDAP_POLL_INTERVAL,
-							      (GSourceFunc) poll_ldap,
-							      search_op);
+			e = ldap_next_entry(ldap, e);
 		}
-
-		/* we're async */
-		return FALSE;
+	}
+	else if (msg_type == LDAP_RES_SEARCH_RESULT) {
+		/* the entry that marks the end of our search */
+		if (search_op->num_pending_adds)
+			send_pending_adds (search_op);
+		pas_book_view_notify_complete (search_op->op.view);
+		ldap_op_finished (op);
 	}
 	else {
-		/* error doing the conversion to an ldap query, let's
-                   end this now by acting like we're synchronous. */
-		g_warning ("LDAP problem converting search query %s\n", search_op->view->search);
-		return TRUE;
+		g_warning ("unhandled search result type %d returned", msg_type);
+		if (search_op->num_pending_adds)
+			send_pending_adds (search_op);
+		pas_book_view_notify_complete (search_op->op.view);
+		ldap_op_finished (op);
 	}
 }
 
 static void
-ldap_search_dtor (PASBackend *backend, LDAPOp *op)
+ldap_search_dtor (LDAPOp *op)
 {
 	LDAPSearchOp *search_op = (LDAPSearchOp*) op;
 
-	g_free (search_op->ldap_query);
+	/* unhook us from our PASBackendLDAPBookView */
+	if (search_op->view)
+		search_op->view->search_op = NULL;
+
 	g_free (search_op);
 }
 
@@ -2446,19 +2692,64 @@ pas_backend_ldap_search (PASBackendLDAP  	*bl,
 			 PASBook         	*book,
 			 PASBackendLDAPBookView *view)
 {
-	LDAPSearchOp *op = g_new (LDAPSearchOp, 1);
+	LDAPSearchOp *search_op = g_new0 (LDAPSearchOp, 1);
+	char *ldap_query;
 
-	ldap_op_init ((LDAPOp*)op, PAS_BACKEND(bl), book, view->book_view, ldap_search_handler, ldap_search_dtor);
+	pas_book_view_notify_status_message (view->book_view, _("Searching..."));
 
-	op->ldap_query = NULL;
-	op->view = view;
-	op->bl = bl;
+	ldap_query = pas_backend_ldap_build_query(bl, view->search);
 
-	/* keep track of the search op so we can delete it from the
-           list if the view is destroyed */
-	view->search_op = (LDAPOp*)op;
+	if (ldap_query != NULL) {
+		LDAP *ldap = bl->priv->ldap;
+		int ldap_err;
+		GTimeVal search_start;
+		int search_msgid;
+		
+		ldap_err = ldap_search_ext (ldap, bl->priv->ldap_rootdn,
+					    bl->priv->ldap_scope,
+					    ldap_query,
+					    NULL, 0,
+					    NULL, /* XXX */
+					    NULL, /* XXX */
+					    NULL, /* XXX timeout */
+					    bl->priv->ldap_limit, &search_msgid);
+
+		g_free (ldap_query);
+
+		if (ldap_err != LDAP_SUCCESS) {
+			pas_book_view_notify_status_message (view->book_view, ldap_err2string(ldap_err));
+			return;
+		}
+		else if (search_msgid == -1) {
+			pas_book_view_notify_status_message (view->book_view,
+							     _("Error performing search"));
+			return;
+		}
+		else {
+			LDAPSearchOp *op = g_new0 (LDAPSearchOp, 1);
+
+			op->target_pending_adds = GROUPING_INITIAL_SIZE;
+
+			g_get_current_time (&search_start);
+			op->grouping_time_start = TV_TO_MILLIS (search_start);
+
+			op->view = view;
+
+			view->search_op = (LDAPOp*)op;
+
+			ldap_op_add ((LDAPOp*)op, PAS_BACKEND(bl), book, view->book_view,
+				     search_msgid,
+				     ldap_search_handler, ldap_search_dtor);
+			
+		}
+		return;
+	}
+	else {
+		g_warning ("LDAP problem converting search query %s\n", search_op->view->search);
+		pas_book_view_notify_status_message (view->book_view, _("Could not parse query string"));
+		return;
+	}
 
-	ldap_op_process ((LDAPOp*)op);
 }
 
 static void
@@ -2467,13 +2758,12 @@ pas_backend_ldap_process_get_book_view (PASBackend *backend,
 					PASRequest *req)
 {
 	PASBackendLDAP *bl = PAS_BACKEND_LDAP (backend);
-	CORBA_Environment ev;
 	PASBookView       *book_view;
 	PASBackendLDAPBookView *view;
 
-	g_return_if_fail (req->listener != NULL);
+	g_return_if_fail (req->get_book_view.listener != NULL);
 
-	book_view = pas_book_view_new (req->listener);
+	book_view = pas_book_view_new (req->get_book_view.listener);
 
 	bonobo_object_ref(BONOBO_OBJECT(book));
 	gtk_signal_connect(GTK_OBJECT(book_view), "destroy",
@@ -2481,7 +2771,7 @@ pas_backend_ldap_process_get_book_view (PASBackend *backend,
 
 	view = g_new0(PASBackendLDAPBookView, 1);
 	view->book_view = book_view;
-	view->search = g_strdup(req->search);
+	view->search = g_strdup(req->get_book_view.search);
 	view->card_sexp = pas_backend_card_sexp_new (view->search);
 	view->blpriv = bl->priv;
 
@@ -2495,18 +2785,7 @@ pas_backend_ldap_process_get_book_view (PASBackend *backend,
 
 	pas_backend_ldap_search (bl, book, view);
 
-	g_free (req->search);
-	CORBA_exception_init(&ev);
-
 	bonobo_object_unref (BONOBO_OBJECT (book_view));
-	bonobo_object_release_unref(req->listener, &ev);
-
-	if (ev._major != CORBA_NO_EXCEPTION) {
-		g_warning("pas_backend_file_process_get_book_view: Exception reffing "
-			  "corba book.\n");
-	}
-	CORBA_exception_free(&ev);
-
 }
 
 static void
@@ -2528,9 +2807,9 @@ pas_backend_ldap_process_authenticate_user (PASBackend *backend,
 	int ldap_error;
 	char *dn = NULL;
 
-	if (!strcmp (req->auth_method, "ldap/simple-email")) {
+	if (!strcmp (req->auth_user.auth_method, "ldap/simple-email")) {
 		LDAPMessage    *res, *e;
-		char *query = g_strdup_printf ("(mail=%s)", req->user);
+		char *query = g_strdup_printf ("(mail=%s)", req->auth_user.user);
 
 		ldap_error = ldap_search_s (bl->priv->ldap,
 					    bl->priv->ldap_rootdn,
@@ -2550,15 +2829,15 @@ pas_backend_ldap_process_authenticate_user (PASBackend *backend,
 			return;
 		}
 	}
-	else {
-		dn = g_strdup (req->user);
+	else if (!strcmp (req->auth_user.auth_method, "ldap/simple-binddn")) {
+		dn = g_strdup (req->auth_user.user);
 	}
 
 	/* now authenticate against the DN we were either supplied or queried for */
 	printf ("authenticating as %s\n", dn);
 	ldap_error = ldap_simple_bind_s(bl->priv->ldap,
 					dn,
-					req->passwd);
+					req->auth_user.passwd);
 	g_free (dn);
 
 	pas_book_respond_authenticate_user (book,
@@ -2566,7 +2845,7 @@ pas_backend_ldap_process_authenticate_user (PASBackend *backend,
 
 	bl->priv->writable = (ldap_error == LDAP_SUCCESS);
 
-	if (!bl->priv->evolutionPersonChecked)
+	if (!bl->priv->schema_checked)
 		check_schema_support (bl);
 
 	pas_book_report_writable (book, bl->priv->writable);
@@ -2639,7 +2918,7 @@ pas_backend_ldap_process_client_requests (PASBook *book)
 		break;
 	}
 
-	g_free (req);
+	pas_book_free_request (req);
 }
 
 static void
@@ -2845,10 +3124,14 @@ pas_backend_ldap_new (void)
 	return PAS_BACKEND (backend);
 }
 
-static void
-call_dtor (LDAPOp *op, gpointer data)
+static gboolean
+call_dtor (int msgid, LDAPOp *op, gpointer data)
 {
-	op->dtor (op->backend, op);
+	ldap_abandon (PAS_BACKEND_LDAP(op->backend)->priv->ldap, op->id);
+
+	op->dtor (op);
+
+	return TRUE;
 }
 
 static void
@@ -2858,8 +3141,11 @@ pas_backend_ldap_destroy (GtkObject *object)
 
 	bl = PAS_BACKEND_LDAP (object);
 
-	g_list_foreach (bl->priv->pending_ops, (GFunc)call_dtor, NULL);
-	g_list_free (bl->priv->pending_ops);
+	g_hash_table_foreach_remove (bl->priv->id_to_op, (GHRFunc)call_dtor, NULL);
+	g_hash_table_destroy (bl->priv->id_to_op);
+
+	if (bl->priv->poll_timeout != -1)
+		g_source_remove (bl->priv->poll_timeout);
 
 	if (bl->priv->supported_fields)
 		gtk_object_unref (GTK_OBJECT (bl->priv->supported_fields));
@@ -2875,6 +3161,9 @@ pas_backend_ldap_class_init (PASBackendLDAPClass *klass)
 	GtkObjectClass  *object_class = (GtkObjectClass *) klass;
 	PASBackendClass *parent_class;
 
+	/* get client side information (extensions present in the library) */
+	get_ldap_library_info ();
+
 	pas_backend_ldap_parent_class = gtk_type_class (pas_backend_get_type ());
 
 	parent_class = PAS_BACKEND_CLASS (klass);
@@ -2897,8 +3186,9 @@ pas_backend_ldap_init (PASBackendLDAP *backend)
 	priv                   = g_new0 (PASBackendLDAPPrivate, 1);
 
 	priv->supported_fields = e_list_new ((EListCopyFunc)g_strdup, (EListFreeFunc)g_free, NULL);
-	priv->ldap_limit            = 100;
-
+	priv->ldap_limit       = 100;
+	priv->id_to_op         = g_hash_table_new (g_int_hash, g_int_equal);
+	priv->poll_timeout     = -1;
 	backend->priv = priv;
 }
 
diff --git a/addressbook/backend/pas/pas-book.c b/addressbook/backend/pas/pas-book.c
index b0b35b2c0f..9bb2cd348e 100644
--- a/addressbook/backend/pas/pas-book.c
+++ b/addressbook/backend/pas/pas-book.c
@@ -74,7 +74,7 @@ pas_book_queue_create_card (PASBook *book, const char *vcard)
 
 	req        = g_new0 (PASRequest, 1);
 	req->op    = CreateCard;
-	req->vcard = g_strdup (vcard);
+	req->create.vcard = g_strdup (vcard);
 
 	pas_book_queue_request (book, req);
 }
@@ -86,7 +86,7 @@ pas_book_queue_remove_card (PASBook *book, const char *id)
 
 	req     = g_new0 (PASRequest, 1);
 	req->op = RemoveCard;
-	req->id = g_strdup (id);
+	req->remove.id = g_strdup (id);
 
 	pas_book_queue_request (book, req);
 }
@@ -98,7 +98,7 @@ pas_book_queue_modify_card (PASBook *book, const char *vcard)
 
 	req        = g_new0 (PASRequest, 1);
 	req->op    = ModifyCard;
-	req->vcard = g_strdup (vcard);
+	req->modify.vcard = g_strdup (vcard);
 
 	pas_book_queue_request (book, req);
 }
@@ -110,7 +110,7 @@ pas_book_queue_get_cursor (PASBook *book, const char *search)
 
 	req         = g_new0 (PASRequest, 1);
 	req->op     = GetCursor;
-	req->search = g_strdup(search);
+	req->get_cursor.search = g_strdup(search);
 
 	pas_book_queue_request (book, req);
 }
@@ -122,7 +122,7 @@ pas_book_queue_get_vcard (PASBook *book, const char *id)
 
 	req     = g_new0 (PASRequest, 1);
 	req->op = GetVCard;
-	req->id = g_strdup(id);
+	req->get_vcard.id = g_strdup(id);
 
 	pas_book_queue_request (book, req);
 }
@@ -135,9 +135,9 @@ pas_book_queue_authenticate_user (PASBook *book,
 
 	req         = g_new0 (PASRequest, 1);
 	req->op     = AuthenticateUser;
-	req->user   = g_strdup(user);
-	req->passwd = g_strdup(passwd);
-	req->auth_method = g_strdup(auth_method);
+	req->auth_user.user   = g_strdup(user);
+	req->auth_user.passwd = g_strdup(passwd);
+	req->auth_user.auth_method = g_strdup(auth_method);
 
 	pas_book_queue_request (book, req);
 }
@@ -162,11 +162,11 @@ pas_book_queue_get_book_view (PASBook *book, const GNOME_Evolution_Addressbook_B
 
 	req           = g_new0 (PASRequest, 1);
 	req->op       = GetBookView;
-	req->search   = g_strdup(search);
+	req->get_book_view.search   = g_strdup(search);
 	
 	CORBA_exception_init (&ev);
 
-	req->listener = bonobo_object_dup_ref(listener, &ev);
+	req->get_book_view.listener = bonobo_object_dup_ref(listener, &ev);
 
 	if (ev._major != CORBA_NO_EXCEPTION) {
 		g_warning ("pas_book_queue_get_book_view: Exception "
@@ -186,11 +186,11 @@ pas_book_queue_get_changes (PASBook *book, const GNOME_Evolution_Addressbook_Boo
 
 	req           = g_new0 (PASRequest, 1);
 	req->op       = GetChanges;
-	req->change_id= g_strdup(change_id);
+	req->get_changes.change_id= g_strdup(change_id);
 	
 	CORBA_exception_init (&ev);
 
-	req->listener = bonobo_object_dup_ref(listener, &ev);
+	req->get_changes.listener = bonobo_object_dup_ref(listener, &ev);
 
 	if (ev._major != CORBA_NO_EXCEPTION) {
 		g_warning ("pas_book_queue_get_changes: Exception "
@@ -766,6 +766,63 @@ pas_book_new (PASBackend             *backend,
 	return book;
 }
 
+void
+pas_book_free_request (PASRequest *req)
+{
+	CORBA_Environment ev;
+	switch (req->op) {
+	case CreateCard:
+		g_free (req->create.id);
+		g_free (req->create.vcard);
+		break;
+	case RemoveCard:
+		g_free (req->remove.id);
+		break;
+	case ModifyCard:
+		g_free (req->modify.vcard);
+		break;
+	case GetVCard:
+		g_free (req->get_vcard.id);
+		break;
+	case GetCursor:
+		g_free (req->get_cursor.search);
+		break;
+	case GetBookView:
+		g_free (req->get_book_view.search);
+		CORBA_exception_init (&ev);
+		bonobo_object_release_unref (req->get_book_view.listener, &ev);
+
+		if (ev._major != CORBA_NO_EXCEPTION)
+			g_message ("pas_book_free_request(GetBookView): could not release the listener");
+	
+		CORBA_exception_free (&ev);
+		break;
+	case GetChanges:
+		g_free (req->get_changes.change_id);
+		CORBA_exception_init (&ev);
+		bonobo_object_release_unref (req->get_changes.listener, &ev);
+
+		if (ev._major != CORBA_NO_EXCEPTION)
+			g_message ("pas_book_free_request(GetChanges): could not release the listener");
+
+		CORBA_exception_free (&ev);
+		break;
+	case CheckConnection:
+		/* nothing to free */
+		break;
+	case AuthenticateUser:
+		g_free (req->auth_user.user);
+		g_free (req->auth_user.passwd);
+		g_free (req->auth_user.auth_method);
+		break;
+	case GetSupportedFields:
+		/* nothing to free */
+		break;
+	}
+
+	g_free (req);
+}
+
 static void
 pas_book_destroy (GtkObject *object)
 {
@@ -774,11 +831,7 @@ pas_book_destroy (GtkObject *object)
 	CORBA_Environment ev;
 
 	for (l = book->priv->request_queue; l != NULL; l = l->next) {
-		PASRequest *req = l->data;
-
-		g_free (req->id);
-		g_free (req->vcard);
-		g_free (req);
+		pas_book_free_request ((PASRequest *)l->data);
 	}
 	g_list_free (book->priv->request_queue);
 
diff --git a/addressbook/backend/pas/pas-book.h b/addressbook/backend/pas/pas-book.h
index 8afba26b45..a6f2fda3cc 100644
--- a/addressbook/backend/pas/pas-book.h
+++ b/addressbook/backend/pas/pas-book.h
@@ -38,16 +38,71 @@ typedef enum {
 } PASOperation;
 
 typedef struct {
-	PASOperation               op;
-	char                      *id;
-	char                      *vcard;
-	char                      *search;
-	char                      *change_id;
-	char                      *user;
-        char                      *passwd;
-	char                      *auth_method;
+	PASOperation op;
+	char *id;
+	char *vcard;
+} PASCreateCardRequest;
+
+typedef struct {
+	PASOperation op;
+	char *id;
+} PASRemoveCardRequest;
+
+typedef struct {
+	PASOperation op;
+	char *vcard;
+} PASModifyCardRequest;
+
+typedef struct {
+	PASOperation op;
+	char *id;
+} PASGetVCardRequest;
+
+typedef struct {
+	PASOperation op;
+	char *search;
+} PASGetCursorRequest;
+
+typedef struct {
+	PASOperation op;
+	char *search;
 	GNOME_Evolution_Addressbook_BookViewListener listener;
-	GNOME_Evolution_Addressbook_stringlist fields;
+} PASGetBookViewRequest;
+
+typedef struct {
+	PASOperation op;
+	char *change_id;
+	GNOME_Evolution_Addressbook_BookViewListener listener;
+} PASGetChangesRequest;
+
+typedef struct {
+	PASOperation op;
+} PASCheckConnectionRequest;
+
+typedef struct {
+	PASOperation op;
+	char *user;
+        char *passwd;
+	char *auth_method;
+} PASAuthenticateUserRequest;
+
+typedef struct {
+	PASOperation op;
+} PASGetSupportedFieldsRequest;
+
+typedef union {
+	PASOperation               op;
+
+	PASCreateCardRequest       create;
+	PASRemoveCardRequest       remove;
+	PASModifyCardRequest       modify;
+	PASGetVCardRequest         get_vcard;
+	PASGetCursorRequest        get_cursor;
+	PASGetBookViewRequest      get_book_view;
+	PASGetChangesRequest       get_changes;
+	PASCheckConnectionRequest  check_connection;
+	PASAuthenticateUserRequest auth_user;
+	PASGetSupportedFieldsRequest get_supported_fields;
 } PASRequest;
 
 struct _PASBook {
@@ -71,6 +126,7 @@ PASBackend             *pas_book_get_backend            (PASBook
 GNOME_Evolution_Addressbook_BookListener  pas_book_get_listener           (PASBook                           *book);
 int                     pas_book_check_pending          (PASBook                           *book);
 PASRequest             *pas_book_pop_request            (PASBook                           *book);
+void                    pas_book_free_request           (PASRequest                        *request);
 void                    pas_book_respond_open           (PASBook                           *book,
 							 GNOME_Evolution_Addressbook_BookListener_CallStatus  status);
 void                    pas_book_respond_create         (PASBook                           *book,