X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fdht%2Fgnunet-dht-put.c;h=64764cb65d7e2c58406d7478190f0b618e8cf056;hb=68aa80774490e7f626bd4e34ca9ecda7fbbf9607;hp=4d25847fb86374155086d58cfe4bfb8e7bac4c33;hpb=e4de5bb96aa6560bbd85ebca896e7cb36d426ad5;p=oweals%2Fgnunet.git

diff --git a/src/dht/gnunet-dht-put.c b/src/dht/gnunet-dht-put.c
index 4d25847fb..64764cb65 100644
--- a/src/dht/gnunet-dht-put.c
+++ b/src/dht/gnunet-dht-put.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
-     (C) 2001, 2002, 2004, 2005, 2006, 2007, 2009 Christian Grothoff (and other contributing authors)
+     Copyright (C) 2001, 2002, 2004, 2005, 2006, 2007, 2009 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
-     by the Free Software Foundation; either version 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -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.
 */
 /**
  * @file dht/gnunet-dht-put.c
@@ -31,20 +31,25 @@
  */
 static unsigned int query_type;
 
+/**
+ * The key used in the DHT
+ */
+struct GNUNET_HashCode key;
+
 /**
  * The key for the query
  */
 static char *query_key;
 
 /**
- * User supplied timeout value
+ * User supplied expiration value
  */
-static unsigned long long timeout_request = 5;
+static struct GNUNET_TIME_Relative expiration;
 
 /**
- * User supplied expiration value
+ * Desired replication level.
  */
-static unsigned long long expiration_seconds = 3600;
+static unsigned int replication = 5;
 
 /**
  * Be verbose
@@ -52,14 +57,20 @@ static unsigned long long expiration_seconds = 3600;
 static int verbose;
 
 /**
- * Handle to the DHT
+ * Use #GNUNET_DHT_DEMULTIPLEX_EVERYWHERE.
  */
-static struct GNUNET_DHT_Handle *dht_handle;
+static int demultixplex_everywhere;
 
 /**
- * Global handle of the scheduler
+ * Use #GNUNET_DHT_RO_RECORD_ROUTE.
  */
-static struct GNUNET_SCHEDULER_Handle *sched;
+static int record_route;
+
+/**
+ * Handle to the DHT
+ */
+static struct GNUNET_DHT_Handle *dht_handle;
+
 
 /**
  * Global handle of the configuration
@@ -76,98 +87,109 @@ static int ret;
  */
 static char *data;
 
+
 static void
-shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls)
 {
-
-  if (dht_handle != NULL)
+  if (NULL != dht_handle)
+  {
     GNUNET_DHT_disconnect (dht_handle);
-
-  dht_handle = NULL;
+    dht_handle = NULL;
+  }
 }
 
+
 /**
  * Signature of the main function of a task.
  *
  * @param cls closure
- * @param tc context information (why was this task triggered now)
+ * @param success #GNUNET_OK if the PUT was transmitted,
+ *                #GNUNET_NO on timeout,
+ *                #GNUNET_SYSERR on disconnect from service
+ *                after the PUT message was transmitted
+ *                (so we don't know if it was received or not)
  */
-void
-message_sent_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+message_sent_cont (void *cls, int success)
 {
-  if (tc->reason == GNUNET_SCHEDULER_REASON_TIMEOUT)
-    {
-      if (verbose)
-        fprintf (stderr,
-                 "Failed to send put request to service, quitting.\n");
-      ret = 1;
-    }
-  else
+  if (verbose)
+  {
+    switch (success)
     {
-      if (verbose)
-        fprintf (stderr, "PUT request sent!\n");
+    case GNUNET_OK:
+      FPRINTF (stderr, "%s `%s'!\n",  _("PUT request sent with key"), GNUNET_h2s_full(&key));
+      break;
+    case GNUNET_NO:
+      FPRINTF (stderr, "%s",  _("Timeout sending PUT request!\n"));
+      break;
+    case GNUNET_SYSERR:
+      FPRINTF (stderr, "%s",  _("PUT request not confirmed!\n"));
+      break;
+    default:
+      GNUNET_break (0);
+      break;
     }
-
-  GNUNET_SCHEDULER_add_now (sched, &shutdown_task, NULL);
+  }
+  GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
 }
 
+
 /**
  * Main function that will be run by the scheduler.
  *
  * @param cls closure
- * @param s the scheduler to use
  * @param args remaining command-line arguments
  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
  * @param c configuration
  */
 static void
 run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *s,
      char *const *args,
