major restructuring of the escrow component

refine the several layers (CLI, API, plugins) and enable async execution

10 files changed, 565 insertions, 186 deletions

diff --git a/src/escrow/escrow.h b/src/escrow/escrow.h
index 7be456bec..f6b9a6320 100644
--- a/src/escrow/escrow.h
+++ b/src/escrow/escrow.h
@@ -28,6 +28,122 @@
 #ifndef ESCROW_H
 #define ESCROW_H
 
+#include "gnunet_escrow_lib.h"
+
+
+/**
+ * State while collecting all egos
+ */
+#define ESCROW_PLUGIN_STATE_INIT 0
+
+/**
+ * Done collecting egos
+ */
+#define ESCROW_PLUGIN_STATE_POST_INIT 1
+
+
+/**
+ * The ego list
+ */
+struct EgoEntry
+{
+  /**
+   * DLL
+   */
+  struct EgoEntry *next;
+
+  /**
+   * DLL
+   */
+  struct EgoEntry *prev;
+
+  /**
+   * Ego Identifier
+   */
+  char *identifier;
+
+  /**
+   * Public key string
+   */
+  char *keystring;
+
+  /**
+   * The Ego
+   */
+  struct GNUNET_IDENTITY_Ego *ego;
+};
+
+/**
+ * Handle for a plugin instance
+ */
+struct ESCROW_PluginHandle
+{
+  /**
+   * The identity init continuation.
+   */
+  GNUNET_ESCROW_IdentityInitContinuation id_init_cont;
+
+  /**
+   * The ego create continuation.
+   */
+  GNUNET_ESCROW_EgoCreateContinuation ego_create_cont;
+
+  /**
+   * The current restore callback.
+   */
+  GNUNET_ESCROW_EgoContinuation curr_restore_cb;
+
+  /**
+   * The handle to the escrow component.
+   */
+  struct GNUNET_ESCROW_Handle *escrow_handle;
+
+  /**
+   * The state of the plugin (in the initialization phase).
+   */
+  int state;
+
+  /**
+   * The head of the ego list.
+   */
+  struct EgoEntry *ego_head;
+
+  /**
+   * The tail of the ego list
+   */
+  struct EgoEntry *ego_tail;
+
+  /**
+   * The head of the plugin operation list
+   */
+  struct ESCROW_PluginOperationWrapper *plugin_op_head;
+
+  /**
+   * The tail of the plugin operation list
+   */
+  struct ESCROW_PluginOperationWrapper *plugin_op_tail;
+};
+
+/**
+ * Wrapper for an escrow plugin operation
+ */
+struct ESCROW_PluginOperationWrapper
+{
+  /**
+   * Plugin operations are kept in a DLL.
+   */
+  struct ESCROW_PluginOperationWrapper *prev;
+
+  /**
+   * Plugin operations are kept in a DLL.
+   */
+  struct ESCROW_PluginOperationWrapper *next;
+
+  /**
+   * The actual plugin operation
+   */
+  void *plugin_op;
+};
 
 
 #endif
diff --git a/src/escrow/escrow_api.c b/src/escrow/escrow_api.c
index 579707af2..20cae2f5c 100644
--- a/src/escrow/escrow_api.c
+++ b/src/escrow/escrow_api.c
@@ -128,6 +128,8 @@ GNUNET_ESCROW_init (const struct GNUNET_CONFIGURATION_Handle *cfg)
 
   h = GNUNET_new (struct GNUNET_ESCROW_Handle);
   h->cfg = cfg;
+  h->op_head = NULL;
+  h->op_tail = NULL;
   return h;
 }
 
@@ -174,22 +176,26 @@ GNUNET_ESCROW_fini (struct GNUNET_ESCROW_Handle *h)
 
 
 void
-handle_start_escrow_result (void *cls,
-                            struct GNUNET_ESCROW_Anchor *escrowAnchor)
+handle_start_escrow_result (void *cls)
 {
-  struct GNUNET_ESCROW_Handle *h = cls;
+  struct GNUNET_ESCROW_Plugin_AnchorContinuationWrapper *w = cls;
   struct GNUNET_ESCROW_Operation *op;
 
-  op = h->op_head;
+  for (op = w->h->op_head; NULL != op; op = op->next)
+    if (1) // TODO: find condition (e.g. unique ID)
+      break;
+
   if (NULL == op)
   {
     GNUNET_break (0);
+    GNUNET_free (w);
     return;
   }
-  GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
-  if (NULL != op->cb_get)
-    op->cb_put (op->cb_cls, escrowAnchor);
+  GNUNET_CONTAINER_DLL_remove (w->h->op_head, w->h->op_tail, op);
+  if (NULL != op->cb_put)
+    op->cb_put (w->escrowAnchor);
   GNUNET_free (op);
+  GNUNET_free (w);
 }
 
 
@@ -216,12 +222,13 @@ GNUNET_ESCROW_put (struct GNUNET_ESCROW_Handle *h,
 
   op = GNUNET_new (struct GNUNET_ESCROW_Operation);
   op->h = h;
+  op->method = method;
   op->cb_put = cb;
   op->cb_cls = cb_cls;
   GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
 
   api = init_plugin (h, method);
-  api->start_key_escrow (h, ego, &handle_start_escrow_result);
+  op->plugin_op_wrap = api->start_key_escrow (h, ego, &handle_start_escrow_result);
 
   return op;
 }
