X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fpsycstore%2Fgnunet-service-psycstore.c;h=33e894b5ec292191c9179fe9bf571671c23bafb2;hb=3aab63d5c50db0eb784d3b65b2bd989d3458c960;hp=87a2c87ab8c3a91577c684df8c2a7b2a0bcfc90d;hpb=40884377f3126bbecbfd3243d47224b3094914f9;p=oweals%2Fgnunet.git

diff --git a/src/psycstore/gnunet-service-psycstore.c b/src/psycstore/gnunet-service-psycstore.c
index 87a2c87ab..33e894b5e 100644
--- a/src/psycstore/gnunet-service-psycstore.c
+++ b/src/psycstore/gnunet-service-psycstore.c
@@ -1,6 +1,6 @@
-/*
+/**
  * This file is part of GNUnet
- * (C) 2013 Christian Grothoff (and other contributing authors)
+ * Copyright (C) 2013 GNUnet e.V.
  *
  * GNUnet is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published
@@ -14,8 +14,8 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with GNUnet; see the file COPYING.  If not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
  */
 
 /**
@@ -32,6 +32,7 @@
 #include "gnunet_constants.h"
 #include "gnunet_protocols.h"
 #include "gnunet_statistics_service.h"
+#include "gnunet_psyc_util_lib.h"
 #include "gnunet_psycstore_service.h"
 #include "gnunet_psycstore_plugin.h"
 #include "psycstore.h"
@@ -67,10 +68,9 @@ static char *db_lib_name;
  * Task run during shutdown.
  *
  * @param cls unused
- * @param tc unused
  */
 static void
-shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls)
 {
   if (NULL != nc)
   {
@@ -105,17 +105,21 @@ 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 = 0; // FIXME: maximum length
+  size_t err_size = 0;
 
   if (NULL != err_msg)
-    err_len = strlen (err_msg) + 1;
-  res = GNUNET_malloc (sizeof (struct OperationResult) + err_len);
+    err_size = strnlen (err_msg,
+                        GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (*res) - 1) + 1;
+  res = GNUNET_malloc (sizeof (struct OperationResult) + err_size);
   res->header.type = htons (GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_CODE);
-  res->header.size = htons (sizeof (struct OperationResult) + err_len);
+  res->header.size = htons (sizeof (struct OperationResult) + err_size);
   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);
+  if (0 < err_size)
+  {
+    GNUNET_memcpy (&res[1], err_msg, err_size);
+    ((char *) &res[1])[err_size - 1] = '\0';
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 	      "Sending result to client: %" PRId64 " (%s)\n",
 	      result_code, err_msg);
@@ -197,7 +201,7 @@ send_fragment (void *cls, struct GNUNET_MULTICAST_MessageHeader *msg,
   res->header.size = htons (sizeof (struct FragmentResult) + msg_size);
   res->op_id = sc->op_id;
   res->psycstore_flags = htonl (flags);
-  memcpy (&res[1], msg, msg_size);
+  GNUNET_memcpy (&res[1], msg, msg_size);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 	      "Sending fragment %ld to client\n",
 	      GNUNET_ntohll (msg->fragment_id));
@@ -212,21 +216,21 @@ send_fragment (void *cls, struct GNUNET_MULTICAST_MessageHeader *msg,
 
 static int
 send_state_var (void *cls, const char *name,
-                const void *value, size_t value_size)
+                const void *value, uint32_t value_size)
 {
   struct SendClosure *sc = cls;
   struct StateResult *res;
   size_t name_size = strlen (name) + 1;
 
-  /* FIXME: split up value into 64k chunks */
+  /** @todo 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);
   res->op_id = sc->op_id;
   res->name_size = htons (name_size);
-  memcpy (&res[1], name, name_size);
-  memcpy ((char *) &res[1] + name_size, value, value_size);
+  GNUNET_memcpy (&res[1], name, name_size);
+  GNUNET_memcpy ((char *) &res[1] + name_size, value, value_size);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Sending state variable %s to client\n", name);
   GNUNET_SERVER_notification_context_add (nc, sc->client);
@@ -314,8 +318,10 @@ handle_fragment_get (void *cls,
   const struct FragmentGetRequest *
     req = (const struct FragmentGetRequest *) msg;
   struct SendClosure
-    sc = { .op_id = req->op_id, .client = client,
-           .channel_key = req->channel_key, .slave_key = req->slave_key,
+    sc = { .op_id = req->op_id,
+           .client = client,
+           .channel_key = req->channel_key,
+           .slave_key = req->slave_key,
            .membership_test = req->do_membership_test };
 
   int64_t ret;
@@ -327,10 +333,10 @@ handle_fragment_get (void *cls,
   if (0 == limit)
     ret = db->fragment_get (db->cls, &req->channel_key,
                             first_fragment_id, last_fragment_id,
-                            &ret_frags, &send_fragment, &sc);
+                            &ret_frags, send_fragment, &sc);
   else
-    ret = db->fragment_get_latest (db->cls, &req->channel_key, limit, 
-                                   &ret_frags, &send_fragment, &sc);
+    ret = db->fragment_get_latest (db->cls, &req->channel_key, limit,
+                                   &ret_frags, send_fragment, &sc);
 
   switch (ret)
   {
@@ -369,24 +375,43 @@ handle_message_get (void *cls,
 {
   const struct MessageGetRequest *
     req = (const struct MessageGetRequest *) msg;
+  uint16_t size = ntohs (msg->size);
+  const char *method_prefix = (const char *) &req[1];
+
+  if (size < sizeof (*req) + 1
+      || '\0' != method_prefix[size - sizeof (*req) - 1])
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Message get: invalid method prefix. size: %u < %u?\n",
+                size,
+                (unsigned int) (sizeof (*req) + 1));
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
+
   struct SendClosure
-    sc = { .op_id = req->op_id, .client = client,
-           .channel_key = req->channel_key, .slave_key = req->slave_key,
+    sc = { .op_id = req->op_id,
+           .client = client,
+           .channel_key = req->channel_key,
+           .slave_key = req->slave_key,
            .membership_test = req->do_membership_test };
 
   int64_t ret;
   uint64_t ret_frags = 0;
   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);
+  uint64_t msg_limit = GNUNET_ntohll (req->message_limit);
+  uint64_t frag_limit = GNUNET_ntohll (req->fragment_limit);
 
-  if (0 == limit)
+  /** @todo method_prefix */
+  if (0 == msg_limit)
     ret = db->message_get (db->cls, &req->channel_key,
-                           first_message_id, last_message_id,
-                           &ret_frags, &send_fragment, &sc);
+                           first_message_id, last_message_id, frag_limit,
+                           &ret_frags, send_fragment, &sc);
   else
-    ret = db->message_get_latest (db->cls, &req->channel_key, limit,
-                                  &ret_frags, &send_fragment, &sc);
+    ret = db->message_get_latest (db->cls, &req->channel_key, msg_limit,
+                                  &ret_frags, send_fragment, &sc);
 
   switch (ret)
   {
@@ -459,7 +484,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 - INT32_MIN);
+  res.result_code = htonl (ret);
   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);
