psyc, psycstore: retrieve state and history

6 files changed, 657 insertions, 260 deletions

diff --git a/src/psycstore/gnunet-service-psycstore.c b/src/psycstore/gnunet-service-psycstore.c
index 7d27ea29b..87a2c87ab 100644
--- a/src/psycstore/gnunet-service-psycstore.c
+++ b/src/psycstore/gnunet-service-psycstore.c
@@ -25,6 +25,8 @@
  * @author Christian Grothoff
  */
 
+#include <inttypes.h>
+
 #include "platform.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_constants.h"
@@ -89,39 +91,41 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 /**
  * Send a result code back to the client.
  *
- * @param client Client that should receive the result code.
- * @param result_code Code to transmit.
- * @param op_id Operation ID.
- * @param err_msg Error message to include (or NULL for none).
+ * @param client
+ *        Client that should receive the result code.
+ * @param result_code
+ *        Code to transmit.
+ * @param op_id
+ *        Operation ID in network byte order.
+ * @param err_msg
+ *        Error message to include (or NULL for none).
  */
 static void
-send_result_code (struct GNUNET_SERVER_Client *client, uint32_t result_code,
-                  uint32_t op_id, const char *err_msg)
+send_result_code (struct GNUNET_SERVER_Client *client, uint64_t op_id,
+                  int64_t result_code, const char *err_msg)
 {
   struct OperationResult *res;
-  size_t err_len;
+  size_t err_len = 0; // FIXME: maximum length
 
-  if (NULL == err_msg)
-    err_len = 0;
-  else
+  if (NULL != err_msg)
     err_len = strlen (err_msg) + 1;
   res = GNUNET_malloc (sizeof (struct OperationResult) + err_len);
   res->header.type = htons (GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_CODE);
   res->header.size = htons (sizeof (struct OperationResult) + err_len);
-  res->result_code = htonl (result_code);
+  res->result_code = GNUNET_htonll (result_code - INT64_MIN);
   res->op_id = op_id;
   if (0 < err_len)
     memcpy (&res[1], err_msg, err_len);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending result %d (%s) to client\n",
-              (int) result_code,
-              err_msg);
+              "Sending result to client: %" PRId64 " (%s)\n",
+              result_code, err_msg);
   GNUNET_SERVER_notification_context_add (nc, client);
   GNUNET_SERVER_notification_context_unicast (nc, client, &res->header,
                                               GNUNET_NO);
   GNUNET_free (res);
 }
 
+
 enum
 {
   MEMBERSHIP_TEST_NOT_NEEDED = 0,
@@ -129,6 +133,7 @@ enum
   MEMBERSHIP_TEST_DONE = 2,
 } MessageMembershipTest;
 
+
 struct SendClosure
 {
   struct GNUNET_SERVER_Client *client;
@@ -158,7 +163,6 @@ struct SendClosure
    * @see enum MessageMembershipTest
    */
   uint8_t membership_test;
-
 };
 
 
