src/namestore/test_plugin_namestore.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2012 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20 /*
  21  * @file namestore/test_plugin_namestore.c
  22  * @brief Test for the namestore plugins
  23  * @author Christian Grothoff
  24  */
  25 #include "platform.h"
  26 #include "gnunet_util_lib.h"
  27 #include "gnunet_namestore_plugin.h"
  28 #include "gnunet_testing_lib.h"
  29
  30
  31 #define ASSERT(x) do { if (! (x)) { printf("Error at %s:%d\n", __FILE__, __LINE__); goto FAILURE;} } while (0)
  32
  33 static int ok;
  34
  35 /**
  36  * Name of plugin under test.
  37  */
  38 static const char *plugin_name;
  39
  40
  41 /**
  42  * Function called when the service shuts down.  Unloads our namestore
  43  * plugin.
  44  *
  45  * @param api api to unload
  46  */
  47 static void
  48 unload_plugin (struct GNUNET_NAMESTORE_PluginFunctions *api)
  49 {
  50   char *libname;
  51
  52   GNUNET_asprintf (&libname, "libgnunet_plugin_namestore_%s", plugin_name);
  53   GNUNET_break (NULL == GNUNET_PLUGIN_unload (libname, api));
  54   GNUNET_free (libname);
  55 }
  56
  57
  58 /**
  59  * Load the namestore plugin.
  60  *
  61  * @param cfg configuration to pass
  62  * @return NULL on error
  63  */
  64 static struct GNUNET_NAMESTORE_PluginFunctions *
  65 load_plugin (const struct GNUNET_CONFIGURATION_Handle *cfg)
  66 {
  67   struct GNUNET_NAMESTORE_PluginFunctions *ret;
  68   char *libname;
  69
  70   GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Loading `%s' namestore plugin\n"),
  71               plugin_name);
  72   GNUNET_asprintf (&libname, "libgnunet_plugin_namestore_%s", plugin_name);
  73   if (NULL == (ret = GNUNET_PLUGIN_load (libname, (void*) cfg)))
  74   {
  75     FPRINTF (stderr, "Failed to load plugin `%s'!\n", plugin_name);
  76     return NULL;
  77   }
  78   GNUNET_free (libname);
  79   return ret;
  80 }
  81
  82
  83 static void
  84 test_record (void *cls,
  85                                                  const struct GNUNET_CRYPTO_EccPrivateKey *private_key,
  86                                                  const char *label,
  87                                                  unsigned int rd_count,
  88                                                  const struct GNUNET_NAMESTORE_RecordData *rd)
  89 {
  90   int *idp = cls;
  91   int id = *idp;
  92   struct GNUNET_CRYPTO_EccPrivateKey tzone_private_key;
  93   char tname[64];
  94   unsigned int trd_count = 1 + (id % 1024);
  95   unsigned int i;
  96
  97   GNUNET_snprintf (tname, sizeof (tname),
  98                    "a%u", (unsigned int ) id);
  99   for (i=0;i<trd_count;i++)
 100   {
 101     GNUNET_assert (rd[i].data_size == id % 10);
 102     GNUNET_assert (0 == memcmp ("Hello World", rd[i].data, id % 10));
 103     GNUNET_assert (rd[i].record_type == 1 + (id % 13));
 104     GNUNET_assert (rd[i].flags == (id  % 7));
 105   }
 106   memset (&tzone_private_key, (id % 241), sizeof (tzone_private_key));
 107   GNUNET_assert (0 == strcmp (label, tname));
 108   GNUNET_assert (0 == memcmp (&tzone_private_key, private_key, sizeof (struct GNUNET_CRYPTO_EccPrivateKey)));
 109 }
 110
 111
 112 static void
 113 get_record (struct GNUNET_NAMESTORE_PluginFunctions *nsp, int id)
 114 {
 115   GNUNET_assert (GNUNET_OK == nsp->iterate_records (nsp->cls,
 116                                             NULL, 0, &test_record, &id));
 117 }
 118
 119
 120 static void
 121 put_record (struct GNUNET_NAMESTORE_PluginFunctions *nsp, int id)
 122 {
 123   struct GNUNET_CRYPTO_EccPrivateKey zone_private_key;
 124   char label[64];
 125   unsigned int rd_count = 1 + (id % 1024);
 126   struct GNUNET_NAMESTORE_RecordData rd[rd_count];
 127   struct GNUNET_CRYPTO_EccSignature signature;
 128   unsigned int i;
 129
 130   GNUNET_snprintf (label, sizeof (label),
 131                    "a%u", (unsigned int ) id);
 132   for (i=0;i<rd_count;i++)
 133   {
 134     rd[i].data = "Hello World";
 135     rd[i].data_size = id % 10;
 136     rd[i].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES).abs_value_us;
 137     rd[i].record_type = 1 + (id % 13);
 138     rd[i].flags = (id  % 7);
 139   }
 140   memset (&zone_private_key, (id % 241), sizeof (zone_private_key));
 141   memset (&signature, (id % 243), sizeof (signature));
 142   GNUNET_assert (GNUNET_OK == nsp->store_records (nsp->cls,
 143                                                 &zone_private_key,
 144                                                 label,
 145                                                 rd_count,
 146                                                 rd));
 147 }
 148
 149
 150 static void
 151 run (void *cls, char *const *args, const char *cfgfile,
 152      const struct GNUNET_CONFIGURATION_Handle *cfg)
 153 {
 154   struct GNUNET_NAMESTORE_PluginFunctions *nsp;
 155
 156   ok = 0;
 157   nsp = load_plugin (cfg);
 158   if (NULL == nsp)
 159   {
 160     FPRINTF (stderr,
 161              "%s",
 162              "Failed to initialize namestore.  Database likely not setup, skipping test.\n");
 163     return;
 164   }
 165   put_record (nsp, 1);
 166   get_record (nsp, 1);
 167
 168   unload_plugin (nsp);
 169 }
 170
 171
 172 int
 173 main (int argc, char *argv[])
 174 {
 175   char cfg_name[128];
 176   char *const xargv[] = {
 177     "test-plugin-namestore",
 178     "-c",
 179     cfg_name,
 180     NULL
 181   };
 182   struct GNUNET_GETOPT_CommandLineOption options[] = {
 183     GNUNET_GETOPT_OPTION_END
 184   };
 185
 186   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-plugin-namestore-sqlite");
 187   GNUNET_log_setup ("test-plugin-namestore",
 188                     "WARNING",
 189                     NULL);
 190   plugin_name = GNUNET_TESTING_get_testname_from_underscore (argv[0]);
 191   GNUNET_snprintf (cfg_name, sizeof (cfg_name), "test_plugin_namestore_%s.conf",
 192                    plugin_name);
 193   GNUNET_PROGRAM_run ((sizeof (xargv) / sizeof (char *)) - 1, xargv,
 194                       "test-plugin-namestore", "nohelp", options, &run, NULL);
 195   if (ok != 0)
 196     FPRINTF (stderr, "Missed some testcases: %d\n", ok);
 197   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-plugin-namestore-sqlite");
 198   return ok;
 199 }
 200
 201 /* end of test_plugin_namestore.c */