@@ -474,7 +499,149 @@ handle_counters_get (void *cls,
 }
 
 
-/* FIXME: stop processing further state modify messages after an error */
+struct StateModifyClosure
+{
+  const struct GNUNET_CRYPTO_EddsaPublicKey channel_key;
+  struct GNUNET_PSYC_ReceiveHandle *recv;
+  enum GNUNET_PSYC_MessageState msg_state;
+  char mod_oper;
+  char *mod_name;
+  char *mod_value;
+  uint32_t mod_value_size;
+  uint32_t mod_value_remaining;
+};
+
+
+static void
+recv_state_message_part (void *cls,
+                         const struct GNUNET_PSYC_MessageHeader *msg,
+                         const struct GNUNET_MessageHeader *pmsg)
+{
+  struct StateModifyClosure *scls = cls;
+  uint16_t psize;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "recv_state_message_part()  message_id: %" PRIu64
+              ", fragment_offset: %" PRIu64 ", flags: %u\n",
+              GNUNET_ntohll (msg->message_id),
+              GNUNET_ntohll (msg->fragment_offset),
+              ntohl (msg->flags));
+
+  if (NULL == pmsg)
+  {
+    scls->msg_state = GNUNET_PSYC_MESSAGE_STATE_ERROR;
+    return;
+  }
+
+  switch (ntohs (pmsg->type))
+  {
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD:
+  {
+    scls->msg_state = GNUNET_PSYC_MESSAGE_STATE_METHOD;
+    break;
+  }
+
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER:
+  {
+    struct GNUNET_PSYC_MessageModifier *
+      pmod = (struct GNUNET_PSYC_MessageModifier *) pmsg;
+    psize = ntohs (pmod->header.size);
+    uint16_t name_size = ntohs (pmod->name_size);
+    uint32_t value_size = ntohl (pmod->value_size);
+
+    const char *name = (const char *) &pmod[1];
+    const void *value = name + name_size;
+
+    if (GNUNET_PSYC_OP_SET != pmod->oper)
+    { // Apply non-transient operation.
+      if (psize == sizeof (*pmod) + name_size + value_size)
+      {
+        db->state_modify_op (db->cls, &scls->channel_key,
+                             pmod->oper, name, value, value_size);
+      }
+      else
+      {
+        scls->mod_oper = pmod->oper;
+        scls->mod_name = GNUNET_malloc (name_size);
+        GNUNET_memcpy (scls->mod_name, name, name_size);
+
+        scls->mod_value_size = value_size;
+        scls->mod_value = GNUNET_malloc (scls->mod_value_size);
+        scls->mod_value_remaining
+          = scls->mod_value_size - (psize - sizeof (*pmod) - name_size);
+        GNUNET_memcpy (scls->mod_value, value, value_size - scls->mod_value_remaining);
+      }
+    }
+    scls->msg_state = GNUNET_PSYC_MESSAGE_STATE_MODIFIER;
+    break;
+  }
+
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MOD_CONT:
+    if (GNUNET_PSYC_OP_SET != scls->mod_oper)
+    {
+      if (scls->mod_value_remaining == 0)
+      {
+        GNUNET_break_op (0);
+        scls->msg_state = GNUNET_PSYC_MESSAGE_STATE_ERROR;
+      }
+      psize = ntohs (pmsg->size);
+      GNUNET_memcpy (scls->mod_value + (scls->mod_value_size - scls->mod_value_remaining),
+              &pmsg[1], psize - sizeof (*pmsg));
+      scls->mod_value_remaining -= psize - sizeof (*pmsg);
+      if (0 == scls->mod_value_remaining)
+      {
+        db->state_modify_op (db->cls, &scls->channel_key,
+                             scls->mod_oper, scls->mod_name,
+                             scls->mod_value, scls->mod_value_size);
+        GNUNET_free (scls->mod_name);
+        GNUNET_free (scls->mod_value);
+        scls->mod_oper = 0;
+        scls->mod_name = NULL;
+        scls->mod_value = NULL;
+        scls->mod_value_size = 0;
+      }
+    }
+    scls->msg_state = GNUNET_PSYC_MESSAGE_STATE_MOD_CONT;
+    break;
+
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA:
+    scls->msg_state = GNUNET_PSYC_MESSAGE_STATE_DATA;
+    break;
+
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END:
+    scls->msg_state = GNUNET_PSYC_MESSAGE_STATE_END;
+    break;
+
+  default:
+    scls->msg_state = GNUNET_PSYC_MESSAGE_STATE_ERROR;
+  }
+}
+
+
+static int
+recv_state_fragment (void *cls, struct GNUNET_MULTICAST_MessageHeader *msg,
+                     enum GNUNET_PSYCSTORE_MessageFlags flags)
+{
+  struct StateModifyClosure *scls = cls;
+
+  if (NULL == scls->recv)
+  {
+    scls->recv = GNUNET_PSYC_receive_create (NULL, recv_state_message_part,
+                                             scls);
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "recv_state_fragment: %" PRIu64 "\n", GNUNET_ntohll (msg->fragment_id));
+
+  struct GNUNET_PSYC_MessageHeader *
+    pmsg = GNUNET_PSYC_message_header_create (msg, flags);
+  GNUNET_PSYC_receive_message (scls->recv, pmsg);
+  GNUNET_free (pmsg);
+
+  return GNUNET_YES;
+}
+
+
 static void
 handle_state_modify (void *cls,
                      struct GNUNET_SERVER_Client *client,
@@ -483,71 +650,52 @@ handle_state_modify (void *cls,
   const struct StateModifyRequest *req
     = (const struct StateModifyRequest *) msg;
 
-  int ret = GNUNET_SYSERR;
-  const char *name = (const char *) &req[1];
-  uint16_t name_size = ntohs (req->name_size);
+  uint64_t message_id = GNUNET_ntohll (req->message_id);
+  uint64_t state_delta = GNUNET_ntohll (req->state_delta);
+  uint64_t ret_frags = 0;
+  struct StateModifyClosure
+    scls = { .channel_key = req->channel_key };
 
-  if (name_size <= 2 || '\0' != name[name_size - 1])
+  int ret = db->state_modify_begin (db->cls, &req->channel_key,
+                                    message_id, state_delta);
+
+  if (GNUNET_OK != ret)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Tried to set invalid state variable name!\n"));
-    GNUNET_break_op (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Failed to begin modifying state: %d\n"), ret);
   }
   else
   {
-    ret = GNUNET_OK;
-
-    if (req->flags & STATE_OP_FIRST)
-    {
-      ret = db->state_modify_begin (db->cls, &req->channel_key,
-                                    GNUNET_ntohll (req->message_id),
-                                    GNUNET_ntohll (req->state_delta));
-    }
-    if (ret != GNUNET_OK)
+    ret = db->message_get (db->cls, &req->channel_key,
+                           message_id, message_id, 0,
+                           &ret_frags, recv_state_fragment, &scls);
+    if (GNUNET_OK != ret)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to begin modifying state!\n"));
+                  _("Failed to modify state: %d\n"), ret);
+      GNUNET_break (0);
     }
     else
     {
-      switch (req->oper)
+      if (GNUNET_OK != db->state_modify_end (db->cls, &req->channel_key, message_id))
       {
-      case GNUNET_ENV_OP_ASSIGN:
-        ret = db->state_modify_set (db->cls, &req->channel_key,
-                                    (const char *) &req[1],
-                                    name + ntohs (req->name_size),
-                                    ntohs (req->header.size) - sizeof (*req)
-                                    - ntohs (req->name_size));
-        break;
-      default:
-#if TODO
-        ret = GNUNET_ENV_operation ((const char *) &req[1],
-                                    current_value, current_value_size,
-                                    req->oper, name + ntohs (req->name_size),
-                                    ntohs (req->header.size) - sizeof (*req)
-                                    - ntohs (req->name_size), &value, &value_size);
-#endif
-        ret = GNUNET_SYSERR;
         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    _("Unknown operator: %c\n"), req->oper);
+                    _("Failed to end modifying state!\n"));
+        GNUNET_break (0);
       }
     }