@@ -214,6 +218,8 @@ send_state_var (void *cls, const char *name,
   struct StateResult *res;
   size_t name_size = strlen (name) + 1;
 
+  /* FIXME: split up value into 64k chunks */
+
   res = GNUNET_malloc (sizeof (struct StateResult) + name_size + value_size);
   res->header.type = htons (GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_STATE);
   res->header.size = htons (sizeof (struct StateResult) + name_size + value_size);
@@ -249,7 +255,7 @@ handle_membership_store (void *cls,
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _("Failed to store membership information!\n"));
 
-  send_result_code (client, ret, req->op_id, NULL);
+  send_result_code (client, req->op_id, ret, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -274,7 +280,7 @@ handle_membership_test (void *cls,
                 _("Failed to test membership!\n"));
   }
 
-  send_result_code (client, ret, req->op_id, NULL);
+  send_result_code (client, req->op_id, ret, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -295,7 +301,7 @@ handle_fragment_store (void *cls,
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _("Failed to store fragment!\n"));
 
-  send_result_code (client, ret, req->op_id, NULL);
+  send_result_code (client, req->op_id, ret, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -312,9 +318,20 @@ handle_fragment_get (void *cls,
            .channel_key = req->channel_key, .slave_key = req->slave_key,
            .membership_test = req->do_membership_test };
 
-  int ret = db->fragment_get (db->cls, &req->channel_key,
-                              GNUNET_ntohll (req->fragment_id),
-                              &send_fragment, &sc);
+  int64_t ret;
+  uint64_t ret_frags = 0;
+  uint64_t first_fragment_id = GNUNET_ntohll (req->first_fragment_id);
+  uint64_t last_fragment_id = GNUNET_ntohll (req->last_fragment_id);
+  uint64_t limit = GNUNET_ntohll (req->fragment_limit);
+
+  if (0 == limit)
+    ret = db->fragment_get (db->cls, &req->channel_key,
+                            first_fragment_id, last_fragment_id,
+                            &ret_frags, &send_fragment, &sc);
+  else
+    ret = db->fragment_get_latest (db->cls, &req->channel_key, limit, 
+                                   &ret_frags, &send_fragment, &sc);
+
   switch (ret)
   {
   case GNUNET_YES:
@@ -340,8 +357,7 @@ handle_fragment_get (void *cls,
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _("Failed to get fragment!\n"));
   }
-
-  send_result_code (client, ret, req->op_id, NULL);
+  send_result_code (client, req->op_id, (ret < 0) ? ret : ret_frags, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -358,22 +374,31 @@ handle_message_get (void *cls,
            .channel_key = req->channel_key, .slave_key = req->slave_key,
            .membership_test = req->do_membership_test };
 
+  int64_t ret;
   uint64_t ret_frags = 0;
-  int64_t ret = db->message_get (db->cls, &req->channel_key,
-                                 GNUNET_ntohll (req->message_id),
-                                 &ret_frags, &send_fragment, &sc);
+  uint64_t first_message_id = GNUNET_ntohll (req->first_message_id);
+  uint64_t last_message_id = GNUNET_ntohll (req->last_message_id);
+  uint64_t limit = GNUNET_ntohll (req->message_limit);
+
+  if (0 == limit)
+    ret = db->message_get (db->cls, &req->channel_key,
+                           first_message_id, last_message_id,
+                           &ret_frags, &send_fragment, &sc);
+  else
+    ret = db->message_get_latest (db->cls, &req->channel_key, limit,
+                                  &ret_frags, &send_fragment, &sc);
+
   switch (ret)
   {
   case GNUNET_YES:
   case GNUNET_NO:
     break;
   default:
-    ret_frags = ret;
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _("Failed to get message!\n"));
   }
 
-  send_result_code (client, ret_frags, req->op_id, NULL);
+  send_result_code (client, req->op_id, (ret < 0) ? ret : ret_frags, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -404,7 +429,7 @@ handle_message_get_fragment (void *cls,
                 _("Failed to get message fragment!\n"));
   }
 
-  send_result_code (client, ret, req->op_id, NULL);
+  send_result_code (client, req->op_id, ret, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -434,7 +459,7 @@ handle_counters_get (void *cls,
 
   res.header.type = htons (GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_COUNTERS);
   res.header.size = htons (sizeof (res));
-  res.result_code = htonl (ret);
+  res.result_code = htonl (ret - INT32_MIN);
   res.op_id = req->op_id;
   res.max_fragment_id = GNUNET_htonll (res.max_fragment_id);
   res.max_message_id = GNUNET_htonll (res.max_message_id);
@@ -517,7 +542,7 @@ handle_state_modify (void *cls,
                     _("Failed to end modifying state!\n"));
     }
   }
-  send_result_code (client, ret, req->op_id, NULL);
+  send_result_code (client, req->op_id, ret, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -571,7 +596,7 @@ handle_state_sync (void *cls,
                     _("Failed to end synchronizing state!\n"));
     }
   }
-  send_result_code (client, ret, req->op_id, NULL);
+  send_result_code (client, req->op_id, ret, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -590,7 +615,7 @@ handle_state_reset (void *cls,
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _("Failed to reset state!\n"));
 
-  send_result_code (client, ret, req->op_id, NULL);
+  send_result_code (client, req->op_id, ret, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -609,7 +634,7 @@ handle_state_hash_update (void *cls,
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _("Failed to reset state!\n"));
 
-  send_result_code (client, ret, req->op_id, NULL);
+  send_result_code (client, req->op_id, ret, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -660,7 +685,7 @@ handle_state_get (void *cls,
                 _("Failed to get state variable!\n"));
   }
 
-  send_result_code (client, ret, req->op_id, NULL);
+  send_result_code (client, req->op_id, ret, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -699,7 +724,7 @@ handle_state_get_prefix (void *cls,
                 _("Failed to get state variable!\n"));
   }
 
-  send_result_code (client, ret, req->op_id, NULL);
+  send_result_code (client, req->op_id, ret, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
diff --git a/src/psycstore/plugin_psycstore_sqlite.c b/src/psycstore/plugin_psycstore_sqlite.c
index 86b969c5d..cb6c5c437 100644
--- a/src/psycstore/plugin_psycstore_sqlite.c
+++ b/src/psycstore/plugin_psycstore_sqlite.c
@@ -130,12 +130,22 @@ struct Plugin
   /**
    * Precompiled SQL for fragment_get()
    */
-  sqlite3_stmt *select_fragment;
+  sqlite3_stmt *select_fragments;
+
+  /**
+   * Precompiled SQL for fragment_get()
+   */
+  sqlite3_stmt *select_latest_fragments;
 
   /**
    * Precompiled SQL for message_get()
    */
-  sqlite3_stmt *select_message;
+  sqlite3_stmt *select_messages;
+
+  /**
+   * Precompiled SQL for message_get()
+   */
+  sqlite3_stmt *select_latest_messages;
 
   /**
    * Precompiled SQL for message_get_fragment()
@@ -456,8 +466,8 @@ database_setup (struct Plugin *plugin)
                "       multicast_flags, psycstore_flags, data\n"
                "FROM messages\n"
                "WHERE channel_id = (SELECT id FROM channels WHERE pub_key = ?)\n"
-               "      AND fragment_id = ?;",
-               &plugin->select_fragment);
+               "      AND ? <= fragment_id AND fragment_id <= ?;",
+               &plugin->select_fragments);
 
   sql_prepare (plugin->dbh,
                "SELECT hop_counter, signature, purpose, fragment_id,\n"
@@ -465,8 +475,35 @@ database_setup (struct Plugin *plugin)
                "       multicast_flags, psycstore_flags, data\n"
                "FROM messages\n"
                "WHERE channel_id = (SELECT id FROM channels WHERE pub_key = ?)\n"
-               "      AND message_id = ? AND fragment_offset = ?;",
-               &plugin->select_message_fragment);
+               "      AND ? <= message_id AND message_id <= ?;",
+               &plugin->select_messages);
+
+  sql_prepare (plugin->dbh,
+               "SELECT * FROM\n"
+               "(SELECT hop_counter, signature, purpose, fragment_id,\n"
+               "        fragment_offset, message_id, group_generation,\n"
+               "        multicast_flags, psycstore_flags, data\n"
+               " FROM messages\n"
+               " WHERE channel_id = (SELECT id FROM channels WHERE pub_key = ?)\n"
+               " ORDER BY fragment_id DESC\n"
+               " LIMIT ?)\n"
+               "ORDER BY fragment_id;",
+               &plugin->select_latest_fragments);
+
+  sql_prepare (plugin->dbh,
+               "SELECT hop_counter, signature, purpose, fragment_id,\n"
+               "       fragment_offset, message_id, group_generation,\n"
+               "        multicast_flags, psycstore_flags, data\n"
+               "FROM messages\n"
+               "WHERE channel_id = (SELECT id FROM channels WHERE pub_key = ?)\n"
+               "      AND message_id IN\n"
+               "      (SELECT message_id\n"
+               "       FROM messages\n"
+               "       WHERE channel_id = (SELECT id FROM channels WHERE pub_key = ?)\n"
+               "       ORDER BY message_id\n"
+               "       DESC LIMIT ?)\n"
+               "ORDER BY fragment_id;",
+               &plugin->select_latest_messages);
 
   sql_prepare (plugin->dbh,
                "SELECT hop_counter, signature, purpose, fragment_id,\n"
@@ -474,8 +511,8 @@ database_setup (struct Plugin *plugin)
                "       multicast_flags, psycstore_flags, data\n"
                "FROM messages\n"
                "WHERE channel_id = (SELECT id FROM channels WHERE pub_key = ?)\n"
-               "      AND message_id = ?;",
-               &plugin->select_message);
+               "      AND message_id = ? AND fragment_offset = ?;",
+               &plugin->select_message_fragment);
 
   sql_prepare (plugin->dbh,
                "SELECT fragment_id, message_id, group_generation\n"
@@ -1036,8 +1073,42 @@ fragment_row (sqlite3_stmt *stmt, GNUNET_PSYCSTORE_FragmentCallback cb,
   return cb (cb_cls, (void *) msg, sqlite3_column_int64 (stmt, 8));
 }
 
+
+static int
+fragment_select (struct Plugin *plugin, sqlite3_stmt *stmt,
+                 uint64_t *returned_fragments,
+                 GNUNET_PSYCSTORE_FragmentCallback cb, void *cb_cls)
+{
+  int ret = GNUNET_SYSERR;
+  int sql_ret;
+
+  do
+  {
+    sql_ret = sqlite3_step (stmt);
+    switch (sql_ret)
+    {
+    case SQLITE_DONE:
+      if (ret != GNUNET_OK)
+        ret = GNUNET_NO;
+      break;
+    case SQLITE_ROW:
+      ret = fragment_row (stmt, cb, cb_cls);
+      (*returned_fragments)++;
+      if (ret != GNUNET_YES)
+        sql_ret = SQLITE_DONE;
+      break;
+    default:
+      LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "sqlite3_step");
+    }
+  }
+  while (sql_ret == SQLITE_ROW);
+
+  return ret;
+}
+
 /**
- * Retrieve a message fragment by fragment ID.
+ * Retrieve a message fragment range by fragment ID.
  *
  * @see GNUNET_PSYCSTORE_fragment_get()
  *
@@ -1046,36 +1117,29 @@ fragment_row (sqlite3_stmt *stmt, GNUNET_PSYCSTORE_FragmentCallback cb,
 static int
 fragment_get (void *cls,
               const struct GNUNET_CRYPTO_EddsaPublicKey *channel_key,
-              uint64_t fragment_id,
+              uint64_t first_fragment_id,
+              uint64_t last_fragment_id,
+              uint64_t *returned_fragments,
               GNUNET_PSYCSTORE_FragmentCallback cb,
               void *cb_cls)
 {
   struct Plugin *plugin = cls;
-  sqlite3_stmt *stmt = plugin->select_fragment;
+  sqlite3_stmt *stmt = plugin->select_fragments;
   int ret = GNUNET_SYSERR;
+  *returned_fragments = 0;
 
   if (SQLITE_OK != sqlite3_bind_blob (stmt, 1, channel_key,
                                       sizeof (*channel_key),
                                       SQLITE_STATIC)
-      || SQLITE_OK != sqlite3_bind_int64 (stmt, 2, fragment_id))
+      || SQLITE_OK != sqlite3_bind_int64 (stmt, 2, first_fragment_id)
+      || SQLITE_OK != sqlite3_bind_int64 (stmt, 3, last_fragment_id))
   {
     LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_bind");
   }
   else
   {
-    switch (sqlite3_step (stmt))
-    {
-    case SQLITE_DONE:
-      ret = GNUNET_NO;
-      break;
-    case SQLITE_ROW:
-      ret = fragment_row (stmt, cb, cb_cls);
-      break;
-    default:
-      LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                  "sqlite3_step");
-    }
+    ret = fragment_select (plugin, stmt, returned_fragments, cb, cb_cls);
   }
 
   if (SQLITE_OK != sqlite3_reset (stmt))
@@ -1087,8 +1151,52 @@ fragment_get (void *cls,
   return ret;
 }
 
+
 /**
- * Retrieve all fragments of a message.
+ * Retrieve a message fragment range by fragment ID.
+ *
+ * @see GNUNET_PSYCSTORE_fragment_get_latest()
+ *
+ * @return #GNUNET_OK on success, else #GNUNET_SYSERR
+ */
+static int
+fragment_get_latest (void *cls,
+                     const struct GNUNET_CRYPTO_EddsaPublicKey *channel_key,
+                     uint64_t fragment_limit,
+                     uint64_t *returned_fragments,
+                     GNUNET_PSYCSTORE_FragmentCallback cb,
+                     void *cb_cls)
+{
+  struct Plugin *plugin = cls;
+  sqlite3_stmt *stmt = plugin->select_latest_fragments;
+  int ret = GNUNET_SYSERR;
+  *returned_fragments = 0;
+
+  if (SQLITE_OK != sqlite3_bind_blob (stmt, 1, channel_key,
+                                      sizeof (*channel_key),
+                                      SQLITE_STATIC)
+      || SQLITE_OK != sqlite3_bind_int64 (stmt, 2, fragment_limit))
+  {
+    LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind");
+  }
+  else
+  {
+    ret = fragment_select (plugin, stmt, returned_fragments, cb, cb_cls);
+  }
+
+  if (SQLITE_OK != sqlite3_reset (stmt))
+  {
+    LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_reset");
+  }
+
+  return ret;
+}
+
+
+/**
+ * Retrieve all fragments of a message ID range.
  *
  * @see GNUNET_PSYCSTORE_message_get()
  *
@@ -1097,48 +1205,29 @@ fragment_get (void *cls,
 static int
 message_get (void *cls,
              const struct GNUNET_CRYPTO_EddsaPublicKey *channel_key,
-             uint64_t message_id,
+             uint64_t first_message_id,
+             uint64_t last_message_id,
              uint64_t *returned_fragments,
              GNUNET_PSYCSTORE_FragmentCallback cb,
              void *cb_cls)
 {
   struct Plugin *plugin = cls;
-  sqlite3_stmt *stmt = plugin->select_message;
+  sqlite3_stmt *stmt = plugin->select_messages;
   int ret = GNUNET_SYSERR;
   *returned_fragments = 0;
 
   if (SQLITE_OK != sqlite3_bind_blob (stmt, 1, channel_key,
                                       sizeof (*channel_key),
                                       SQLITE_STATIC)
-      || SQLITE_OK != sqlite3_bind_int64 (stmt, 2, message_id))
+      || SQLITE_OK != sqlite3_bind_int64 (stmt, 2, first_message_id)
+      || SQLITE_OK != sqlite3_bind_int64 (stmt, 3, last_message_id))
   {
     LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_bind");
   }
   else
   {
-    int sql_ret;
-    do
-    {
-      sql_ret = sqlite3_step (stmt);
-      switch (sql_ret)
-      {
-      case SQLITE_DONE:
-        if (ret != GNUNET_OK)
-          ret = GNUNET_NO;
-        break;
-      case SQLITE_ROW:
-        ret = fragment_row (stmt, cb, cb_cls);
-        (*returned_fragments)++;
-        if (ret != GNUNET_YES)
-          sql_ret = SQLITE_DONE;
-        break;
-      default:
-        LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                    "sqlite3_step");
-      }
-    }
-    while (sql_ret == SQLITE_ROW);
+    ret = fragment_select (plugin, stmt, returned_fragments, cb, cb_cls);
   }
 
   if (SQLITE_OK != sqlite3_reset (stmt))
@@ -1150,6 +1239,53 @@ message_get (void *cls,
   return ret;
 }
 
+
+/**
+ * Retrieve all fragments of the latest messages.
+ *
+ * @see GNUNET_PSYCSTORE_message_get_latest()
+ *
+ * @return #GNUNET_OK on success, else #GNUNET_SYSERR
+ */
+static int
+message_get_latest (void *cls,
+                    const struct GNUNET_CRYPTO_EddsaPublicKey *channel_key,
+                    uint64_t message_limit,
+                    uint64_t *returned_fragments,
+                    GNUNET_PSYCSTORE_FragmentCallback cb,
+                    void *cb_cls)
+{
+  struct Plugin *plugin = cls;
+  sqlite3_stmt *stmt = plugin->select_latest_messages;
+  int ret = GNUNET_SYSERR;
+  *returned_fragments = 0;
+
+  if (SQLITE_OK != sqlite3_bind_blob (stmt, 1, channel_key,
+                                      sizeof (*channel_key),
+                                      SQLITE_STATIC)
+      || SQLITE_OK != sqlite3_bind_blob (stmt, 2, channel_key,
+                                         sizeof (*channel_key),
+                                         SQLITE_STATIC)
+      || SQLITE_OK != sqlite3_bind_int64 (stmt, 3, message_limit))
+  {
+    LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind");
+  }
+  else
+  {
+    ret = fragment_select (plugin, stmt, returned_fragments, cb, cb_cls);
+  }
+
+  if (SQLITE_OK != sqlite3_reset (stmt))
+  {
+    LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_reset");
+  }
+
+  return ret;
+}
+
+
 /**
  * Retrieve a fragment of message specified by its message ID and fragment
  * offset.
@@ -1777,7 +1913,9 @@ libgnunet_plugin_psycstore_sqlite_init (void *cls)
   api->fragment_store = &fragment_store;
   api->message_add_flags = &message_add_flags;
   api->fragment_get = &fragment_get;
+  api->fragment_get_latest = &fragment_get_latest;
   api->message_get = &message_get;
+  api->message_get_latest = &message_get_latest;
   api->message_get_fragment = &message_get_fragment;
   api->counters_message_get = &counters_message_get;
   api->counters_state_get = &counters_state_get;
diff --git a/src/psycstore/psycstore.h b/src/psycstore/psycstore.h
index 17905f422..e6a82848a 100644
--- a/src/psycstore/psycstore.h
+++ b/src/psycstore/psycstore.h
@@ -42,15 +42,17 @@ struct OperationResult
    */
   struct GNUNET_MessageHeader header;
 
+  uint32_t reserved GNUNET_PACKED;
+
   /**
    * Operation ID.
    */
-  uint32_t op_id GNUNET_PACKED;
+  uint64_t op_id GNUNET_PACKED;
 
   /**
    * Status code for the operation.
    */
-  int64_t result_code GNUNET_PACKED;
+  uint64_t result_code GNUNET_PACKED;
 
   /* followed by 0-terminated error message (on error) */
 
@@ -70,9 +72,17 @@ struct CountersResult
   struct GNUNET_MessageHeader header;
 
   /**
+   * Status code for the operation:
+   * #GNUNET_OK: success, counter values are returned.
+   * #GNUNET_NO: no message has been sent to the channel yet.
+   * #GNUNET_SYSERR: an error occurred.
+   */
+  uint32_t result_code GNUNET_PACKED;
+
+  /**
    * Operation ID.
    */
-  uint32_t op_id GNUNET_PACKED;
+  uint64_t op_id GNUNET_PACKED;
 
   uint64_t max_fragment_id GNUNET_PACKED;
 
@@ -81,14 +91,6 @@ struct CountersResult
   uint64_t max_group_generation GNUNET_PACKED;
 
   uint64_t max_state_message_id GNUNET_PACKED;
-
-  /**
-   * Status code for the operation:
-   * #GNUNET_OK: success, counter values are returned.
-   * #GNUNET_NO: no message has been sent to the channel yet.
-   * #GNUNET_SYSERR: an error occurred.
-   */
-  int32_t result_code GNUNET_PACKED;
 };
 
 
@@ -102,15 +104,14 @@ struct FragmentResult
    */
   struct GNUNET_MessageHeader header;
 
+  uint32_t psycstore_flags GNUNET_PACKED;
+
   /**
    * Operation ID.
    */
-  uint32_t op_id GNUNET_PACKED;
-
-  uint32_t psycstore_flags GNUNET_PACKED;
-
-  /* followed by GNUNET_MULTICAST_MessageHeader */
+  uint64_t op_id GNUNET_PACKED;
 
+  /* Followed by GNUNET_MULTICAST_MessageHeader */
 };
 
 
@@ -124,14 +125,16 @@ struct StateResult
    */
   struct GNUNET_MessageHeader header;
 
+  uint16_t name_size GNUNET_PACKED;
+
+  uint16_t reserved GNUNET_PACKED;
+
   /**
    * Operation ID.
    */
-  uint32_t op_id GNUNET_PACKED;
-
-  uint16_t name_size  GNUNET_PACKED;
+  uint64_t op_id GNUNET_PACKED;
 
-  /* followed by name and value */
+  /* Followed by name and value */
 };
 
 
@@ -142,13 +145,14 @@ struct OperationRequest
 {
   struct GNUNET_MessageHeader header;
 
+  uint32_t reserved GNUNET_PACKED;
+
   /**
    * Operation ID.
    */
-  uint32_t op_id GNUNET_PACKED;
+  uint64_t op_id GNUNET_PACKED;
 
   struct GNUNET_CRYPTO_EddsaPublicKey channel_key;
-
 };
 
 
@@ -162,10 +166,12 @@ struct MembershipStoreRequest
    */
   struct GNUNET_MessageHeader header;
 
+  uint32_t reserved GNUNET_PACKED;
+
   /**
    * Operation ID.
    */
-  uint32_t op_id GNUNET_PACKED;
+  uint64_t op_id GNUNET_PACKED;
 
   /**
    * Channel's public key.
@@ -177,9 +183,9 @@ struct MembershipStoreRequest
    */
   struct GNUNET_CRYPTO_EcdsaPublicKey slave_key;
 
-  uint64_t announced_at;
-  uint64_t effective_since;
-  uint64_t group_generation;
+  uint64_t announced_at GNUNET_PACKED;
+  uint64_t effective_since GNUNET_PACKED;
+  uint64_t group_generation GNUNET_PACKED;
   uint8_t did_join;
 };
 
@@ -194,10 +200,12 @@ struct MembershipTestRequest
    */
   struct GNUNET_MessageHeader header;
 
+  uint32_t reserved GNUNET_PACKED;
+
   /**
    * Operation ID.
    */
-  uint32_t op_id GNUNET_PACKED;
+  uint64_t op_id GNUNET_PACKED;
 
   /**
    * Channel's public key.
@@ -226,9 +234,9 @@ struct FragmentStoreRequest
   struct GNUNET_MessageHeader header;
 
   /**
-   * Operation ID.
+   * enum GNUNET_PSYCSTORE_MessageFlags
    */
-  uint32_t op_id GNUNET_PACKED;
+  uint32_t psycstore_flags GNUNET_PACKED;
 
   /**
    * Channel's public key.
@@ -236,9 +244,9 @@ struct FragmentStoreRequest
   struct GNUNET_CRYPTO_EddsaPublicKey channel_key;
 
   /**
-   * enum GNUNET_PSYCSTORE_MessageFlags
+   * Operation ID.
    */
-  uint32_t psycstore_flags GNUNET_PACKED;
+  uint64_t op_id;
 
   /* Followed by fragment */
 };