-     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
 {
-  struct GNUNET_TIME_Relative timeout;
   struct GNUNET_TIME_Absolute expiration;
-  GNUNET_HashCode key;
-  sched = s;
-  cfg = c;
-
-  if ((query_key == NULL) || (data == NULL))
-    {
-      if (verbose)
-        fprintf (stderr, "Must provide KEY and DATA for DHT put!\n");
-      ret = 1;
-      return;
-    }
-
-  dht_handle = GNUNET_DHT_connect (sched, cfg, 1);
+  enum GNUNET_DHT_RouteOption ro;
 
-  if (dht_handle == NULL)
-    {
-      if (verbose)
-        fprintf (stderr, "Couldn't connect to DHT service!\n");
-      ret = 1;
-      return;
-    }
-  else if (verbose)
-    fprintf (stderr, "Connected to DHT service!\n");
+  cfg = c;
+  if ((NULL == query_key) || (NULL == data))
+  {
+    FPRINTF (stderr, "%s",  _("Must provide KEY and DATA for DHT put!\n"));
+    ret = 1;
+    return;
+  }
+
+  if (NULL == (dht_handle = GNUNET_DHT_connect (cfg, 1)))
+  {
+    FPRINTF (stderr, _("Could not connect to %s service!\n"), "DHT");
+    ret = 1;
+    return;
+  }
+  if (GNUNET_BLOCK_TYPE_ANY == query_type)      /* Type of data not set */
+    query_type = GNUNET_BLOCK_TYPE_TEST;
 
   GNUNET_CRYPTO_hash (query_key, strlen (query_key), &key);
 
-  timeout =
-    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, timeout_request);
-  expiration =
-    GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_multiply
-                                      (GNUNET_TIME_UNIT_SECONDS,
-                                       expiration_seconds));
-
   if (verbose)
-    fprintf (stderr, "Issuing put request for `%s' with data `%s'!\n",
-             query_key, data);
-
-  GNUNET_DHT_put (dht_handle, &key, query_type, strlen (data), data,
-                  expiration, timeout, &message_sent_cont, NULL);
-
+    FPRINTF (stderr,
+             _("Issuing put request for `%s' with data `%s'!\n"),
+             query_key,
+             data);
+  ro = GNUNET_DHT_RO_NONE;
+  if (demultixplex_everywhere)
+    ro |= GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE;
+  if (record_route)
+    ro |= GNUNET_DHT_RO_RECORD_ROUTE;
+  GNUNET_DHT_put (dht_handle,
+                  &key,
+                  replication,
+                  ro,
+                  query_type,
+                  strlen (data),
+                  data,
+                  expiration,
+                  &message_sent_cont,
+                  NULL);
 }
 
 
@@ -175,21 +197,27 @@ run (void *cls,
  * gnunet-dht-put command line options
  */
 static struct GNUNET_GETOPT_CommandLineOption options[] = {
-  {'k', "key", "KEY",
-   gettext_noop ("the query key"),
-   1, &GNUNET_GETOPT_set_string, &query_key},
   {'d', "data", "DATA",
    gettext_noop ("the data to insert under the key"),
    1, &GNUNET_GETOPT_set_string, &data},
-  {'t', "type", "TYPE",
-   gettext_noop ("the type to insert data as"),
-   0, &GNUNET_GETOPT_set_uint, &query_type},
-  {'T', "timeout", "TIMEOUT",
-   gettext_noop ("how long to execute this query before giving up?"),
-   0, &GNUNET_GETOPT_set_ulong, &timeout_request},
   {'e', "expiration", "EXPIRATION",
    gettext_noop ("how long to store this entry in the dht (in seconds)"),
-   0, &GNUNET_GETOPT_set_ulong, &expiration_seconds},
+   1, &GNUNET_GETOPT_set_relative_time, &expiration},
+  {'k', "key", "KEY",
+   gettext_noop ("the query key"),
+   1, &GNUNET_GETOPT_set_string, &query_key},
+  {'x', "demultiplex", NULL,
+   gettext_noop ("use DHT's demultiplex everywhere option"),
+   0, &GNUNET_GETOPT_set_one, &demultixplex_everywhere},
+  {'r', "replication", "LEVEL",
+   gettext_noop ("how many replicas to create"),
+   1, &GNUNET_GETOPT_set_uint, &replication},
+  {'R', "record", NULL,
+   gettext_noop ("use DHT's record route option"),
+   0, &GNUNET_GETOPT_set_one, &record_route},
+  {'t', "type", "TYPE",
+   gettext_noop ("the type to insert data as"),
+   1, &GNUNET_GETOPT_set_uint, &query_type},
   {'V', "verbose", NULL,
    gettext_noop ("be verbose (print progress information)"),
    0, &GNUNET_GETOPT_set_one, &verbose},
@@ -207,11 +235,20 @@ static struct GNUNET_GETOPT_CommandLineOption options[] = {
 int
 main (int argc, char *const *argv)
 {
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv,
+                                                 &argc, &argv))
+    return 2;
+  expiration = GNUNET_TIME_UNIT_HOURS;
   return (GNUNET_OK ==
           GNUNET_PROGRAM_run (argc,
                               argv,
                               "gnunet-dht-put",
                               gettext_noop
                               ("Issue a PUT request to the GNUnet DHT insert DATA under KEY."),
-                              options, &run, NULL)) ? ret : 1;
+                              options,
+                              &run,
+                              NULL))
+    ? ret : 1;
 }
+
+/* end of gnunet-dht-put.c */