-
-    if (GNUNET_OK == ret && req->flags & STATE_OP_LAST)
+    if (NULL != scls.recv)
     {
-      ret = db->state_modify_end (db->cls, &req->channel_key,
-                                  GNUNET_ntohll (req->message_id));
-      if (ret != GNUNET_OK)
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    _("Failed to end modifying state!\n"));
+      GNUNET_PSYC_receive_destroy (scls.recv);
     }
   }
+
   send_result_code (client, req->op_id, ret, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
 
-/* FIXME: stop processing further state sync messages after an error */
+/** @todo FIXME: stop processing further state sync messages after an error */
 static void
 handle_state_sync (void *cls,
                    struct GNUNET_SERVER_Client *client,
@@ -581,16 +729,17 @@ handle_state_sync (void *cls,
     }
     else
     {
-      ret = db->state_sync_set (db->cls, &req->channel_key, name,
-                                name + ntohs (req->name_size),
-                                ntohs (req->header.size) - sizeof (*req)
-                                - ntohs (req->name_size));
+      ret = db->state_sync_assign (db->cls, &req->channel_key, name,
+                                   name + ntohs (req->name_size),
+                                   ntohs (req->header.size) - sizeof (*req)
+                                   - ntohs (req->name_size));
     }
 
     if (GNUNET_OK == ret && req->flags & STATE_OP_LAST)
     {
       ret = db->state_sync_end (db->cls, &req->channel_key,
-                                GNUNET_ntohll (req->message_id));
+                                GNUNET_ntohll (req->max_state_message_id),
+                                GNUNET_ntohll (req->state_hash_message_id));
       if (ret != GNUNET_OK)
         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                     _("Failed to end synchronizing state!\n"));
@@ -665,7 +814,7 @@ handle_state_get (void *cls,
     if (GNUNET_NO == ret && name_size >= 5) /* min: _a_b\0 */
     {
       char *p, *n = GNUNET_malloc (name_size);
-      memcpy (n, name, name_size);
+      GNUNET_memcpy (n, name, name_size);
       while (&n[1] < (p = strrchr (n, '_')) && GNUNET_NO == ret)
       {
         *p = '\0';
@@ -757,8 +906,7 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
       sizeof (struct FragmentGetRequest) },
 
     { &handle_message_get, NULL,
-      GNUNET_MESSAGE_TYPE_PSYCSTORE_MESSAGE_GET,
-      sizeof (struct MessageGetRequest) },
+      GNUNET_MESSAGE_TYPE_PSYCSTORE_MESSAGE_GET, 0 },
 
     { &handle_message_get_fragment, NULL,
       GNUNET_MESSAGE_TYPE_PSYCSTORE_MESSAGE_GET_FRAGMENT,
@@ -799,11 +947,15 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
       GNUNET_CONFIGURATION_get_value_string (cfg, "psycstore", "database",
                                              &database))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No database backend configured\n");
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+			       "psycstore",
+			       "database");
   }
   else
   {
-    GNUNET_asprintf (&db_lib_name, "libgnunet_plugin_psycstore_%s", database);
+    GNUNET_asprintf (&db_lib_name,
+		     "libgnunet_plugin_psycstore_%s",
+		     database);
     db = GNUNET_PLUGIN_load (db_lib_name, (void *) cfg);
     GNUNET_free (database);
   }
@@ -819,8 +971,8 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
   stats = GNUNET_STATISTICS_create ("psycstore", cfg);
   GNUNET_SERVER_add_handlers (server, handlers);
   nc = GNUNET_SERVER_notification_context_create (server, 1);
-  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
-                                NULL);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+				 NULL);
 }