@@ -254,10 +262,12 @@ struct FragmentGetRequest
    */
   struct GNUNET_MessageHeader header;
 
+  uint32_t reserved GNUNET_PACKED;
+
   /**
    * Operation ID.
    */
-  uint32_t op_id GNUNET_PACKED;
+  uint64_t op_id GNUNET_PACKED;
 
   /**
    * Channel's public key.
@@ -270,9 +280,19 @@ struct FragmentGetRequest
   struct GNUNET_CRYPTO_EcdsaPublicKey slave_key;
 
   /**
-   * Fragment ID to request.
+   * First fragment ID to request.
    */
-  uint64_t fragment_id GNUNET_PACKED;
+  uint64_t first_fragment_id GNUNET_PACKED;
+
+  /**
+   * Last fragment ID to request.
+   */
+  uint64_t last_fragment_id GNUNET_PACKED;
+
+  /**
+   * Maximum number of fragments to retrieve.
+   */
+  uint64_t fragment_limit GNUNET_PACKED;
 
   /**
    * Do membership test with @a slave_key before returning fragment?
@@ -292,10 +312,12 @@ struct MessageGetRequest
    */
   struct GNUNET_MessageHeader header;
 
+  uint32_t reserved GNUNET_PACKED;
+
   /**
    * Operation ID.
    */