@@ -250,6 +257,7 @@ GNUNET_ESCROW_renew (struct GNUNET_ESCROW_Handle *h,
 
   op = GNUNET_new (struct GNUNET_ESCROW_Operation);
   op->h = h;
+  op->method = method;
   op->cb_renew = cb;
   op->cb_cls = cb_cls;
 
@@ -261,22 +269,26 @@ GNUNET_ESCROW_renew (struct GNUNET_ESCROW_Handle *h,
 
 
 static void
-handle_restore_key_result (void *cls,
-                           const struct GNUNET_IDENTITY_Ego *ego)
+handle_restore_key_result (void *cls)
 {
-  struct GNUNET_ESCROW_Handle *h = cls;
+  struct GNUNET_ESCROW_Plugin_EgoContinuationWrapper *w = cls;
   struct GNUNET_ESCROW_Operation *op;
 
-  op = h->op_head;
+  for (op = w->h->op_head; NULL != op; op = op->next)
+    if (1) // TODO: find condition (e.g. unique ID)
+      break;
+
   if (NULL == op)
   {
     GNUNET_break (0);
+    GNUNET_free (w);
     return;
   }
-  GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
+  GNUNET_CONTAINER_DLL_remove (w->h->op_head, w->h->op_tail, op);
   if (NULL != op->cb_get)
-    op->cb_get (op->cb_cls, ego);
+    op->cb_get (w->ego);
   GNUNET_free (op);
+  GNUNET_free (w);
 }
 
 
@@ -305,34 +317,41 @@ GNUNET_ESCROW_get (struct GNUNET_ESCROW_Handle *h,
 
   op = GNUNET_new (struct GNUNET_ESCROW_Operation);
   op->h = h;
+  op->method = method;
   op->cb_get = cb;
   op->cb_cls = cb_cls;
   GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
 
   api = init_plugin (h, method);
-  api->restore_key (h, escrowAnchor, egoName, &handle_restore_key_result);
+  op->plugin_op_wrap = api->restore_key (h, escrowAnchor, egoName, &handle_restore_key_result);
 
   return op;
 }
 
 
 void
-handle_verify_escrow_result (void *cls,
-                             int verificationResult)
+handle_verify_escrow_result (void *cls)
 {
-  struct GNUNET_ESCROW_Handle *h = cls;
+  struct GNUNET_ESCROW_Plugin_VerifyContinuationWrapper *w = cls;
   struct GNUNET_ESCROW_Operation *op;
 
-  op = h->op_head;
+  for (op = w->h->op_head; NULL != op; op = op->next)
+    if (1) // TODO: find condition (e.g. unique ID)
+      break;
+
   if (NULL == op)
   {
     GNUNET_break (0);
+    GNUNET_free (w);
     return;
   }
-  GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
-  if (NULL != op->cb_get)
-    op->cb_verify (op->cb_cls, verificationResult);
+  GNUNET_CONTAINER_DLL_remove (w->h->op_head, w->h->op_tail, op);
+  if (NULL != op->cb_verify)
+    op->cb_verify (w->verificationResult);
+  GNUNET_free (op->plugin_op_wrap->plugin_op);
+  GNUNET_free (op->plugin_op_wrap);
   GNUNET_free (op);
+  GNUNET_free (w);
 }
 
 
@@ -361,12 +380,13 @@ GNUNET_ESCROW_verify (struct GNUNET_ESCROW_Handle *h,
 
   op = GNUNET_new (struct GNUNET_ESCROW_Operation);
   op->h = h;
+  op->method = method;
   op->cb_verify = cb;
   op->cb_cls = cb_cls;
   GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
 
   api = init_plugin (h, method);
-  api->verify_key_escrow (h, ego, escrowAnchor, &handle_verify_escrow_result);
+  op->plugin_op_wrap = api->verify_key_escrow (h, ego, escrowAnchor, &handle_verify_escrow_result);
 
   return op;
 }
@@ -420,21 +440,31 @@ GNUNET_ESCROW_anchor_data_to_string (struct GNUNET_ESCROW_Handle *h,
  * be executed; this merely cancels the continuation.
  *
  * @param op operation to cancel
- * @param method the escrow method to use
  */
 void
-GNUNET_ESCROW_cancel (struct GNUNET_ESCROW_Operation *op,
-                      enum GNUNET_ESCROW_Key_Escrow_Method method)
+GNUNET_ESCROW_cancel (struct GNUNET_ESCROW_Operation *op)
 {
   const struct GNUNET_ESCROW_KeyPluginFunctions *api;
+  struct GNUNET_ESCROW_Handle *h = op->h;
+  struct GNUNET_ESCROW_Operation *curr;
 
-  api = init_plugin (op->h, method);
-  // TODO: api->cancel (...);
-
-  op->cb_put = NULL;
-  op->cb_renew = NULL;
-  op->cb_verify = NULL;
-  op->cb_get = NULL;
+  // check if op is in our DLL
+  for (curr = h->op_head; NULL != curr; curr = curr->next)
+  {
+    if (curr == op)
+    {
+      GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
+      api = init_plugin (op->h, op->method);
+      api->cancel_plugin_operation (op->plugin_op_wrap);
+      // TODO: check which callback is not NULL?
+      op->cb_put = NULL;
+      op->cb_renew = NULL;
+      op->cb_verify = NULL;
+      op->cb_get = NULL;
+      GNUNET_free (op);
+      return;
+    }
+  }
 }
 
 
diff --git a/src/escrow/escrow_plugin_helper.c b/src/escrow/escrow_plugin_helper.c
index afbbd409a..07cb5e139 100644
--- a/src/escrow/escrow_plugin_helper.c
+++ b/src/escrow/escrow_plugin_helper.c
@@ -71,7 +71,7 @@ ESCROW_list_ego (void *cls,
                  void **ctx,
                  const char *identifier)
 {
-  struct EscrowPluginHandle *ph = cls;
+  struct ESCROW_PluginHandle *ph = cls;
   struct EgoEntry *ego_entry;
   struct GNUNET_CRYPTO_EcdsaPublicKey pk;
 
@@ -161,7 +161,7 @@ ESCROW_list_ego (void *cls,
  * @param ph handle for the plugin
  */
 void
-ESCROW_cleanup_ego_list (struct EscrowPluginHandle *ph)
+ESCROW_cleanup_ego_list (struct ESCROW_PluginHandle *ph)
 {
   struct EgoEntry *ego_entry;
 
diff --git a/src/escrow/escrow_plugin_helper.h b/src/escrow/escrow_plugin_helper.h
index 96910ad6a..d0409bc38 100644
--- a/src/escrow/escrow_plugin_helper.h
+++ b/src/escrow/escrow_plugin_helper.h
@@ -78,4 +78,4 @@ ESCROW_list_ego (void *cls,
  * @param ph handle for the plugin
  */
 void
-ESCROW_cleanup_ego_list (struct EscrowPluginHandle *ph);
+ESCROW_cleanup_ego_list (struct ESCROW_PluginHandle *ph);
diff --git a/src/escrow/gnunet-escrow.c b/src/escrow/gnunet-escrow.c
index 929ff169d..7918423ba 100644
--- a/src/escrow/gnunet-escrow.c
+++ b/src/escrow/gnunet-escrow.c
@@ -68,7 +68,7 @@ static char *get_ego;
 /**
  * The ego
  */
-struct GNUNET_IDENTITY_Ego *ego;
+const struct GNUNET_IDENTITY_Ego *ego;
 
 /**
  * Anchor string
@@ -124,7 +124,7 @@ do_cleanup (void *cls)
     GNUNET_IDENTITY_disconnect (identity_handle);
   if (NULL != escrow_op)
   {
-    GNUNET_ESCROW_cancel (escrow_op, method);
+    GNUNET_ESCROW_cancel (escrow_op);
     GNUNET_free (escrow_op);
     escrow_op = NULL;
   }
@@ -145,16 +145,16 @@ do_cleanup (void *cls)
   }
   if (NULL != ego)
   {
-    //GNUNET_free (ego); // TODO: free correctly!
+    /* does not have to be freed, as this is done when
+       cleaning up the ego list in the plugin */
     ego = NULL;
   }
-  method = 0;
+  method = -1;
 }
 
 
 static void
-put_cb (void *cls,
-        struct GNUNET_ESCROW_Anchor *escrowAnchor)
+put_cb (struct GNUNET_ESCROW_Anchor *escrowAnchor)
 {
   char *anchorString;
 
@@ -171,8 +171,7 @@ in order to restore the key later!\n%s\n", anchorString);
 
 
 static void
-verify_cb (void *cls,
-           int verificationResult)
+verify_cb (int verificationResult)
 {
   escrow_op = NULL;
 
@@ -195,8 +194,7 @@ verify_cb (void *cls,
 
 
 static void
-get_cb (void *cls,
-        const struct GNUNET_IDENTITY_Ego *ego)
+get_cb (const struct GNUNET_IDENTITY_Ego *ego)
 {
   escrow_op = NULL;
 
@@ -330,11 +328,23 @@ run (void *cls,
       return;
     }
     /* verify */
+    if (NULL == anchor_string)
+    {
+      ret = 1;
+      fprintf (stderr, _ ("-a is needed for -V!\n"));
+      return;
+    }
     ego_name = verify_ego;
   }
   else if (NULL != get_ego)
   {
     /* get */
+    if (NULL == anchor_string)
+    {
+      ret = 1;
+      fprintf (stderr, _ ("-a is needed for -G!\n"));
+      return;
+    }
     ego_name = get_ego;
   }
   else
diff --git a/src/escrow/plugin_escrow_anastasis.c b/src/escrow/plugin_escrow_anastasis.c
index 0c657de4d..3f70a4aaf 100644
--- a/src/escrow/plugin_escrow_anastasis.c
+++ b/src/escrow/plugin_escrow_anastasis.c
@@ -39,7 +39,7 @@ static struct GNUNET_IDENTITY_Handle *identity_handle;
 /**
  * Handle for the plugin instance
  */
-struct EscrowPluginHandle ph;
+struct ESCROW_PluginHandle ph;
 
 
 /**
@@ -48,14 +48,23 @@ struct EscrowPluginHandle ph;
  * @param h the handle for the escrow component
  * @param ego the identity ego containing the private key
  * @param cb the function called upon completion
+ * 
+ * @return plugin operation wrapper
  */
-void
+struct ESCROW_PluginOperationWrapper *
 start_anastasis_key_escrow (struct GNUNET_ESCROW_Handle *h,
                             const struct GNUNET_IDENTITY_Ego *ego,
-                            GNUNET_ESCROW_AnchorContinuation cb)
+                            GNUNET_SCHEDULER_TaskCallback cb)
 {
+  struct GNUNET_ESCROW_Plugin_AnchorContinuationWrapper *w;
+
+  w = GNUNET_new (struct GNUNET_ESCROW_Plugin_AnchorContinuationWrapper);
+  w->h = h;
+
   // TODO: implement
-  cb (h, NULL);
+  w->escrowAnchor = NULL;
+  GNUNET_SCHEDULER_add_now (cb, w);
+  return NULL;
 }
 
 
@@ -70,7 +79,7 @@ renew_anastasis_key_escrow (struct GNUNET_ESCROW_Operation *op,
                             struct GNUNET_ESCROW_Anchor *escrowAnchor)
 {
   // TODO: implement
-  op->cb_renew (op->cb_cls, NULL);
+  op->cb_renew (NULL);
 }
 
 
@@ -81,15 +90,24 @@ renew_anastasis_key_escrow (struct GNUNET_ESCROW_Operation *op,
  * @param ego the identity ego containing the private key
  * @param escrowAnchor the escrow anchor needed to restore the key
  * @param cb the function called upon completion
+ * 
+ * @return plugin operation wrapper
  */
-void
+struct ESCROW_PluginOperationWrapper *
 verify_anastasis_key_escrow (struct GNUNET_ESCROW_Handle *h,
                              const struct GNUNET_IDENTITY_Ego *ego,
                              struct GNUNET_ESCROW_Anchor *escrowAnchor,
-                             GNUNET_ESCROW_VerifyContinuation cb)
+                             GNUNET_SCHEDULER_TaskCallback cb)
 {
+  struct GNUNET_ESCROW_Plugin_VerifyContinuationWrapper *w;
+
+  w = GNUNET_new (struct GNUNET_ESCROW_Plugin_VerifyContinuationWrapper);
+  w->h = h;
+
   // TODO: implement
-  cb (h, GNUNET_ESCROW_INVALID);
+  w->verificationResult = GNUNET_ESCROW_INVALID;
+  GNUNET_SCHEDULER_add_now (cb, w);
+  return NULL;
 }
 
 
@@ -100,15 +118,24 @@ verify_anastasis_key_escrow (struct GNUNET_ESCROW_Handle *h,
  * @param escrowAnchor the escrow anchor needed to restore the key
  * @param egoName the name of the ego to restore
  * @param cb the function called upon completion
+ * 
+ * @return plugin operation wrapper
  */
-void
+struct ESCROW_PluginOperationWrapper *
 restore_anastasis_key_escrow (struct GNUNET_ESCROW_Handle *h,
                               struct GNUNET_ESCROW_Anchor *escrowAnchor,
                               char *egoName,
-                              GNUNET_ESCROW_EgoContinuation cb)
+                              GNUNET_SCHEDULER_TaskCallback cb)
 {
+  struct GNUNET_ESCROW_Plugin_EgoContinuationWrapper *w;
+
+  w = GNUNET_new (struct GNUNET_ESCROW_Plugin_EgoContinuationWrapper);
+  w->h = h;
+
   // TODO: implement
-  cb (h, NULL);
+  w->ego = NULL;
+  GNUNET_SCHEDULER_add_now (cb, w);
+  return NULL;
 }
 
 
@@ -155,6 +182,19 @@ anastasis_anchor_data_to_string (struct GNUNET_ESCROW_Handle *h,
 
 
 /**
+ * Cancel an Anastasis plugin operation.
+ * 
+ * @param plugin_op_wrap the plugin operation wrapper containing the operation
+ */
+void
+cancel_anastasis_operation (struct ESCROW_PluginOperationWrapper *plugin_op_wrap)
+{
+  // TODO: implement
+  return;
+}
+
+
+/**
  * IdentityInitContinuation for the Anastasis plugin
  */
 void
@@ -183,6 +223,7 @@ libgnunet_plugin_escrow_anastasis_init (void *cls)
   api->verify_key_escrow = &verify_anastasis_key_escrow;
   api->restore_key = &restore_anastasis_key_escrow;
   api->anchor_string_to_data = &anastasis_anchor_string_to_data;
+  api->cancel_plugin_operation = &cancel_anastasis_operation;
 
   ph.id_init_cont = &anastasis_cont_init;
 
diff --git a/src/escrow/plugin_escrow_gns.c b/src/escrow/plugin_escrow_gns.c
index f77ef30d6..278ceff5b 100644
--- a/src/escrow/plugin_escrow_gns.c
+++ b/src/escrow/plugin_escrow_gns.c
@@ -44,7 +44,7 @@ static struct GNUNET_IDENTITY_Handle *identity_handle;
 /**
  * Handle for the plugin instance
  */
-struct EscrowPluginHandle ph;
+struct ESCROW_PluginHandle ph;
 
 
 /**
@@ -53,21 +53,28 @@ struct EscrowPluginHandle ph;
  * @param h the handle for the escrow component
  * @param ego the identity ego containing the private key
  * @param cb the function called upon completion
+ * 
+ * @return plugin operation wrapper
  */
-void
+struct ESCROW_PluginOperationWrapper *
 start_gns_key_escrow (struct GNUNET_ESCROW_Handle *h,
                       const struct GNUNET_IDENTITY_Ego *ego,
-                      GNUNET_ESCROW_AnchorContinuation cb)
+                      GNUNET_SCHEDULER_TaskCallback cb)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk;
   sss_Keyshare keyshares;
   struct GNUNET_ESCROW_Anchor *anchor;
   int anchorDataSize;
+  struct GNUNET_ESCROW_Plugin_AnchorContinuationWrapper *w;
+
+  w = GNUNET_new (struct GNUNET_ESCROW_Plugin_AnchorContinuationWrapper);
+  w->h = h;
 
   if (NULL == ego)
   {
-    cb (h, NULL);
-    return;
+    w->escrowAnchor = NULL;
+    GNUNET_SCHEDULER_add_now (cb, w);
+    return NULL; // TODO!
   }
   pk = GNUNET_IDENTITY_ego_get_private_key (ego);
 
@@ -85,7 +92,9 @@ start_gns_key_escrow (struct GNUNET_ESCROW_Handle *h,
   // TODO: implement
   anchorDataSize = 0; // TODO!
   anchor = GNUNET_malloc (sizeof (struct GNUNET_ESCROW_Anchor) + anchorDataSize);
-  cb (h, anchor);
+  w->escrowAnchor = anchor;
+  GNUNET_SCHEDULER_add_now (cb, w);
+  return NULL; // TODO!
 }
 
 
@@ -100,7 +109,7 @@ renew_gns_key_escrow (struct GNUNET_ESCROW_Operation *op,
                       struct GNUNET_ESCROW_Anchor *escrowAnchor)
 {
   // TODO: implement
-  op->cb_renew (op->cb_cls, NULL);
+  op->cb_renew (NULL);
 }
 
 
@@ -111,15 +120,24 @@ renew_gns_key_escrow (struct GNUNET_ESCROW_Operation *op,
  * @param ego the identity ego containing the private key
  * @param escrowAnchor the escrow anchor needed to restore the key
  * @param cb the function called upon completion
+ * 
+ * @return plugin operation wrapper
  */
-void
+struct ESCROW_PluginOperationWrapper *
 verify_gns_key_escrow (struct GNUNET_ESCROW_Handle *h,
                        const struct GNUNET_IDENTITY_Ego *ego,
                        struct GNUNET_ESCROW_Anchor *escrowAnchor,
-                       GNUNET_ESCROW_VerifyContinuation cb)
+                       GNUNET_SCHEDULER_TaskCallback cb)
 {
+  struct GNUNET_ESCROW_Plugin_VerifyContinuationWrapper *w;
+
+  w = GNUNET_new (struct GNUNET_ESCROW_Plugin_VerifyContinuationWrapper);
+  w->h = h;
+
   // TODO: implement
-  cb (h, GNUNET_ESCROW_INVALID);
+  w->verificationResult = GNUNET_ESCROW_INVALID;
+  GNUNET_SCHEDULER_add_now (cb, w);
+  return NULL;
 }
 
 
@@ -130,15 +148,24 @@ verify_gns_key_escrow (struct GNUNET_ESCROW_Handle *h,
  * @param escrowAnchor the escrow anchor needed to restore the key
  * @param egoName the name of the ego to restore
  * @param cb the function called upon completion
+ * 
+ * @return plugin operation wrapper
  */
-void
+struct ESCROW_PluginOperationWrapper *
 restore_gns_key_escrow (struct GNUNET_ESCROW_Handle *h,
                         struct GNUNET_ESCROW_Anchor *escrowAnchor,
                         char *egoName,
-                        GNUNET_ESCROW_EgoContinuation cb)
+                        GNUNET_SCHEDULER_TaskCallback cb)
 {
+  struct GNUNET_ESCROW_Plugin_EgoContinuationWrapper *w;
+
+  w = GNUNET_new (struct GNUNET_ESCROW_Plugin_EgoContinuationWrapper);
+  w->h = h;
+
   // TODO: implement
-  cb (h, NULL);
+  w->ego = NULL;
+  GNUNET_SCHEDULER_add_now (cb, w);
+  return NULL;
 }
 
 
@@ -185,6 +212,19 @@ gns_anchor_data_to_string (struct GNUNET_ESCROW_Handle *h,
 
 
 /**
+ * Cancel a GNS plugin operation.
+ * 
+ * @param plugin_op_wrap the plugin operation wrapper containing the operation
+ */
+void
+cancel_gns_operation (struct ESCROW_PluginOperationWrapper *plugin_op_wrap)
+{
+  // TODO: implement
+  return;
+}
+
+
+/**
  * IdentityInitContinuation for the GNS plugin
  */
 void
@@ -213,6 +253,7 @@ libgnunet_plugin_escrow_gns_init (void *cls)
   api->verify_key_escrow = &verify_gns_key_escrow;
   api->restore_key = &restore_gns_key_escrow;
   api->anchor_string_to_data = &gns_anchor_string_to_data;
+  api->cancel_plugin_operation = &cancel_gns_operation;
 
   ph.id_init_cont = &gns_cont_init;
 
diff --git a/src/escrow/plugin_escrow_plaintext.c b/src/escrow/plugin_escrow_plaintext.c
index 63ffe7720..b260f6190 100644
--- a/src/escrow/plugin_escrow_plaintext.c
+++ b/src/escrow/plugin_escrow_plaintext.c
@@ -30,9 +30,44 @@
 #include "escrow_plugin_helper.h"
 #include "gnunet_identity_service.h"
 #include "../identity/identity.h"
+#include "escrow.h"
 #include <inttypes.h>
 
 
+struct ESCROW_PlaintextPluginOperation
+{
+  /**
+   * Handle for the escrow component
+   */
+  struct GNUNET_ESCROW_Handle *h;
+
+  /**
+   * Continuation for a plugin operation (e.g. used for restore, as this
+   * callback has to be called from the IDENTITY service after finishing)
+   */
+  GNUNET_SCHEDULER_TaskCallback cont;
+
+  /**
+   * Scheduler task the SCHEDULE operation returns (needed for cancellation)
+   */
+  struct GNUNET_SCHEDULER_Task *sched_task;
+
+  /**
+   * Identity operation
+   */
+  struct GNUNET_IDENTITY_Operation *id_op;
+
+  /**
+   * Private key of the created ego
+   */
+  const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk;
+
+  /**
+   * Ego continuation wrapper
+   */
+  struct GNUNET_ESCROW_Plugin_EgoContinuationWrapper *ego_cont_wrap;
+};
+
 /**
  * Identity handle
  */
@@ -41,7 +76,7 @@ static struct GNUNET_IDENTITY_Handle *identity_handle;
 /**
  * Handle for the plugin instance
  */
-struct EscrowPluginHandle ph;
+struct ESCROW_PluginHandle ph;
 
 
 /**
@@ -50,21 +85,40 @@ struct EscrowPluginHandle ph;
  * @param h the handle for the escrow component
  * @param ego the identity ego containing the private key
  * @param cb the function called upon completion
+ * 
+ * @return plugin operation wrapper
  */
-void
+struct ESCROW_PluginOperationWrapper *
 start_plaintext_key_escrow (struct GNUNET_ESCROW_Handle *h,
                             const struct GNUNET_IDENTITY_Ego *ego,
-                            GNUNET_ESCROW_AnchorContinuation cb)
+                            GNUNET_SCHEDULER_TaskCallback cb)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk;
   struct GNUNET_ESCROW_Anchor *anchor;
   char *pkString;
   uint32_t anchorDataSize;
+  struct ESCROW_PluginOperationWrapper *plugin_op_wrap;
+  struct ESCROW_PlaintextPluginOperation *p_op;
+  struct GNUNET_ESCROW_Plugin_AnchorContinuationWrapper *w;
+
+  // create a new plaintext plugin operation (in a wrapper) and insert it into the DLL
+  plugin_op_wrap = GNUNET_new (struct ESCROW_PluginOperationWrapper);
+  plugin_op_wrap->plugin_op = GNUNET_new (struct ESCROW_PlaintextPluginOperation);
+  GNUNET_CONTAINER_DLL_insert_tail (ph.plugin_op_head,
+                                    ph.plugin_op_tail,
+                                    plugin_op_wrap);
+
+  p_op = (struct ESCROW_PlaintextPluginOperation *)plugin_op_wrap->plugin_op;
+  p_op->h = h;
+
+  w = GNUNET_new (struct GNUNET_ESCROW_Plugin_AnchorContinuationWrapper);
+  w->h = h;
 
   if (NULL == ego)
   {
-    cb (h, NULL);
-    return;
+    w->escrowAnchor = NULL;
+    p_op->sched_task = GNUNET_SCHEDULER_add_now (cb, w);
+    return plugin_op_wrap;
   }
   pk = GNUNET_IDENTITY_ego_get_private_key (ego);
   pkString = GNUNET_CRYPTO_ecdsa_private_key_to_string (pk);
@@ -75,7 +129,10 @@ start_plaintext_key_escrow (struct GNUNET_ESCROW_Handle *h,
   anchor->size = anchorDataSize;
   GNUNET_memcpy (&anchor[1], pkString, anchorDataSize);
 
-  cb (h, anchor);
+  w->escrowAnchor = anchor;
+
+  p_op->sched_task = GNUNET_SCHEDULER_add_now (cb, w);
+  return plugin_op_wrap;
 }
 
 
@@ -89,7 +146,7 @@ void
 renew_plaintext_key_escrow (struct GNUNET_ESCROW_Operation *op,
                             struct GNUNET_ESCROW_Anchor *escrowAnchor)
 {
-  op->cb_renew (op->cb_cls, escrowAnchor);
+  op->cb_renew (escrowAnchor);
 }
 
 
@@ -100,21 +157,40 @@ renew_plaintext_key_escrow (struct GNUNET_ESCROW_Operation *op,
  * @param ego the identity ego containing the private key
  * @param escrowAnchor the escrow anchor needed to restore the key
  * @param cb the function called upon completion
+ * 
+ * @return plugin operation wrapper
  */
-void
+struct ESCROW_PluginOperationWrapper *
 verify_plaintext_key_escrow (struct GNUNET_ESCROW_Handle *h,
                              const struct GNUNET_IDENTITY_Ego *ego,
                              struct GNUNET_ESCROW_Anchor *escrowAnchor,
-                             GNUNET_ESCROW_VerifyContinuation cb)
+                             GNUNET_SCHEDULER_TaskCallback cb)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk;
   char *pkString;
   int verificationResult;
+  struct ESCROW_PluginOperationWrapper *plugin_op_wrap;
+  struct ESCROW_PlaintextPluginOperation *p_op;
+  struct GNUNET_ESCROW_Plugin_VerifyContinuationWrapper *w;
+  
+  // create a new plaintext plugin operation (in a wrapper) and insert it into the DLL
+  plugin_op_wrap = GNUNET_new (struct ESCROW_PluginOperationWrapper);
+  plugin_op_wrap->plugin_op = GNUNET_new (struct ESCROW_PlaintextPluginOperation);
+  GNUNET_CONTAINER_DLL_insert_tail (ph.plugin_op_head,
+                                    ph.plugin_op_tail,
+                                    plugin_op_wrap);
+
+  p_op = (struct ESCROW_PlaintextPluginOperation *)plugin_op_wrap->plugin_op;
+  p_op->h = h;
+
+  w = GNUNET_new (struct GNUNET_ESCROW_Plugin_VerifyContinuationWrapper);
+  w->h = h;
 
   if (NULL == ego)
   {
-    cb (h, GNUNET_ESCROW_INVALID);
-    return;
+    w->verificationResult = GNUNET_ESCROW_INVALID;
+    p_op->sched_task = GNUNET_SCHEDULER_add_now (cb, w);
+    return plugin_op_wrap;
   }
   pk = GNUNET_IDENTITY_ego_get_private_key (ego);
   pkString = GNUNET_CRYPTO_ecdsa_private_key_to_string (pk);
@@ -122,16 +198,45 @@ verify_plaintext_key_escrow (struct GNUNET_ESCROW_Handle *h,
                                 (char *)&escrowAnchor[1],
                                 strlen (pkString)) == 0 ?
     GNUNET_ESCROW_VALID : GNUNET_ESCROW_INVALID;
-  cb (h, verificationResult);
+
+  w->verificationResult = verificationResult;
+  p_op->sched_task = GNUNET_SCHEDULER_add_now (cb, w);
+  return plugin_op_wrap;
 }
 
 
 void
 ego_created (const struct GNUNET_IDENTITY_Ego *ego)
 {
-  ph.ego_create_cont = NULL;
-  ph.curr_restore_cb (ph.escrow_handle, ego);
-  ph.curr_restore_cb = NULL;
+  struct ESCROW_PluginOperationWrapper *curr;
+  struct ESCROW_PlaintextPluginOperation *curr_p_op;
+  char *ego_pk_string, *curr_pk_string;
+
+  ego_pk_string = GNUNET_CRYPTO_ecdsa_private_key_to_string (&ego->pk);
+
+  for (curr = ph.plugin_op_head; NULL != curr; curr = curr->next)
+  {
+    curr_p_op = (struct ESCROW_PlaintextPluginOperation *)curr->plugin_op;
+    curr_pk_string = GNUNET_CRYPTO_ecdsa_private_key_to_string (curr_p_op->pk);
+    // compare the strings of the private keys
+    if (0 == strcmp (ego_pk_string, curr_pk_string))
+    {
+      // the ego was created due to a restore operation that is not yet finished
+      GNUNET_free (curr_pk_string);
+      GNUNET_CONTAINER_DLL_remove (ph.plugin_op_head,
+                                   ph.plugin_op_tail,
+                                   curr);
+      curr_p_op->ego_cont_wrap->ego = ego;
+      curr_p_op->sched_task = GNUNET_SCHEDULER_add_now (curr_p_op->cont,
+                                                        curr_p_op->ego_cont_wrap);
+      GNUNET_free (curr_p_op);
+      GNUNET_free (curr);
+      GNUNET_free (ego_pk_string);
+      return;
+    }
+    GNUNET_free (curr_pk_string);
+  }
+  GNUNET_free (ego_pk_string);
 }
 
 
@@ -150,7 +255,7 @@ create_finished (void *cls,
                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk,
                  const char *emsg)
 {
-  GNUNET_ESCROW_EgoContinuation cb = cls;
+  struct ESCROW_PlaintextPluginOperation *p_op = cls;
 
   if (NULL == pk)
   {
@@ -160,14 +265,14 @@ create_finished (void *cls,
                emsg);
     else
       fprintf (stderr, "Failed to create ego!");
-    cb (ph.escrow_handle, NULL);
+    p_op->ego_cont_wrap->ego = NULL;
+    p_op->sched_task = GNUNET_SCHEDULER_add_now (p_op->cont, p_op->ego_cont_wrap);
     return;
   }
 
-  /* no error occurred, op->cb_get will be called from ESCROW_list_ego after 
-     adding the new ego to our list */
-  ph.ego_create_cont = &ego_created;
-  ph.curr_restore_cb = cb;
+  /* no error occurred, p_op->restore_cont will be called in ego_created, which
+     is called from ESCROW_list_ego after adding the new ego to our list */
+  p_op->pk = pk;
 }
 
 
@@ -178,40 +283,64 @@ create_finished (void *cls,
  * @param escrowAnchor the escrow anchor needed to restore the key
  * @param egoName the name of the ego to restore
  * @param cb the function called upon completion
+ * 
+ * @return plugin operation wrapper
  */
-void
+struct ESCROW_PluginOperationWrapper *
 restore_plaintext_key_escrow (struct GNUNET_ESCROW_Handle *h,
                               struct GNUNET_ESCROW_Anchor *escrowAnchor,
                               char *egoName,
-                              GNUNET_ESCROW_EgoContinuation cb)
+                              GNUNET_SCHEDULER_TaskCallback cb)
 {
   struct GNUNET_CRYPTO_EcdsaPrivateKey pk;
   struct GNUNET_IDENTITY_Operation *id_op;
+  struct ESCROW_PluginOperationWrapper *plugin_op_wrap;
+  struct ESCROW_PlaintextPluginOperation *p_op;
+  struct GNUNET_ESCROW_Plugin_EgoContinuationWrapper *w;
+
+  // create a new plaintext plugin operation (in a wrapper) and insert it into the DLL
+  plugin_op_wrap = GNUNET_new (struct ESCROW_PluginOperationWrapper);
+  plugin_op_wrap->plugin_op = GNUNET_new (struct ESCROW_PlaintextPluginOperation);
+  GNUNET_CONTAINER_DLL_insert_tail (ph.plugin_op_head,
+                                    ph.plugin_op_tail,
+                                    plugin_op_wrap);
+
+  p_op = (struct ESCROW_PlaintextPluginOperation *)plugin_op_wrap->plugin_op;
+  p_op->h = h;
+  // set cont here (has to be scheduled from the IDENTITY service when it finished)
+  p_op->cont = cb;
+
+  w = GNUNET_new (struct GNUNET_ESCROW_Plugin_EgoContinuationWrapper);
+  w->h = h;
 
-  // TODO: is this the right place for that?
-  ph.escrow_handle = h;
+  p_op->ego_cont_wrap = w;
 
   if (NULL == escrowAnchor)
   {
-    cb (h, NULL);
-    return;
+    // TODO: correct error handling?
+    w->ego = NULL;
+    p_op->sched_task = GNUNET_SCHEDULER_add_now (cb, w);
+    return plugin_op_wrap;
   }
   if (GNUNET_OK !=
     GNUNET_CRYPTO_ecdsa_private_key_from_string ((char *)&escrowAnchor[1],
                                                  strlen ((char *)&escrowAnchor[1]),
                                                  &pk))
   {
-    cb (h, NULL);
-    return;
+    w->ego = NULL;
+    p_op->sched_task = GNUNET_SCHEDULER_add_now (cb, w);
+    return plugin_op_wrap;
   }
   
   id_op = GNUNET_IDENTITY_create (identity_handle,
                                   egoName,
                                   &pk,
                                   &create_finished,
-                                  cb);
+                                  p_op);
 
-  // TODO: return id_op?
+  p_op->id_op = id_op;
+  
+  return plugin_op_wrap;
 }
 
 
@@ -263,12 +392,32 @@ plaintext_anchor_data_to_string (struct GNUNET_ESCROW_Handle *h,
 
 
 /**
- * Cancel ... TODO
+ * Cancel a plaintext plugin operation.
+ * 
+ * @param plugin_op_wrap the plugin operation wrapper containing the operation
  */
 void
-cancel_plaintext_ ()
+cancel_plaintext_operation (struct ESCROW_PluginOperationWrapper *plugin_op_wrap)
 {
-  return;
+  struct ESCROW_PluginOperationWrapper *curr;
+  struct ESCROW_PlaintextPluginOperation *plugin_op;
+
+  for (curr = ph.plugin_op_head; NULL != curr; curr = curr->next)
+  {
+    if (curr == plugin_op_wrap)
+    {
+      GNUNET_CONTAINER_DLL_remove (ph.plugin_op_head,
+                                   ph.plugin_op_tail,
+                                   curr);
+      plugin_op = (struct ESCROW_PlaintextPluginOperation *)curr->plugin_op;
+      GNUNET_IDENTITY_cancel (plugin_op->id_op);
+      if (NULL != plugin_op->sched_task)
+        GNUNET_SCHEDULER_cancel (plugin_op->sched_task);
+      GNUNET_free (plugin_op);
+      GNUNET_free (curr);
+      return;
+    }
+  }
 }
 
 
@@ -302,9 +451,12 @@ libgnunet_plugin_escrow_plaintext_init (void *cls)
   api->restore_key = &restore_plaintext_key_escrow;
   api->anchor_string_to_data = &plaintext_anchor_string_to_data;
   api->anchor_data_to_string = &plaintext_anchor_data_to_string;
+  api->cancel_plugin_operation = &cancel_plaintext_operation;
 
   ph.id_init_cont = &plaintext_cont_init;
 
+  // set ego_create_cont here so it is called every time an ego is created
+  ph.ego_create_cont = &ego_created;
   identity_handle = GNUNET_IDENTITY_connect (cfg,
                                              &ESCROW_list_ego,
                                              &ph);
diff --git a/src/include/gnunet_escrow_lib.h b/src/include/gnunet_escrow_lib.h
index 388f5a3e1..aea081319 100644
--- a/src/include/gnunet_escrow_lib.h
+++ b/src/include/gnunet_escrow_lib.h
@@ -97,7 +97,6 @@ typedef void (*GNUNET_ESCROW_EgoCreateContinuation) (
  * @param escrowAnchor the escrow anchor needed to get the data back
  */
 typedef void (*GNUNET_ESCROW_AnchorContinuation) (
-  void *cls,
   struct GNUNET_ESCROW_Anchor *escrowAnchor);
 
 /**
@@ -107,7 +106,6 @@ typedef void (*GNUNET_ESCROW_AnchorContinuation) (
  * @param ego a new identity ego restored from the escrow
  */
 typedef void (*GNUNET_ESCROW_EgoContinuation) (
-  void *cls,
   const struct GNUNET_IDENTITY_Ego *ego);
 
 /**
@@ -120,7 +118,6 @@ typedef void (*GNUNET_ESCROW_EgoContinuation) (
  *   GNUNET_ESCROW_INVALID otherwise
  */
 typedef void (*GNUNET_ESCROW_VerifyContinuation) (
-  void *cls,
   int verificationResult);
 
 
@@ -167,6 +164,31 @@ struct GNUNET_ESCROW_Operation
   struct GNUNET_ESCROW_Operation *prev;
 
   /**
+   * The used escrow method.
+   */
+  enum GNUNET_ESCROW_Key_Escrow_Method method;
+
+  /**
+   * The respective plugin operation
+   */
+  struct ESCROW_PluginOperationWrapper *plugin_op_wrap;
+
+  /**
+   * The escrow anchor.
+   */
+  struct GNUNET_ESCROW_Anchor *escrow_anchor;
+
+  /**
+   * The ego.
+   */
+  struct GNUNET_IDENTITY_Ego *ego;
+
+  /**
+   * The verification result.
+   */
+  enum GNUNET_ESCROW_Verification_Result verification_result;
+
+  /**
    * Continuation for a PUT operation.
    */
   GNUNET_ESCROW_AnchorContinuation cb_put;
@@ -336,11 +358,9 @@ GNUNET_ESCROW_anchor_data_to_string (struct GNUNET_ESCROW_Handle *h,
  * be executed; this merely cancels the continuation.
  *
  * @param op operation to cancel
- * @param method the escrow method to use
  */
 void
-GNUNET_ESCROW_cancel (struct GNUNET_ESCROW_Operation *op,
-                      enum GNUNET_ESCROW_Key_Escrow_Method method);
+GNUNET_ESCROW_cancel (struct GNUNET_ESCROW_Operation *op);
 
 
 #if 0 /* keep Emacsens' auto-indent happy */
diff --git a/src/include/gnunet_escrow_plugin.h b/src/include/gnunet_escrow_plugin.h
index d3bb33745..b0a5f5652 100644
--- a/src/include/gnunet_escrow_plugin.h
+++ b/src/include/gnunet_escrow_plugin.h
@@ -33,6 +33,8 @@
 #include "gnunet_util_lib.h"
 #include "gnunet_escrow_lib.h"
 #include "gnunet_identity_service.h"
+#include "../escrow/escrow.h"
+#include "gnunet_scheduler_lib.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -41,88 +43,41 @@ extern "C" {
 #endif
 #endif
 
-/**
- * State while collecting all egos
- */
-#define ESCROW_PLUGIN_STATE_INIT 0
 
 /**
- * Done collecting egos
+ * Wrapper for the Plugin_AnchorContinuation.
+ * 
+ * As this type of function is called from the scheduler, which only takes
+ * one argument as closure, this struct is used to pass more arguments.
  */
-#define ESCROW_PLUGIN_STATE_POST_INIT 1
-
+struct GNUNET_ESCROW_Plugin_AnchorContinuationWrapper
+{
+  struct GNUNET_ESCROW_Handle *h;
+  struct GNUNET_ESCROW_Anchor *escrowAnchor;
+};
 
 /**
- * The ego list
+ * Wrapper for the Plugin_EgoContinuation.
+ * 
+ * As this type of function is called from the scheduler, which only takes
+ * one argument as closure, this struct is used to pass more arguments.
  */
-struct EgoEntry
+struct GNUNET_ESCROW_Plugin_EgoContinuationWrapper
 {
-  /**
-   * DLL
-   */
-  struct EgoEntry *next;
-
-  /**
-   * DLL
-   */
-  struct EgoEntry *prev;
-
-  /**
-   * Ego Identifier
-   */
-  char *identifier;
-
-  /**
-   * Public key string
-   */
-  char *keystring;
-
-  /**
-   * The Ego
-   */
-  struct GNUNET_IDENTITY_Ego *ego;
+  struct GNUNET_ESCROW_Handle *h;
+  const struct GNUNET_IDENTITY_Ego *ego;
 };
 
-
 /**
- * Handle for a plugin instance
+ * Wrapper for the Plugin_VerifyContinuation.
+ * 
+ * As this type of function is called from the scheduler, which only takes
+ * one argument as closure, this struct is used to pass more arguments.
  */
-struct EscrowPluginHandle
+struct GNUNET_ESCROW_Plugin_VerifyContinuationWrapper
 {
-  /**
-   * The identity init continuation.
-   */
-  GNUNET_ESCROW_IdentityInitContinuation id_init_cont;
-
-  /**
-   * The ego create continuation.
-   */
-  GNUNET_ESCROW_EgoCreateContinuation ego_create_cont;
-
-  /**
-   * The current restore callback.
-   */
-  GNUNET_ESCROW_EgoContinuation curr_restore_cb;
-
-  /**
-   * The handle to the escrow component.
-   */
-  struct GNUNET_ESCROW_Handle *escrow_handle;
-
-  /**
-   * The state of the plugin (in the initialization phase).
-   */
-  int state;
-
-  /**
-   * The head of the ego list.
-   */
-  struct EgoEntry *ego_head;
-
-  /**
-   * The tail of the ego list
-   */
-  struct EgoEntry *ego_tail;
+  struct GNUNET_ESCROW_Handle *h;
+  int verificationResult;
 };
 
 
@@ -133,10 +88,10 @@ struct EscrowPluginHandle
  * @param ego the identity ego containing the private key
  * @param cb the function called upon completion
  */
-typedef void (*GNUNET_ESCROW_StartKeyEscrowFunction) (
+typedef struct ESCROW_PluginOperationWrapper *(*GNUNET_ESCROW_StartKeyEscrowFunction) (
   struct GNUNET_ESCROW_Handle *h,
   const struct GNUNET_IDENTITY_Ego *ego,
-  GNUNET_ESCROW_AnchorContinuation cb);
+  GNUNET_SCHEDULER_TaskCallback cb);
 
 /**
  * Function called to renew the escrow of the key
@@ -156,11 +111,11 @@ typedef void (*GNUNET_ESCROW_RenewKeyEscrowFunction) (
  * @param escrowAnchor the escrow anchor needed to restore the key
  * @param cb the function called upon completion
  */
-typedef void (*GNUNET_ESCROW_VerifyKeyEscrowFunction) (
+typedef struct ESCROW_PluginOperationWrapper *(*GNUNET_ESCROW_VerifyKeyEscrowFunction) (
   struct GNUNET_ESCROW_Handle *h,
   const struct GNUNET_IDENTITY_Ego *ego,
   struct GNUNET_ESCROW_Anchor *escrowAnchor,
-  GNUNET_ESCROW_VerifyContinuation cb);
+  GNUNET_SCHEDULER_TaskCallback cb);
 
 /**
  * Function called to restore a key from an escrow
@@ -170,11 +125,11 @@ typedef void (*GNUNET_ESCROW_VerifyKeyEscrowFunction) (
  * @param egoName the name of the ego to restore
  * @param cb the function called upon completion
  */
-typedef void (*GNUNET_ESCROW_RestoreKeyFunction) (
+typedef struct ESCROW_PluginOperationWrapper *(*GNUNET_ESCROW_RestoreKeyFunction) (
   struct GNUNET_ESCROW_Handle *h,
   struct GNUNET_ESCROW_Anchor *escrowAnchor,
   char *egoName,
-  GNUNET_ESCROW_EgoContinuation cb);
+  GNUNET_SCHEDULER_TaskCallback cb);
 
 
 /**
@@ -205,6 +160,15 @@ typedef char *(*GNUNET_ESCROW_AnchorDataToStringFunction) (
 
 
 /**
+ * Function called to cancel a plugin operation
+ * 
+ * @param plugin_op_wrap plugin operation wrapper containing the plugin operation
+ */
+typedef void (*GNUNET_ESCROW_CancelPluginOperationFunction) (
+  struct ESCROW_PluginOperationWrapper *plugin_op_wrap);
+
+
+/**
  * Each plugin is required to return a pointer to a struct of this
  * type as the return value from its entry point.
  */
@@ -244,6 +208,11 @@ struct GNUNET_ESCROW_KeyPluginFunctions
    * Serialize anchor data to string
    */
   GNUNET_ESCROW_AnchorDataToStringFunction anchor_data_to_string;
+
+  /**
+   * Cancel plugin operation
+   */
+  GNUNET_ESCROW_CancelPluginOperationFunction cancel_plugin_operation;
 };