src/regex/gnunet-daemon-regexprofiler.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2012, 2013 Christian Grothoff
   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 /**
  22  * @file regex/gnunet-daemon-regexprofiler.c
  23  * @brief daemon that uses mesh to announce a regular expression. Used in
  24  * conjunction with gnunet-regex-profiler to announce regexes on serveral peers
  25  * without the need to explicitly connect to the mesh service running on the
  26  * peer from within the profiler.
  27  * @author Maximilian Szengel
  28  * @author Bartlomiej Polot
  29  */
  30 #include "platform.h"
  31 #include "gnunet_util_lib.h"
  32 #include "gnunet_regex_lib.h"
  33 #include "gnunet_dht_service.h"
  34 #include "gnunet_statistics_service.h"
  35
  36 /**
  37  * Return value from 'main'.
  38  */
  39 static int global_ret;
  40
  41 /**
  42  * Configuration we use.
  43  */
  44 static const struct GNUNET_CONFIGURATION_Handle *cfg;
  45
  46 /**
  47  * Handle to the statistics service.
  48  */
  49 static struct GNUNET_STATISTICS_Handle *stats_handle;
  50
  51 /**
  52  * Peer's dht handle.
  53  */
  54 static struct GNUNET_DHT_Handle *dht_handle;
  55
  56 /**
  57  * Peer's regex announce handle.
  58  */
  59 static struct GNUNET_REGEX_announce_handle *announce_handle;
  60
  61 /**
  62  * Periodically reannounce regex.
  63  */
  64 static GNUNET_SCHEDULER_TaskIdentifier reannounce_task;
  65
  66 /**
  67  * How often reannounce regex.
  68  */
  69 static struct GNUNET_TIME_Relative reannounce_freq;
  70
  71 /**
  72  * Maximal path compression length for regex announcing.
  73  */
  74 static unsigned long long max_path_compression;
  75
  76 /**
  77  * Name of the file containing policies that this peer should announce. One
  78  * policy per line.
  79  */
  80 static char * policy_filename;
  81
  82 /**
  83  * Prefix to add before every regex we're announcing.
  84  */
  85 static char * regex_prefix;
  86
  87 /**
  88  * Regex with prefix.
  89  */
  90 static char *rx_with_pfx;
  91
  92
  93 /**
  94  * Task run during shutdown.
  95  *
  96  * @param cls unused
  97  * @param tc unused
  98  */
  99 static void
 100 shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 101 {
 102   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "shutting down\n");
 103
 104   if (NULL != announce_handle)
 105   {
 106     GNUNET_REGEX_announce_cancel (announce_handle);
 107     announce_handle = NULL;
 108   }
 109
 110   if (NULL != dht_handle)
 111   {
 112     GNUNET_DHT_disconnect (dht_handle);
 113     dht_handle = NULL;
 114   }
 115
 116   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "shut down\n");
 117 }
 118
 119
 120 /**
 121  * Announce a previously announced regex re-using cached data.
 122  *
 123  * @param cls Closure (regex to announce if needed).
 124  * @param tc TaskContext.
 125  */
 126 static void
 127 reannounce_regex (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 128 {
 129   struct GNUNET_PeerIdentity id;
 130   struct GNUNET_TIME_Relative random_delay;
 131   char *regex = cls;
 132
 133   reannounce_task = GNUNET_SCHEDULER_NO_TASK;
 134   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
 135   {
 136     GNUNET_free (regex);
 137     return;
 138   }
 139
 140   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Announcing regex: %s\n", regex);
 141   GNUNET_STATISTICS_update (stats_handle, "# regexes announced", 1, GNUNET_NO);
 142   if (NULL == announce_handle && NULL != regex)
 143   {
 144     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 145                 "First time, creating regex: %s\n",
 146                 regex);
 147     memset (&id, 0, sizeof (struct GNUNET_PeerIdentity));
 148     announce_handle = GNUNET_REGEX_announce (dht_handle,
 149                                             &id,
 150                                             regex,
 151                                             (unsigned int) max_path_compression,
 152                                             stats_handle);
 153   }
 154   else
 155   {
 156     GNUNET_assert (NULL != announce_handle);
 157     GNUNET_REGEX_reannounce (announce_handle);
 158   }
 159
 160   random_delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
 161                                                 GNUNET_CRYPTO_random_u32 (
 162                                                   GNUNET_CRYPTO_QUALITY_WEAK,
 163                                                   600));
 164   reannounce_task =
 165     GNUNET_SCHEDULER_add_delayed (
 166       GNUNET_TIME_relative_add (reannounce_freq, random_delay),
 167       &reannounce_regex,
 168       cls);
 169 }
 170
 171
 172 /**
 173  * Announce the given regular expression using regex and the path compression
 174  * length read from config.
 175  *
 176  * @param regex regular expression to announce on this peer's mesh.
 177  */
 178 static void
 179 announce_regex (const char * regex)
 180 {
 181   char *copy;
 182
 183   if (NULL == regex || 0 == strlen (regex))
 184   {
 185     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot announce empty regex\n");
 186     return;
 187   }
 188
 189   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == reannounce_task);
 190   copy = GNUNET_strdup (regex);
 191   reannounce_task = GNUNET_SCHEDULER_add_now (reannounce_regex, (void *) copy);
 192 }
 193
 194
 195 /**
 196  * Load regular expressions from filename into 'rxes' array. Array needs to be freed.
 197  *
 198  * @param filename filename of the file containing the regexes, one per line.
 199  * @param rx string with the union of all regular expressions.
 200  *
 201  * @return number of regular expressions read from filename and in rxes array.
 202  * FIXME use load regex lib function
 203  */
 204 static unsigned int
 205 load_regexes (const char *filename, char **rx)
 206 {
 207   char *data;
 208   char *buf;
 209   uint64_t filesize;
 210   unsigned int offset;
 211   unsigned int rx_cnt;
 212
 213   if (GNUNET_YES != GNUNET_DISK_file_test (policy_filename))
 214   {
 215     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 216                 "Could not find policy file %s\n", policy_filename);
 217     return 0;
 218   }
 219   if (GNUNET_OK != GNUNET_DISK_file_size (policy_filename, &filesize, GNUNET_YES, GNUNET_YES))
 220     filesize = 0;
 221   if (0 == filesize)
 222   {
 223     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Policy file %s is empty.\n", policy_filename);
 224     return 0;
 225   }
 226   data = GNUNET_malloc (filesize);
 227   if (filesize != GNUNET_DISK_fn_read (policy_filename, data, filesize))
 228   {
 229     GNUNET_free (data);
 230     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not read policy file %s.\n",
 231                 policy_filename);
 232     return 0;
 233   }
 234   buf = data;
 235   offset = 0;
 236   rx_cnt = 0;
 237   while (offset < (filesize - 1))
 238   {
 239     offset++;
 240     if ((data[offset] == '\n') && (buf != &data[offset]))
 241     {
 242       data[offset] = '|';
 243       buf = &data[offset + 1];
 244       rx_cnt++;
 245     }
 246     else if ((data[offset] == '\n') || (data[offset] == '\0'))
 247       buf = &data[offset + 1];
 248   }
 249   data[offset] = '\0';
 250   *rx = data;
 251
 252   return rx_cnt;
 253 }
 254
 255
 256 /**
 257  * @brief Main function that will be run by the scheduler.
 258  *
 259  * @param cls closure
 260  * @param args remaining command-line arguments
 261  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 262  * @param cfg_ configuration
 263  */
 264 static void
 265 run (void *cls, char *const *args GNUNET_UNUSED,
 266      const char *cfgfile GNUNET_UNUSED,
 267      const struct GNUNET_CONFIGURATION_Handle *cfg_)
 268 {
 269   char *regex = NULL;
 270
 271   cfg = cfg_;
 272
 273   if (GNUNET_OK !=
 274       GNUNET_CONFIGURATION_get_value_number (cfg, "REGEXPROFILER", "MAX_PATH_COMPRESSION",
 275                                              &max_path_compression))
 276   {
 277     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 278                 _
 279                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
 280                 "regexprofiler", "max_path_compression");
 281     global_ret = GNUNET_SYSERR;
 282     GNUNET_SCHEDULER_shutdown ();
 283     return;
 284   }
 285
 286   if (GNUNET_OK !=
 287       GNUNET_CONFIGURATION_get_value_filename (cfg, "REGEXPROFILER",
 288                                                "POLICY_FILE", &policy_filename))
 289   {
 290     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 291                 _
 292                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
 293                 "regexprofiler", "policy_file");
 294     global_ret = GNUNET_SYSERR;
 295     GNUNET_SCHEDULER_shutdown ();
 296     return;
 297   }
 298
 299   if (GNUNET_OK !=
 300       GNUNET_CONFIGURATION_get_value_string (cfg, "REGEXPROFILER",
 301                                              "REGEX_PREFIX", &regex_prefix))
 302   {
 303     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 304                 _
 305                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
 306                 "regexprofiler", "regex_prefix");
 307     global_ret = GNUNET_SYSERR;
 308     GNUNET_SCHEDULER_shutdown ();
 309     return;
 310   }
 311
 312   if (GNUNET_OK !=
 313       GNUNET_CONFIGURATION_get_value_time (cfg, "REGEXPROFILER",
 314                                            "REANNOUNCE_FREQ", &reannounce_freq))
 315   {
 316     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 317                 "reannounce_freq not given. Using 10 minutes.\n");
 318     reannounce_freq =
 319       GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 10);
 320
 321   }
 322
 323   stats_handle = GNUNET_STATISTICS_create ("regexprofiler", cfg);
 324
 325   dht_handle = GNUNET_DHT_connect (cfg, 1);
 326
 327   if (NULL == dht_handle)
 328   {
 329     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 330                 "Could not acquire dht handle. Exiting.\n");
 331     global_ret = GNUNET_SYSERR;
 332     GNUNET_SCHEDULER_shutdown ();
 333     return;
 334   }
 335
 336   /* Read regexes from policy files */
 337   if (0 == load_regexes (policy_filename, &regex))
 338   {
 339     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 340                 "Policy file %s contains no policies. Exiting.\n",
 341                 policy_filename);
 342     global_ret = GNUNET_SYSERR;
 343     GNUNET_SCHEDULER_shutdown ();
 344     return;
 345   }
 346
 347   /* Announcing regexes from policy_filename */
 348   GNUNET_asprintf (&rx_with_pfx, "%s(%s)", regex_prefix, regex);
 349   announce_regex (rx_with_pfx);
 350   GNUNET_free (regex);
 351   GNUNET_free (rx_with_pfx);
 352
 353   /* Scheduled the task to clean up when shutdown is called */
 354   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
 355                                 NULL);
 356 }
 357
 358
 359 /**
 360  * The main function of the regexprofiler service.
 361  *
 362  * @param argc number of arguments from the command line
 363  * @param argv command line arguments
 364  * @return 0 ok, 1 on error
 365  */
 366 int
 367 main (int argc, char *const *argv)
 368 {
 369   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 370     GNUNET_GETOPT_OPTION_END
 371   };
 372
 373   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
 374     return 2;
 375   return (GNUNET_OK ==
 376           GNUNET_PROGRAM_run (argc, argv, "regexprofiler",
 377                               gettext_noop
 378                               ("Daemon to announce regular expressions for the peer using mesh."),
 379                               options, &run, NULL)) ? global_ret : 1;
 380 }
 381
 382
 383 #ifdef LINUX
 384 #include <malloc.h>
 385
 386 /**
 387  * MINIMIZE heap size (way below 128k) since this process doesn't need much.
 388  */
 389 void __attribute__ ((constructor)) GNUNET_ARM_memory_init ()
 390 {
 391   mallopt (M_TRIM_THRESHOLD, 4 * 1024);
 392   mallopt (M_TOP_PAD, 1 * 1024);
 393   malloc_trim (0);
 394 }
 395 #endif
 396
 397
 398 /* end of gnunet-daemon-regexprofiler.c */