-  uint32_t op_id GNUNET_PACKED;
+  uint64_t op_id GNUNET_PACKED;
 
   /**
    * Channel's public key.
@@ -308,9 +330,19 @@ struct MessageGetRequest
   struct GNUNET_CRYPTO_EcdsaPublicKey slave_key;
 
   /**
-   * Message ID to request.
+   * First message ID to request.
    */
-  uint64_t message_id GNUNET_PACKED;
+  uint64_t first_message_id GNUNET_PACKED;
+
+  /**
+   * Last message ID to request.
+   */
+  uint64_t last_message_id GNUNET_PACKED;
+
+  /**
+   * Maximum number of messages to retrieve.
+   */
+  uint64_t message_limit GNUNET_PACKED;
 
   /**
    * Do membership test with @a slave_key before returning fragment?
@@ -330,10 +362,12 @@ struct MessageGetFragmentRequest
    */
   struct GNUNET_MessageHeader header;
 
+  uint32_t reserved GNUNET_PACKED;
+
   /**
    * Operation ID.
    */
-  uint32_t op_id GNUNET_PACKED;
+  uint64_t op_id GNUNET_PACKED;
 
   /**
    * Channel's public key.
@@ -373,10 +407,12 @@ struct StateHashUpdateRequest
    */
   struct GNUNET_MessageHeader header;
 
+  uint32_t reserved GNUNET_PACKED;
+
   /**
    * Operation ID.
    */
-  uint32_t op_id GNUNET_PACKED;
+  uint64_t op_id GNUNET_PACKED;
 
   /**
    * Channel's public key.
@@ -405,20 +441,6 @@ struct StateModifyRequest
   struct GNUNET_MessageHeader header;
 
   /**
-   * Operation ID.
-   */
-  uint32_t op_id GNUNET_PACKED;
-
-  /**
-   * Channel's public key.
-   */
-  struct GNUNET_CRYPTO_EddsaPublicKey channel_key;
-
-  uint64_t message_id GNUNET_PACKED;
-
-  uint64_t state_delta GNUNET_PACKED;
-
-  /**
    * Size of name, including NUL terminator.
    */
   uint16_t name_size GNUNET_PACKED;
@@ -433,6 +455,20 @@ struct StateModifyRequest
    */
   uint8_t oper;
 
+  /**
+   * Operation ID.
+   */
+  uint64_t op_id GNUNET_PACKED;
+
+  /**
+   * Channel's public key.
+   */
+  struct GNUNET_CRYPTO_EddsaPublicKey channel_key;
+
+  uint64_t message_id GNUNET_PACKED;
+
+  uint64_t state_delta GNUNET_PACKED;
+
   /* Followed by NUL-terminated name, then the value. */
 };
 
@@ -448,26 +484,28 @@ struct StateSyncRequest
   struct GNUNET_MessageHeader header;
 
   /**
-   * Operation ID.
+   * Size of name, including NUL terminator.
    */
-  uint32_t op_id GNUNET_PACKED;
+  uint16_t name_size GNUNET_PACKED;
 
   /**
-   * Channel's public key.
+   * OR'd StateOpFlags
    */
-  struct GNUNET_CRYPTO_EddsaPublicKey channel_key;
+  uint8_t flags;
+
+  uint8_t reserved;
 
   uint64_t message_id GNUNET_PACKED;
 
   /**
-   * Size of name, including NUL terminator.
+   * Operation ID.
    */
-  uint16_t name_size GNUNET_PACKED;
+  uint64_t op_id GNUNET_PACKED;
 
   /**
-   * OR'd StateOpFlags
+   * Channel's public key.
    */
-  uint8_t flags;
+  struct GNUNET_CRYPTO_EddsaPublicKey channel_key;
 
   /* Followed by NUL-terminated name, then the value. */
 };
diff --git a/src/psycstore/psycstore_api.c b/src/psycstore/psycstore_api.c
index 9df55888d..9ef1fb61a 100644
--- a/src/psycstore/psycstore_api.c
+++ b/src/psycstore/psycstore_api.c
@@ -25,6 +25,8 @@
  * @author Christian Grothoff
  */
 
+#include <inttypes.h>
+
 #include "platform.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_constants.h"
@@ -76,7 +78,7 @@ struct GNUNET_PSYCSTORE_OperationHandle
   /**
    * Operation ID.
    */
-  uint32_t op_id;
+  uint64_t op_id;
 
   /**
    * Message to send to the PSYCstore service.
@@ -137,15 +139,14 @@ struct GNUNET_PSYCSTORE_Handle
   struct GNUNET_TIME_Relative reconnect_delay;
 
   /**
-   * Are we polling for incoming messages right now?
+   * Last operation ID used.
    */
-  int in_receive;
+  uint64_t last_op_id;
 
   /**
-   * The last operation id used for a PSYCstore operation.
+   * Are we polling for incoming messages right now?
    */
-  uint32_t last_op_id_used;
-
+  uint8_t in_receive;
 };
 
 
@@ -155,10 +156,10 @@ struct GNUNET_PSYCSTORE_Handle
  * @param h Handle to the PSYCstore service.
  * @return next operation id to use
  */
-static uint32_t
+static uint64_t
 get_next_op_id (struct GNUNET_PSYCSTORE_Handle *h)
 {
-  return h->last_op_id_used++;
+  return h->last_op_id++;
 }
 
 
@@ -168,7 +169,7 @@ get_next_op_id (struct GNUNET_PSYCSTORE_Handle *h)
  * @return OperationHandle if found, or NULL otherwise.
  */
 static struct GNUNET_PSYCSTORE_OperationHandle *
-find_op_by_id (struct GNUNET_PSYCSTORE_Handle *h, uint32_t op_id)
+find_op_by_id (struct GNUNET_PSYCSTORE_Handle *h, uint64_t op_id)
 {
   struct GNUNET_PSYCSTORE_OperationHandle *op = h->op_head;
   while (NULL != op)
@@ -284,19 +285,20 @@ message_handler (void *cls, const struct GNUNET_MessageHeader *msg)
     if (size == sizeof (struct OperationResult))
       str = NULL;
 
-    op = find_op_by_id (h, ntohl (opres->op_id));
+    op = find_op_by_id (h, GNUNET_ntohll (opres->op_id));
     if (NULL == op)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "No callback registered for operation with ID %ld.\n",
-           type, ntohl (opres->op_id));
+           "No callback registered for operation with ID %" PRIu64 ".\n",
+           type, GNUNET_ntohll (opres->op_id));
     }
     else
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Received result message (type %d) with operation ID: %ld\n",
+           "Received result message (type %d) with operation ID: %" PRIu64 "\n",
            type, op->op_id);
 
+      int64_t result_code = GNUNET_ntohll (opres->result_code) + INT64_MIN;
       GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
       if (NULL != op->res_cb)
       {
@@ -307,19 +309,19 @@ message_handler (void *cls, const struct GNUNET_MessageHeader *msg)
         case GNUNET_MESSAGE_TYPE_PSYCSTORE_STATE_MODIFY:
           smreq = (const struct StateModifyRequest *) op->msg;
           if (!(smreq->flags & STATE_OP_LAST
-                || GNUNET_OK != ntohl (opres->result_code)))
+                || GNUNET_OK != result_code))
             op->res_cb = NULL;
           break;
         case GNUNET_MESSAGE_TYPE_PSYCSTORE_STATE_SYNC:
           ssreq = (const struct StateSyncRequest *) op->msg;
           if (!(ssreq->flags & STATE_OP_LAST
-                || GNUNET_OK != ntohl (opres->result_code)))
+                || GNUNET_OK != result_code))
             op->res_cb = NULL;
           break;
         }
       }
       if (NULL != op->res_cb)
-        op->res_cb (op->cls, ntohl (opres->result_code), str);
+        op->res_cb (op->cls, result_code, str);
       GNUNET_free (op);
     }
     break;
@@ -338,19 +340,20 @@ message_handler (void *cls, const struct GNUNET_MessageHeader *msg)
 
     cres = (const struct CountersResult *) msg;
 
-    op = find_op_by_id (h, ntohl (cres->op_id));
+    op = find_op_by_id (h, GNUNET_ntohll (cres->op_id));
     if (NULL == op)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "No callback registered for operation with ID %ld.\n",
-           type, ntohl (cres->op_id));
+           "No callback registered for operation with ID %" PRIu64 ".\n",
+           type, GNUNET_ntohll (cres->op_id));
     }
     else
     {
       GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
       if (NULL != op->data_cb)
         ((GNUNET_PSYCSTORE_CountersCallback)
-         op->data_cb) (op->cls, ntohl (cres->result_code),
+         op->data_cb) (op->cls,
+                       ntohl (cres->result_code) + INT32_MIN,
                        GNUNET_ntohll (cres->max_fragment_id),
                        GNUNET_ntohll (cres->max_message_id),
                        GNUNET_ntohll (cres->max_group_generation),
@@ -386,12 +389,12 @@ message_handler (void *cls, const struct GNUNET_MessageHeader *msg)
       return;
     }
 
-    op = find_op_by_id (h, ntohl (fres->op_id));
+    op = find_op_by_id (h, GNUNET_ntohll (fres->op_id));
     if (NULL == op)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "No callback registered for operation with ID %ld.\n",
-           type, ntohl (fres->op_id));
+           "No callback registered for operation with ID %" PRIu64 ".\n",
+           type, GNUNET_ntohll (fres->op_id));
     }
     else
     {
@@ -427,12 +430,12 @@ message_handler (void *cls, const struct GNUNET_MessageHeader *msg)
       return;
     }
 
-    op = find_op_by_id (h, ntohl (sres->op_id));
+    op = find_op_by_id (h, GNUNET_ntohll (sres->op_id));
     if (NULL == op)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "No callback registered for operation with ID %ld.\n",
-           type, ntohl (sres->op_id));
+           "No callback registered for operation with ID %" PRIu64 ".\n",
+           type, GNUNET_ntohll (sres->op_id));
     }
     else
     {
@@ -479,7 +482,7 @@ send_next_message (void *cls, size_t size, void *buf)
     return 0;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Sending message of type %d to PSYCstore service. ID: %u\n",
+       "Sending message of type %d to PSYCstore service. ID: %" PRIu64 "\n",
        ntohs (op->msg->type), op->op_id);
   memcpy (buf, op->msg, ret);
 
@@ -682,8 +685,8 @@ GNUNET_PSYCSTORE_membership_store (struct GNUNET_PSYCSTORE_Handle *h,
                  : effective_since == 0);
 
   struct MembershipStoreRequest *req;
-  struct GNUNET_PSYCSTORE_OperationHandle *op
-    = GNUNET_malloc (sizeof (*op) + sizeof (*req));
+  struct GNUNET_PSYCSTORE_OperationHandle *
+    op = GNUNET_malloc (sizeof (*op) + sizeof (*req));
   op->h = h;
   op->res_cb = rcb;
   op->cls = rcb_cls;
@@ -700,7 +703,7 @@ GNUNET_PSYCSTORE_membership_store (struct GNUNET_PSYCSTORE_Handle *h,
   req->group_generation = GNUNET_htonll (group_generation);
 
   op->op_id = get_next_op_id (h);
-  req->op_id = htonl (op->op_id);
+  req->op_id = GNUNET_htonll (op->op_id);
 
   GNUNET_CONTAINER_DLL_insert_tail (h->transmit_head, h->transmit_tail, op);
   transmit_next (h);
@@ -746,8 +749,8 @@ GNUNET_PSYCSTORE_membership_test (struct GNUNET_PSYCSTORE_Handle *h,
                                   void *rcb_cls)
 {
   struct MembershipTestRequest *req;
-  struct GNUNET_PSYCSTORE_OperationHandle *op
-    = GNUNET_malloc (sizeof (*op) + sizeof (*req));
+  struct GNUNET_PSYCSTORE_OperationHandle *
+    op = GNUNET_malloc (sizeof (*op) + sizeof (*req));
   op->h = h;
   op->res_cb = rcb;
   op->cls = rcb_cls;
@@ -762,7 +765,7 @@ GNUNET_PSYCSTORE_membership_test (struct GNUNET_PSYCSTORE_Handle *h,
   req->group_generation = GNUNET_htonll (group_generation);
 
   op->op_id = get_next_op_id (h);
-  req->op_id = htonl (op->op_id);
+  req->op_id = GNUNET_htonll (op->op_id);
 
   GNUNET_CONTAINER_DLL_insert_tail (h->transmit_head, h->transmit_tail, op);
   transmit_next (h);
@@ -794,8 +797,8 @@ GNUNET_PSYCSTORE_fragment_store (struct GNUNET_PSYCSTORE_Handle *h,
 {
   uint16_t size = ntohs (msg->header.size);
   struct FragmentStoreRequest *req;
-  struct GNUNET_PSYCSTORE_OperationHandle *op
-    = GNUNET_malloc (sizeof (*op) + sizeof (*req) + size);
+  struct GNUNET_PSYCSTORE_OperationHandle *
+    op = GNUNET_malloc (sizeof (*op) + sizeof (*req) + size);
   op->h = h;
   op->res_cb = rcb;
   op->cls = rcb_cls;
@@ -809,7 +812,7 @@ GNUNET_PSYCSTORE_fragment_store (struct GNUNET_PSYCSTORE_Handle *h,
   memcpy (&req[1], msg, size);
 
   op->op_id = get_next_op_id (h);
-  req->op_id = htonl (op->op_id);
+  req->op_id = GNUNET_htonll (op->op_id);
 
   GNUNET_CONTAINER_DLL_insert_tail (h->transmit_head, h->transmit_tail, op);
   transmit_next (h);
@@ -819,7 +822,7 @@ GNUNET_PSYCSTORE_fragment_store (struct GNUNET_PSYCSTORE_Handle *h,
 
 
 /**
- * Retrieve a message fragment by fragment ID.
+ * Retrieve message fragments by fragment ID range.
  *
  * @param h
  *        Handle for the PSYCstore.
@@ -829,9 +832,15 @@ GNUNET_PSYCSTORE_fragment_store (struct GNUNET_PSYCSTORE_Handle *h,
  *        The slave requesting the fragment.  If not NULL, a membership test is
  *        performed first and the fragment is only returned if the slave has
  *        access to it.
- * @param fragment_id
- *        Fragment ID to retrieve.  Use 0 to get the latest message fragment.
- * @param fcb
+ * @param first_fragment_id
+ *        First fragment ID to retrieve.
+ *        Use 0 to get the latest message fragment.
+ * @param last_fragment_id
+ *        Last consecutive fragment ID to retrieve.
+ *        Use 0 to get the latest message fragment.
+ * @param fragment_limit
+ *        Maximum number of fragments to retrieve.
+ * @param fragment_cb
  *        Callback to call with the retrieved fragments.
  * @param rcb
  *        Callback to call with the result of the operation.
@@ -844,16 +853,85 @@ struct GNUNET_PSYCSTORE_OperationHandle *
 GNUNET_PSYCSTORE_fragment_get (struct GNUNET_PSYCSTORE_Handle *h,
                                const struct GNUNET_CRYPTO_EddsaPublicKey *channel_key,
                                const struct GNUNET_CRYPTO_EcdsaPublicKey *slave_key,
-                               uint64_t fragment_id,
-                               GNUNET_PSYCSTORE_FragmentCallback fcb,
+                               uint64_t first_fragment_id,
+                               uint64_t last_fragment_id,
+                               GNUNET_PSYCSTORE_FragmentCallback fragment_cb,
                                GNUNET_PSYCSTORE_ResultCallback rcb,
                                void *cls)
 {
   struct FragmentGetRequest *req;
-  struct GNUNET_PSYCSTORE_OperationHandle *op
-    = GNUNET_malloc (sizeof (*op) + sizeof (*req));
+  struct GNUNET_PSYCSTORE_OperationHandle *
+    op = GNUNET_malloc (sizeof (*op) + sizeof (*req));
+  op->h = h;
+  op->data_cb = (DataCallback) fragment_cb;
+  op->res_cb = rcb;
+  op->cls = cls;
+
+  req = (struct FragmentGetRequest *) &op[1];
+  op->msg = (struct GNUNET_MessageHeader *) req;
+  req->header.type = htons (GNUNET_MESSAGE_TYPE_PSYCSTORE_FRAGMENT_GET);
+  req->header.size = htons (sizeof (*req));
+  req->channel_key = *channel_key;
+  req->first_fragment_id = GNUNET_htonll (first_fragment_id);
+  req->last_fragment_id = GNUNET_htonll (last_fragment_id);
+  if (NULL != slave_key)
+  {
+    req->slave_key = *slave_key;
+    req->do_membership_test = GNUNET_YES;
+  }
+
+  op->op_id = get_next_op_id (h);
+  req->op_id = GNUNET_htonll (op->op_id);
+
+  GNUNET_CONTAINER_DLL_insert_tail (h->transmit_head, h->transmit_tail, op);
+  transmit_next (h);
+
+  return op;
+}
+
+
+/**
+ * Retrieve latest message fragments.
+ *
+ * @param h
+ *        Handle for the PSYCstore.
+ * @param channel_key
+ *        The channel we are interested in.
+ * @param slave_key
+ *        The slave requesting the fragment.  If not NULL, a membership test is
+ *        performed first and the fragment is only returned if the slave has
+ *        access to it.
+ * @param first_fragment_id
+ *        First fragment ID to retrieve.
+ *        Use 0 to get the latest message fragment.
+ * @param last_fragment_id
+ *        Last consecutive fragment ID to retrieve.
+ *        Use 0 to get the latest message fragment.
+ * @param fragment_limit
+ *        Maximum number of fragments to retrieve.
+ * @param fragment_cb
+ *        Callback to call with the retrieved fragments.
+ * @param rcb
+ *        Callback to call with the result of the operation.
+ * @param cls
+ *        Closure for the callbacks.
+ *
+ * @return Handle that can be used to cancel the operation.
+ */
+struct GNUNET_PSYCSTORE_OperationHandle *
+GNUNET_PSYCSTORE_fragment_get_latest (struct GNUNET_PSYCSTORE_Handle *h,
+                                      const struct GNUNET_CRYPTO_EddsaPublicKey *channel_key,
+                                      const struct GNUNET_CRYPTO_EcdsaPublicKey *slave_key,
+                                      uint64_t fragment_limit,
+                                      GNUNET_PSYCSTORE_FragmentCallback fragment_cb,
+                                      GNUNET_PSYCSTORE_ResultCallback rcb,
+                                      void *cls)
+{
+  struct FragmentGetRequest *req;
+  struct GNUNET_PSYCSTORE_OperationHandle *
+    op = GNUNET_malloc (sizeof (*op) + sizeof (*req));
   op->h = h;
-  op->data_cb = (DataCallback) fcb;
+  op->data_cb = (DataCallback) fragment_cb;
   op->res_cb = rcb;
   op->cls = cls;
 
@@ -862,7 +940,7 @@ GNUNET_PSYCSTORE_fragment_get (struct GNUNET_PSYCSTORE_Handle *h,
   req->header.type = htons (GNUNET_MESSAGE_TYPE_PSYCSTORE_FRAGMENT_GET);
   req->header.size = htons (sizeof (*req));
   req->channel_key = *channel_key;
-  req->fragment_id = GNUNET_htonll (fragment_id);
+  req->fragment_limit = GNUNET_ntohll (fragment_limit);
   if (NULL != slave_key)
   {
     req->slave_key = *slave_key;
@@ -870,7 +948,7 @@ GNUNET_PSYCSTORE_fragment_get (struct GNUNET_PSYCSTORE_Handle *h,
   }
 
   op->op_id = get_next_op_id (h);
-  req->op_id = htonl (op->op_id);
+  req->op_id = GNUNET_htonll (op->op_id);
 
   GNUNET_CONTAINER_DLL_insert_tail (h->transmit_head, h->transmit_tail, op);
   transmit_next (h);
@@ -880,7 +958,7 @@ GNUNET_PSYCSTORE_fragment_get (struct GNUNET_PSYCSTORE_Handle *h,
 
 
 /**
- * Retrieve all fragments of a message.
+ * Retrieve all fragments of messages in a message ID range.
  *
  * @param h
  *        Handle for the PSYCstore.
@@ -890,9 +968,13 @@ GNUNET_PSYCSTORE_fragment_get (struct GNUNET_PSYCSTORE_Handle *h,
  *        The slave requesting the message.  If not NULL, a membership test is
  *        performed first and the message is only returned if the slave has
  *        access to it.
- * @param message_id
- *        Message ID to retrieve.  Use 0 to get the latest message.
- * @param fcb
+ * @param first_message_id
+ *        First message ID to retrieve.
+ *        Use 0 to get the latest message.
+ * @param last_message_id
+ *        Last consecutive message ID to retrieve.
+ *        Use 0 to get the latest message.
+ * @param fragment_cb
  *        Callback to call with the retrieved fragments.
  * @param rcb
  *        Callback to call with the result of the operation.
@@ -905,16 +987,17 @@ struct GNUNET_PSYCSTORE_OperationHandle *
 GNUNET_PSYCSTORE_message_get (struct GNUNET_PSYCSTORE_Handle *h,
                               const struct GNUNET_CRYPTO_EddsaPublicKey *channel_key,
                               const struct GNUNET_CRYPTO_EcdsaPublicKey *slave_key,
-                              uint64_t message_id,
-                              GNUNET_PSYCSTORE_FragmentCallback fcb,
+                              uint64_t first_message_id,
+                              uint64_t last_message_id,
+                              GNUNET_PSYCSTORE_FragmentCallback fragment_cb,
                               GNUNET_PSYCSTORE_ResultCallback rcb,
                               void *cls)
 {
   struct MessageGetRequest *req;
-  struct GNUNET_PSYCSTORE_OperationHandle *op
-    = GNUNET_malloc (sizeof (*op) + sizeof (*req));
+  struct GNUNET_PSYCSTORE_OperationHandle *
+    op = GNUNET_malloc (sizeof (*op) + sizeof (*req));
   op->h = h;
-  op->data_cb = (DataCallback) fcb;
+  op->data_cb = (DataCallback) fragment_cb;
   op->res_cb = rcb;
   op->cls = cls;
 
@@ -923,7 +1006,8 @@ GNUNET_PSYCSTORE_message_get (struct GNUNET_PSYCSTORE_Handle *h,
   req->header.type = htons (GNUNET_MESSAGE_TYPE_PSYCSTORE_MESSAGE_GET);
   req->header.size = htons (sizeof (*req));
   req->channel_key = *channel_key;
-  req->message_id = GNUNET_htonll (message_id);
+  req->first_message_id = GNUNET_htonll (first_message_id);
+  req->last_message_id = GNUNET_htonll (last_message_id);
   if (NULL != slave_key)
   {
     req->slave_key = *slave_key;
@@ -931,7 +1015,68 @@ GNUNET_PSYCSTORE_message_get (struct GNUNET_PSYCSTORE_Handle *h,
   }
 
   op->op_id = get_next_op_id (h);
-  req->op_id = htonl (op->op_id);
+  req->op_id = GNUNET_htonll (op->op_id);
+
+  GNUNET_CONTAINER_DLL_insert_tail (h->transmit_head, h->transmit_tail, op);
+  transmit_next (h);
+
+  return op;
+}
+
+
+/**
+ * Retrieve all fragments of the latest messages.
+ *
+ * @param h
+ *        Handle for the PSYCstore.
+ * @param channel_key
+ *        The channel we are interested in.
+ * @param slave_key
+ *        The slave requesting the message.  If not NULL, a membership test is
+ *        performed first and the message is only returned if the slave has
+ *        access to it.
+ * @param message_limit
+ *        Maximum number of messages to retrieve.
+ * @param fragment_cb
+ *        Callback to call with the retrieved fragments.
+ * @param rcb
+ *        Callback to call with the result of the operation.
+ * @param cls
+ *        Closure for the callbacks.
+ *
+ * @return Handle that can be used to cancel the operation.
+ */
+struct GNUNET_PSYCSTORE_OperationHandle *
+GNUNET_PSYCSTORE_message_get_latest (struct GNUNET_PSYCSTORE_Handle *h,
+                                     const struct GNUNET_CRYPTO_EddsaPublicKey *channel_key,
+                                     const struct GNUNET_CRYPTO_EcdsaPublicKey *slave_key,
+                                     uint64_t message_limit,
+                                     GNUNET_PSYCSTORE_FragmentCallback fragment_cb,
+                                     GNUNET_PSYCSTORE_ResultCallback rcb,
+                                     void *cls)
+{
+  struct MessageGetRequest *req;
+  struct GNUNET_PSYCSTORE_OperationHandle *
+    op = GNUNET_malloc (sizeof (*op) + sizeof (*req));
+  op->h = h;
+  op->data_cb = (DataCallback) fragment_cb;
+  op->res_cb = rcb;
+  op->cls = cls;
+
+  req = (struct MessageGetRequest *) &op[1];
+  op->msg = (struct GNUNET_MessageHeader *) req;
+  req->header.type = htons (GNUNET_MESSAGE_TYPE_PSYCSTORE_MESSAGE_GET);
+  req->header.size = htons (sizeof (*req));
+  req->channel_key = *channel_key;
+  req->message_limit = GNUNET_ntohll (message_limit);
+  if (NULL != slave_key)
+  {
+    req->slave_key = *slave_key;
+    req->do_membership_test = GNUNET_YES;
+  }
+
+  op->op_id = get_next_op_id (h);
+  req->op_id = GNUNET_htonll (op->op_id);
 
   GNUNET_CONTAINER_DLL_insert_tail (h->transmit_head, h->transmit_tail, op);
   transmit_next (h);
@@ -956,9 +1101,9 @@ GNUNET_PSYCSTORE_message_get (struct GNUNET_PSYCSTORE_Handle *h,
  *        Message ID to retrieve.  Use 0 to get the latest message.
  * @param fragment_offset
  *        Offset of the fragment to retrieve.
- * @param fcb
+ * @param fragment_cb
  *        Callback to call with the retrieved fragments.
- * @param rcb
+ * @param result_cb
  *        Callback to call with the result of the operation.
  * @param cls
  *        Closure for the callbacks.
@@ -971,15 +1116,15 @@ GNUNET_PSYCSTORE_message_get_fragment (struct GNUNET_PSYCSTORE_Handle *h,
                                        const struct GNUNET_CRYPTO_EcdsaPublicKey *slave_key,
                                        uint64_t message_id,
                                        uint64_t fragment_offset,
-                                       GNUNET_PSYCSTORE_FragmentCallback fcb,
+                                       GNUNET_PSYCSTORE_FragmentCallback fragment_cb,
                                        GNUNET_PSYCSTORE_ResultCallback rcb,
                                        void *cls)
 {
   struct MessageGetFragmentRequest *req;
-  struct GNUNET_PSYCSTORE_OperationHandle *op
-    = GNUNET_malloc (sizeof (*op) + sizeof (*req));
+  struct GNUNET_PSYCSTORE_OperationHandle *
+    op = GNUNET_malloc (sizeof (*op) + sizeof (*req));
   op->h = h;
-  op->data_cb = (DataCallback) fcb;
+  op->data_cb = (DataCallback) fragment_cb;
   op->res_cb = rcb;
   op->cls = cls;
 
@@ -997,7 +1142,7 @@ GNUNET_PSYCSTORE_message_get_fragment (struct GNUNET_PSYCSTORE_Handle *h,
   }
 
   op->op_id = get_next_op_id (h);
-  req->op_id = htonl (op->op_id);
+  req->op_id = GNUNET_htonll (op->op_id);
 
   GNUNET_CONTAINER_DLL_insert_tail (h->transmit_head, h->transmit_tail, op);
   transmit_next (h);
@@ -1026,8 +1171,8 @@ GNUNET_PSYCSTORE_counters_get (struct GNUNET_PSYCSTORE_Handle *h,
                                void *ccb_cls)
 {
   struct OperationRequest *req;
-  struct GNUNET_PSYCSTORE_OperationHandle *op
-    = GNUNET_malloc (sizeof (*op) + sizeof (*req));
+  struct GNUNET_PSYCSTORE_OperationHandle *
+    op = GNUNET_malloc (sizeof (*op) + sizeof (*req));
   op->h = h;
   op->data_cb = ccb;
   op->cls = ccb_cls;
@@ -1039,7 +1184,7 @@ GNUNET_PSYCSTORE_counters_get (struct GNUNET_PSYCSTORE_Handle *h,
   req->channel_key = *channel_key;
 
   op->op_id = get_next_op_id (h);
-  req->op_id = htonl (op->op_id);
+  req->op_id = GNUNET_htonll (op->op_id);
 
   GNUNET_CONTAINER_DLL_insert_tail (h->transmit_head, h->transmit_tail, op);
   transmit_next (h);
@@ -1109,7 +1254,7 @@ GNUNET_PSYCSTORE_state_modify (struct GNUNET_PSYCSTORE_Handle *h,
     memcpy ((char *) &req[1] + name_size, modifiers[i].value, modifiers[i].value_size);
 
     op->op_id = get_next_op_id (h);
-    req->op_id = htonl (op->op_id);
+    req->op_id = GNUNET_htonll (op->op_id);
 
     GNUNET_CONTAINER_DLL_insert_tail (h->transmit_head, h->transmit_tail, op);
     transmit_next (h);
@@ -1175,7 +1320,7 @@ GNUNET_PSYCSTORE_state_sync (struct GNUNET_PSYCSTORE_Handle *h,
     memcpy ((char *) &req[1] + name_size, modifiers[i].value, modifiers[i].value_size);
 
     op->op_id = get_next_op_id (h);
-    req->op_id = htonl (op->op_id);
+    req->op_id = GNUNET_htonll (op->op_id);
 
     GNUNET_CONTAINER_DLL_insert_tail (h->transmit_head, h->transmit_tail, op);
     transmit_next (h);
@@ -1204,8 +1349,8 @@ GNUNET_PSYCSTORE_state_reset (struct GNUNET_PSYCSTORE_Handle *h,
                               void *rcb_cls)
 {
   struct OperationRequest *req;
-  struct GNUNET_PSYCSTORE_OperationHandle *op
-    = GNUNET_malloc (sizeof (*op) + sizeof (*req));
+  struct GNUNET_PSYCSTORE_OperationHandle *
+    op = GNUNET_malloc (sizeof (*op) + sizeof (*req));
   op->h = h;
   op->res_cb = rcb;
   op->cls = rcb_cls;
@@ -1217,7 +1362,7 @@ GNUNET_PSYCSTORE_state_reset (struct GNUNET_PSYCSTORE_Handle *h,
   req->channel_key = *channel_key;
 
   op->op_id = get_next_op_id (h);
-  req->op_id = htonl (op->op_id);
+  req->op_id = GNUNET_htonll (op->op_id);
 
   GNUNET_CONTAINER_DLL_insert_tail (h->transmit_head, h->transmit_tail, op);
   transmit_next (h);
@@ -1247,8 +1392,8 @@ GNUNET_PSYCSTORE_state_hash_update (struct GNUNET_PSYCSTORE_Handle *h,
                                     void *rcb_cls)
 {
   struct StateHashUpdateRequest *req;
-  struct GNUNET_PSYCSTORE_OperationHandle *op
-    = GNUNET_malloc (sizeof (*op) + sizeof (*req));
+  struct GNUNET_PSYCSTORE_OperationHandle *
+    op = GNUNET_malloc (sizeof (*op) + sizeof (*req));
   op->h = h;
   op->res_cb = rcb;
   op->cls = rcb_cls;
@@ -1261,7 +1406,7 @@ GNUNET_PSYCSTORE_state_hash_update (struct GNUNET_PSYCSTORE_Handle *h,
   req->hash = *hash;
 
   op->op_id = get_next_op_id (h);
-  req->op_id = htonl (op->op_id);
+  req->op_id = GNUNET_htonll (op->op_id);
 
   GNUNET_CONTAINER_DLL_insert_tail (h->transmit_head, h->transmit_tail, op);
   transmit_next (h);
@@ -1292,8 +1437,8 @@ GNUNET_PSYCSTORE_state_get (struct GNUNET_PSYCSTORE_Handle *h,
 {
   size_t name_size = strlen (name) + 1;
   struct OperationRequest *req;
-  struct GNUNET_PSYCSTORE_OperationHandle *op
-    = GNUNET_malloc (sizeof (*op) + sizeof (*req) + name_size);
+  struct GNUNET_PSYCSTORE_OperationHandle *
+    op = GNUNET_malloc (sizeof (*op) + sizeof (*req) + name_size);
   op->h = h;
   op->data_cb = (DataCallback) scb;
   op->res_cb = rcb;
@@ -1307,7 +1452,7 @@ GNUNET_PSYCSTORE_state_get (struct GNUNET_PSYCSTORE_Handle *h,
   memcpy (&req[1], name, name_size);
 
   op->op_id = get_next_op_id (h);
-  req->op_id = htonl (op->op_id);
+  req->op_id = GNUNET_htonll (op->op_id);
 
   GNUNET_CONTAINER_DLL_insert_tail (h->transmit_head, h->transmit_tail, op);
   transmit_next (h);
@@ -1339,8 +1484,8 @@ GNUNET_PSYCSTORE_state_get_prefix (struct GNUNET_PSYCSTORE_Handle *h,
 {
   size_t name_size = strlen (name_prefix) + 1;
   struct OperationRequest *req;
-  struct GNUNET_PSYCSTORE_OperationHandle *op
-    = GNUNET_malloc (sizeof (*op) + sizeof (*req) + name_size);
+  struct GNUNET_PSYCSTORE_OperationHandle *
+    op = GNUNET_malloc (sizeof (*op) + sizeof (*req) + name_size);
   op->h = h;
   op->data_cb = (DataCallback) scb;
   op->res_cb = rcb;
@@ -1354,7 +1499,7 @@ GNUNET_PSYCSTORE_state_get_prefix (struct GNUNET_PSYCSTORE_Handle *h,
   memcpy (&req[1], name_prefix, name_size);
 
   op->op_id = get_next_op_id (h);
-  req->op_id = htonl (op->op_id);
+  req->op_id = GNUNET_htonll (op->op_id);
 
   GNUNET_CONTAINER_DLL_insert_tail (h->transmit_head, h->transmit_tail, op);
   transmit_next (h);
diff --git a/src/psycstore/test_plugin_psycstore.c b/src/psycstore/test_plugin_psycstore.c
index 8267ddba8..a6c456fec 100644
--- a/src/psycstore/test_plugin_psycstore.c
+++ b/src/psycstore/test_plugin_psycstore.c
@@ -204,11 +204,17 @@ run (void *cls, char *const *args, const char *cfgfile,
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MULTICAST_MESSAGE);
   msg->header.size = htons (sizeof (*msg) + sizeof (channel_pub_key));
 
+  uint64_t fragment_id = INT64_MAX - 1;
+  msg->fragment_id = GNUNET_htonll (fragment_id);
+
+  uint64_t message_id = INT64_MAX - 10;
+  msg->message_id = GNUNET_htonll (message_id);
+
+  uint64_t group_generation = INT64_MAX - 3;
+  msg->group_generation = GNUNET_htonll (group_generation);
+
   msg->hop_counter = htonl (9);
-  msg->fragment_id = GNUNET_htonll (INT64_MAX - 1);
   msg->fragment_offset = GNUNET_htonll (0);
-  msg->message_id = GNUNET_htonll (INT64_MAX - 10);
-  msg->group_generation = GNUNET_htonll (INT64_MAX - 3);
   msg->flags = htonl (GNUNET_MULTICAST_MESSAGE_LAST_FRAGMENT);
 
   memcpy (&msg[1], &channel_pub_key, sizeof (channel_pub_key));
@@ -225,14 +231,19 @@ run (void *cls, char *const *args, const char *cfgfile,
   fcls.msg[0] = msg;
   fcls.flags[0] = GNUNET_PSYCSTORE_MESSAGE_STATE;
 
-  GNUNET_assert (GNUNET_OK == db->fragment_store (db->cls, &channel_pub_key, msg,
-                                           fcls.flags[0]));
+  GNUNET_assert (
+    GNUNET_OK == db->fragment_store (db->cls, &channel_pub_key, msg,
+                                     fcls.flags[0]));
 
-  GNUNET_assert (GNUNET_OK == db->fragment_get (db->cls, &channel_pub_key,
-                                         GNUNET_ntohll (msg->fragment_id),
-                                         fragment_cb, &fcls));
+  uint64_t ret_frags = 0;
+  GNUNET_assert (
+    GNUNET_OK == db->fragment_get (db->cls, &channel_pub_key,
+                                   fragment_id, fragment_id,
+                                   &ret_frags, fragment_cb, &fcls));
   GNUNET_assert (fcls.n == 1);
 
+  // FIXME: test fragment_get_latest and message_get_latest
+
   fcls.n = 0;
 
   GNUNET_assert (
@@ -250,9 +261,10 @@ run (void *cls, char *const *args, const char *cfgfile,
   fcls.n = 0;
   fcls.flags[0] |= GNUNET_PSYCSTORE_MESSAGE_STATE_APPLIED;
 
-  GNUNET_assert (GNUNET_OK == db->fragment_get (db->cls, &channel_pub_key,
-                                                GNUNET_ntohll (msg->fragment_id),
-                                                fragment_cb, &fcls));
+  GNUNET_assert (
+    GNUNET_OK == db->fragment_get (db->cls, &channel_pub_key,
+                                   fragment_id, fragment_id,
+                                   &ret_frags, fragment_cb, &fcls));
   GNUNET_assert (fcls.n == 1);
 
   struct GNUNET_MULTICAST_MessageHeader *msg1
@@ -270,15 +282,17 @@ run (void *cls, char *const *args, const char *cfgfile,
   GNUNET_assert (GNUNET_OK == db->fragment_store (db->cls, &channel_pub_key, msg1,
                                                   fcls.flags[1]));
 
-  uint64_t retfrags = 0;
-  GNUNET_assert (GNUNET_OK == db->message_get (db->cls, &channel_pub_key,
-                                               GNUNET_ntohll (msg->message_id),
-                                               &retfrags, fragment_cb, &fcls));
-  GNUNET_assert (fcls.n == 2 && retfrags == 2);
+  GNUNET_assert (
+    GNUNET_OK == db->message_get (db->cls, &channel_pub_key,
+                                  message_id, message_id,
+                                  &ret_frags, fragment_cb, &fcls));
+  GNUNET_assert (fcls.n == 2 && ret_frags == 2);
 
   /* Message counters */
 
-  uint64_t fragment_id = 0, message_id = 0, group_generation = 0;
+  fragment_id = 0;
+  message_id = 0;
+  group_generation = 0;
   GNUNET_assert (
     GNUNET_OK == db->counters_message_get (db->cls, &channel_pub_key,
                                            &fragment_id, &message_id,
diff --git a/src/psycstore/test_psycstore.c b/src/psycstore/test_psycstore.c
index 3ef2439e3..125e64f58 100644
--- a/src/psycstore/test_psycstore.c
+++ b/src/psycstore/test_psycstore.c
@@ -25,6 +25,8 @@
  * @author Christian Grothoff
  */
 
+#include <inttypes.h>
+
 #include "platform.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_common.h"
@@ -302,19 +304,22 @@ fragment_result (void *cls,
                  enum GNUNET_PSYCSTORE_MessageFlags flags)
 {
   struct FragmentClosure *fcls = cls;
+  GNUNET_assert (fcls->n < fcls->n_expected);
   struct GNUNET_MULTICAST_MessageHeader *msg0 = fcls->msg[fcls->n];
   uint64_t flags0 = fcls->flags[fcls->n++];
 
   if (flags == flags0 && msg->header.size == msg0->header.size
       && 0 == memcmp (msg, msg0, ntohs (msg->header.size)))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  fragment %llu matches\n",
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  fragment %" PRIu64 " matches\n",
                 GNUNET_ntohll (msg->fragment_id));
     return GNUNET_YES;
   }
   else
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "  fragment %llu differs\n",
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "  fragment differs: expected %" PRIu64 ", got %" PRIu64 "\n",
+                GNUNET_ntohll (msg0->fragment_id),
                 GNUNET_ntohll (msg->fragment_id));
     GNUNET_assert (0);
     return GNUNET_SYSERR;
@@ -323,13 +328,12 @@ fragment_result (void *cls,
 
 
 void
-message_get_result (void *cls, int64_t result, const char *err_msg)
+message_get_latest_result (void *cls, int64_t result, const char *err_msg)
 {
   struct FragmentClosure *fcls = cls;
   op = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "message_get:\t%d\n", result);
-  GNUNET_assert (result > 0 && fcls->n && fcls->n_expected);
-
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "message_get_latest:\t%d\n", result);
+  GNUNET_assert (0 < result && fcls->n == fcls->n_expected);
 
   modifiers[0] = (struct GNUNET_ENV_Modifier) {
     .oper = '=',
@@ -351,29 +355,46 @@ message_get_result (void *cls, int64_t result, const char *err_msg)
 
 
 void
+message_get_result (void *cls, int64_t result, const char *err_msg)
+{
+  struct FragmentClosure *fcls = cls;
+  op = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "message_get:\t%d\n", result);
+  GNUNET_assert (0 < result && fcls->n == fcls->n_expected);
+
+  fcls->n = 0;
+  fcls->n_expected = 3;
+  op = GNUNET_PSYCSTORE_message_get_latest (h, &channel_pub_key, &slave_pub_key,
+                                            1, &fragment_result,
+                                            &message_get_latest_result, fcls);
+}
+
+
+void
 message_get_fragment_result (void *cls, int64_t result, const char *err_msg)
 {
   struct FragmentClosure *fcls = cls;
   op = NULL;
   GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "message_get_fragment:\t%d\n", result);
-  GNUNET_assert (result > 0 && fcls->n && fcls->n_expected);
+  GNUNET_assert (0 < result && fcls->n == fcls->n_expected);
 
   fcls->n = 0;
   fcls->n_expected = 3;
+  uint64_t message_id = GNUNET_ntohll (fcls->msg[0]->message_id);
   op = GNUNET_PSYCSTORE_message_get (h, &channel_pub_key, &slave_pub_key,
-                                     GNUNET_ntohll (fcls->msg[0]->message_id),
+                                     message_id, message_id,
                                      &fragment_result,
                                      &message_get_result, fcls);
 }
 
 
 void
-fragment_get_result (void *cls, int64_t result, const char *err_msg)
+fragment_get_latest_result (void *cls, int64_t result, const char *err_msg)
 {
   struct FragmentClosure *fcls = cls;
   op = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "fragment_get:\t%d\n", result);
-  GNUNET_assert (result > 0 && fcls->n && fcls->n_expected);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "fragment_get_latest:\t%d\n", result);
+  GNUNET_assert (0 < result && fcls->n == fcls->n_expected);
 
   fcls->n = 1;
   fcls->n_expected = 2;
@@ -381,9 +402,24 @@ fragment_get_result (void *cls, int64_t result, const char *err_msg)
                                               GNUNET_ntohll (fcls->msg[1]->message_id),
                                               GNUNET_ntohll (fcls->msg[1]->fragment_offset),
                                               &fragment_result,
-                                              &message_get_fragment_result,
-                                              fcls);
+                                              &message_get_fragment_result, fcls);
+}
+
 
+void
+fragment_get_result (void *cls, int64_t result, const char *err_msg)
+{
+  struct FragmentClosure *fcls = cls;
+  op = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "fragment_get:\t%d\n", result);
+  GNUNET_assert (0 < result && fcls->n == fcls->n_expected);
+
+  fcls->n = 0;
+  fcls->n_expected = 3;
+  op = GNUNET_PSYCSTORE_fragment_get_latest (h, &channel_pub_key,
+                                             &slave_pub_key, fcls->n_expected,
+                                             &fragment_result,
+                                             &fragment_get_latest_result, fcls);
 }
 
 
@@ -398,8 +434,9 @@ fragment_store_result (void *cls, int64_t result, const char *err_msg)
   { /* last fragment */
     fcls.n = 0;
     fcls.n_expected = 1;
+    uint64_t fragment_id = GNUNET_ntohll (fcls.msg[0]->fragment_id);
     op = GNUNET_PSYCSTORE_fragment_get (h, &channel_pub_key, &slave_pub_key,
-                                        GNUNET_ntohll (fcls.msg[0]->fragment_id),
+                                        fragment_id, fragment_id,
                                         &fragment_result,
                                         &fragment_get_result, &fcls);
   }