src/hostlist/test_gnunet_daemon_hostlist_learning.c

   1 /*
   2      This file is part of GNUnet
   3      Copyright (C) 2009, 2010, 2011, 2012, 2016 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your 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      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19 */
  20 /**
  21  * @file hostlist/test_gnunet_daemon_hostlist_learning.c
  22  * @brief test for gnunet_daemon_hostslist.c
  23  * @author Christian Grothoff
  24  */
  25 #include "platform.h"
  26 #include "gnunet_util_lib.h"
  27 #include "gnunet_arm_service.h"
  28 #include "gnunet_core_service.h"
  29 #include "gnunet_transport_service.h"
  30 #include "gnunet_resolver_service.h"
  31 #include "gnunet_statistics_service.h"
  32
  33 #define MAX_URL_LEN 1000
  34
  35 /**
  36  * How long until wait until testcases fails
  37  */
  38 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 180)
  39
  40 #define CHECK_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
  41
  42
  43 struct PeerContext
  44 {
  45   struct GNUNET_CONFIGURATION_Handle *cfg;
  46   struct GNUNET_MessageHeader *hello;
  47   struct GNUNET_CORE_Handle *core;
  48   struct GNUNET_STATISTICS_Handle *stats;
  49   struct GNUNET_OS_Process *arm_proc;
  50 };
  51
  52 static int timeout;
  53
  54 static int adv_sent;
  55
  56 static int adv_arrived;
  57
  58 static int learned_hostlist_saved;
  59
  60 static int learned_hostlist_downloaded;
  61
  62 static char *current_adv_uri;
  63
  64 static const struct GNUNET_CONFIGURATION_Handle *cfg;
  65
  66 static struct GNUNET_SCHEDULER_Task *timeout_task;
  67
  68 static struct GNUNET_SCHEDULER_Task *check_task;
  69
  70 static struct PeerContext adv_peer;
  71
  72 static struct PeerContext learn_peer;
  73
  74 static struct GNUNET_STATISTICS_GetHandle *download_stats;
  75
  76 static struct GNUNET_STATISTICS_GetHandle *urisrecv_stat;
  77
  78 static struct GNUNET_STATISTICS_GetHandle *advsent_stat;
  79
  80
  81 static void
  82 shutdown_testcase ()
  83 {
  84   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
  85               "Shutdown testcase....\n");
  86   if (NULL != timeout_task)
  87   {
  88     GNUNET_SCHEDULER_cancel (timeout_task);
  89     timeout_task = NULL;
  90   }
  91   if (NULL != download_stats)
  92   {
  93     GNUNET_STATISTICS_get_cancel (download_stats);
  94     download_stats = NULL;
  95   }
  96   if (NULL != urisrecv_stat)
  97   {
  98     GNUNET_STATISTICS_get_cancel (urisrecv_stat);
  99     urisrecv_stat = NULL;
 100   }
 101   if (NULL != advsent_stat)
 102   {
 103     GNUNET_STATISTICS_get_cancel (advsent_stat);
 104     advsent_stat = NULL;
 105   }
 106   if (NULL != adv_peer.stats)
 107   {
 108     GNUNET_STATISTICS_destroy (adv_peer.stats, GNUNET_NO);
 109     adv_peer.stats = NULL;
 110   }
 111   if (NULL != learn_peer.stats)
 112   {
 113     GNUNET_STATISTICS_destroy (learn_peer.stats, GNUNET_NO);
 114     learn_peer.stats = NULL;
 115   }
 116   if (NULL != check_task)
 117   {
 118     GNUNET_SCHEDULER_cancel (check_task);
 119     check_task = NULL;
 120   }
 121   if (NULL != current_adv_uri)
 122   {
 123     GNUNET_free (current_adv_uri);
 124     current_adv_uri = NULL;
 125   }
 126   if (NULL != adv_peer.core)
 127   {
 128     GNUNET_CORE_disconnect (adv_peer.core);
 129     adv_peer.core = NULL;
 130   }
 131   if (NULL != learn_peer.core)
 132   {
 133     GNUNET_CORE_disconnect (learn_peer.core);
 134     learn_peer.core = NULL;
 135   }
 136   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 137               "Killing hostlist server ARM process.\n");
 138   if (0 != GNUNET_OS_process_kill (adv_peer.arm_proc,
 139                                    GNUNET_TERM_SIG))
 140     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
 141                          "kill");
 142   if (GNUNET_OK !=
 143       GNUNET_OS_process_wait (adv_peer.arm_proc))
 144     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
 145                          "waitpid");
 146   GNUNET_OS_process_destroy (adv_peer.arm_proc);
 147   adv_peer.arm_proc = NULL;
 148   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 149               "Killing hostlist client ARM process.\n");
 150   if (0 != GNUNET_OS_process_kill (learn_peer.arm_proc,
 151                                    GNUNET_TERM_SIG))
 152     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
 153                          "kill");
 154   if (GNUNET_OK !=
 155       GNUNET_OS_process_wait (learn_peer.arm_proc))
 156     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
 157                          "waitpid");
 158   GNUNET_OS_process_destroy (learn_peer.arm_proc);
 159   learn_peer.arm_proc = NULL;
 160   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 161               "Shutdown complete....\n");
 162 }
 163
 164
 165 /**
 166  * Timeout, give up.
 167  */
 168 static void
 169 timeout_error (void *cls)
 170 {
 171   timeout_task = NULL;
 172   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 173               "Timeout while executing testcase, test failed.\n");
 174   timeout = GNUNET_YES;
 175   shutdown_testcase ();
 176 }
 177
 178
 179 static void
 180 process_downloads_done (void *cls, int success)
 181 {
 182   download_stats = NULL;
 183 }
 184
 185
 186 static void
 187 do_shutdown (void *cls)
 188 {
 189   shutdown_testcase ();
 190 }
 191
 192
 193 static int
 194 process_downloads (void *cls,
 195                    const char *subsystem,
 196                    const char *name,
 197                    uint64_t value,
 198                    int is_persistent)
 199 {
 200   if ( (value >= 2) &&
 201        (GNUNET_NO == learned_hostlist_downloaded) )
 202   {
 203     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 204                 "Peer has successfully downloaded advertised URI\n");
 205     learned_hostlist_downloaded = GNUNET_YES;
 206     if ((learned_hostlist_saved == GNUNET_YES) && (adv_sent == GNUNET_YES))
 207     {
 208       GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
 209     }
 210   }
 211   return GNUNET_OK;
 212 }
 213
 214
 215 static void
 216 process_uris_recv_done (void *cls, int success)
 217 {
 218   urisrecv_stat = NULL;
 219 }
 220
 221
 222 static int
 223 process_uris_recv (void *cls,
 224                    const char *subsystem,
 225                    const char *name,
 226                    uint64_t value,
 227                    int is_persistent)
 228 {
 229   struct PeerContext *pc = cls;
 230   if ( (pc == &learn_peer) &&
 231        (value == 1) &&
 232        (learned_hostlist_saved == GNUNET_NO) )
 233   {
 234     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 235                 "Peer has successfully saved advertised URI\n");
 236     learned_hostlist_saved = GNUNET_YES;
 237     if ( (learned_hostlist_downloaded == GNUNET_YES) &&
 238          (adv_sent == GNUNET_YES) )
 239     {
 240       GNUNET_SCHEDULER_add_now (&do_shutdown,
 241                                 NULL);
 242     }
 243   }
 244   return GNUNET_OK;
 245 }
 246
 247
 248 static void
 249 process_adv_sent_done (void *cls, int success)
 250 {
 251   advsent_stat = NULL;
 252 }
 253
 254
 255 static int
 256 process_adv_sent (void *cls,
 257                   const char *subsystem,
 258                   const char *name,
 259                   uint64_t value,
 260                   int is_persistent)
 261 {
 262   if ((value >= 1) && (adv_sent == GNUNET_NO))
 263   {
 264     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 265                 "Server has successfully sent advertisement\n");
 266     adv_sent = GNUNET_YES;
 267     if ((learned_hostlist_downloaded == GNUNET_YES) &&
 268         (learned_hostlist_saved == GNUNET_YES))
 269     {
 270       GNUNET_SCHEDULER_add_now (&do_shutdown,
 271                                 NULL);
 272     }
 273   }
 274   return GNUNET_OK;
 275 }
 276
 277
 278 /**
 279  * Check the server statistics regularly
 280  */
 281 static void
 282 check_statistics (void *cls)
 283 {
 284   char *stat;
 285
 286   check_task = NULL;
 287   GNUNET_asprintf (&stat,
 288                    gettext_noop ("# advertised URI `%s' downloaded"),
 289                    current_adv_uri);
 290   if (NULL != learn_peer.stats)
 291   {
 292     if (NULL != download_stats)
 293       GNUNET_STATISTICS_get_cancel (download_stats);
 294     download_stats =
 295         GNUNET_STATISTICS_get (learn_peer.stats,
 296                                "hostlist",
 297                                stat,
 298                                &process_downloads_done,
 299                                &process_downloads,
 300                                &learn_peer);
 301     if (NULL != urisrecv_stat)
 302       GNUNET_STATISTICS_get_cancel (urisrecv_stat);
 303     urisrecv_stat =
 304         GNUNET_STATISTICS_get (learn_peer.stats, "hostlist",
 305                                gettext_noop ("# advertised hostlist URIs"),
 306                                &process_uris_recv_done, &process_uris_recv,
 307                                &learn_peer);
 308   }
 309   GNUNET_free (stat);
 310   if (NULL != adv_peer.stats)
 311   {
 312     if (NULL != advsent_stat)
 313       GNUNET_STATISTICS_get_cancel (advsent_stat);
 314     advsent_stat =
 315         GNUNET_STATISTICS_get (adv_peer.stats, "hostlist",
 316                                gettext_noop ("# hostlist advertisements send"),
 317                                &process_adv_sent_done,
 318                                &process_adv_sent,
 319                                NULL);
 320   }
 321   check_task =
 322       GNUNET_SCHEDULER_add_delayed (CHECK_INTERVAL,
 323                                     &check_statistics,
 324                                     NULL);
 325 }
 326
 327
 328 static int
 329 check_ad_arrive (void *cls,
 330                  const struct GNUNET_MessageHeader *message)
 331 {
 332   const char *end = (const char *) &message[1];
 333   if ('\0' != end[ntohs (message->size) - sizeof (struct GNUNET_MessageHeader) - 1])
 334   {
 335     GNUNET_break (0);
 336     return GNUNET_SYSERR;
 337   }
 338   return GNUNET_OK;
 339 }
 340
 341
 342 static void
 343 handle_ad_arrive (void *cls,
 344                    const struct GNUNET_MessageHeader *message)
 345 {
 346   char *hostname;
 347   char *expected_uri;
 348   unsigned long long port;
 349   const char *end;
 350
 351   if (GNUNET_SYSERR ==
 352       GNUNET_CONFIGURATION_get_value_number (adv_peer.cfg,
 353                                              "HOSTLIST",
 354                                              "HTTPPORT",
 355                                              &port))
 356   {
 357     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 358                 "Could not read advertising server's configuration\n");
 359     return;
 360   }
 361
 362   if (GNUNET_SYSERR ==
 363       GNUNET_CONFIGURATION_get_value_string (adv_peer.cfg,
 364                                              "HOSTLIST",
 365                                              "EXTERNAL_DNS_NAME",
 366                                              &hostname))
 367     hostname = GNUNET_RESOLVER_local_fqdn_get ();
 368   GNUNET_asprintf (&expected_uri,
 369                    "http://%s:%u/",
 370                    hostname != NULL ? hostname : "localhost",
 371                    (unsigned int) port);
 372   end = (const char *) &message[1];
 373   current_adv_uri = GNUNET_strdup (end);
 374   if (0 == strcmp (expected_uri,
 375                    current_adv_uri))
 376   {
 377     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 378                 "Received hostlist advertisement with URI `%s' as expected\n",
 379                 current_adv_uri);
 380     adv_arrived = GNUNET_YES;
 381     adv_sent = GNUNET_YES;
 382   }
 383   else
 384     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 385                 "Expected URI `%s' and received URI `%s' differ\n",
 386                 expected_uri,
 387                 current_adv_uri);
 388   GNUNET_free (expected_uri);
 389   GNUNET_free_non_null (hostname);
 390 }
 391
 392
 393 static void
 394 setup_learn_peer (struct PeerContext *p,
 395                   const char *cfgname)
 396 {
 397   struct GNUNET_MQ_MessageHandler learn_handlers[] = {
 398     GNUNET_MQ_hd_var_size (ad_arrive,
 399                            GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT,
 400                            struct GNUNET_MessageHeader,
 401                            NULL),
 402     GNUNET_MQ_handler_end ()
 403   };
 404   char *filename;
 405   unsigned int result;
 406   char *binary;
 407
 408   binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");
 409   p->cfg = GNUNET_CONFIGURATION_create ();
 410   p->arm_proc =
 411     GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
 412                              NULL, NULL, NULL,
 413                              binary,
 414                              "gnunet-service-arm",
 415                              "-c", cfgname, NULL);
 416   GNUNET_assert (GNUNET_OK ==
 417                  GNUNET_CONFIGURATION_load (p->cfg,
 418                                             cfgname));
 419   if (GNUNET_OK ==
 420       GNUNET_CONFIGURATION_get_value_string (p->cfg,
 421                                              "HOSTLIST",
 422                                              "HOSTLISTFILE",
 423                                              &filename))
 424   {
 425     if (GNUNET_YES == GNUNET_DISK_file_test (filename))
 426     {
 427       result = UNLINK (filename);
 428       if (result == 0)
 429         GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 430                     _("Hostlist file `%s' was removed\n"),
 431                     filename);
 432     }
 433     GNUNET_free (filename);
 434   }
 435   p->core = GNUNET_CORE_connect (p->cfg,
 436                                  NULL,
 437                                  NULL,
 438                                  NULL,
 439                                  NULL,
 440                                  learn_handlers);
 441   GNUNET_assert (NULL != p->core);
 442   p->stats = GNUNET_STATISTICS_create ("hostlist",
 443                                        p->cfg);
 444   GNUNET_assert (NULL != p->stats);
 445   GNUNET_free (binary);
 446 }
 447
 448
 449 static void
 450 setup_adv_peer (struct PeerContext *p,
 451                 const char *cfgname)
 452 {
 453   char *binary;
 454
 455   binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");
 456   p->cfg = GNUNET_CONFIGURATION_create ();
 457   p->arm_proc =
 458     GNUNET_OS_start_process (GNUNET_YES,
 459                              GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
 460                              NULL, NULL, NULL,
 461                              binary,
 462                              "gnunet-service-arm",
 463                              "-c", cfgname, NULL);
 464   GNUNET_assert (GNUNET_OK ==
 465                  GNUNET_CONFIGURATION_load (p->cfg,
 466                                             cfgname));
 467   p->stats = GNUNET_STATISTICS_create ("hostlist", p->cfg);
 468   GNUNET_assert (NULL != p->stats);
 469   GNUNET_free (binary);
 470 }
 471
 472
 473 static void
 474 run (void *cls,
 475      char *const *args,
 476      const char *cfgfile,
 477      const struct GNUNET_CONFIGURATION_Handle *c)
 478 {
 479   timeout = GNUNET_NO;
 480   adv_sent = GNUNET_NO;
 481
 482   adv_arrived = 0;
 483   learned_hostlist_saved = GNUNET_NO;
 484   learned_hostlist_downloaded = GNUNET_NO;
 485
 486   cfg = c;
 487
 488   setup_adv_peer (&adv_peer,
 489                   "test_learning_adv_peer.conf");
 490   setup_learn_peer (&learn_peer,
 491                     "test_learning_learn_peer.conf");
 492   timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
 493                                                &timeout_error,
 494                                                NULL);
 495   check_task =
 496       GNUNET_SCHEDULER_add_delayed (CHECK_INTERVAL,
 497                                     &check_statistics,
 498                                     NULL);
 499 }
 500
 501
 502 static int
 503 check ()
 504 {
 505   unsigned int failed;
 506
 507   char *const argv[] = {
 508     "test-gnunet-daemon-hostlist-learning",
 509     "-c", "learning_data.conf",
 510     NULL
 511   };
 512   struct GNUNET_GETOPT_CommandLineOption options[] = {
 513     GNUNET_GETOPT_OPTION_END
 514   };
 515
 516   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
 517                       argv,
 518                       "test-gnunet-daemon-hostlist-learning",
 519                       "nohelp",
 520                       options,
 521                       &run,
 522                       NULL);
 523   failed = GNUNET_NO;
 524   if (timeout == GNUNET_YES)
 525   {
 526     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 527                 "Testcase timeout\n");
 528     failed = GNUNET_YES;
 529   }
 530   if (adv_arrived != GNUNET_YES)
 531   {
 532     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 533                 "Learning peer did not receive advertisement from server\n");
 534     failed = GNUNET_YES;
 535   }
 536   if (learned_hostlist_saved == GNUNET_NO)
 537   {
 538     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 539                 "Advertised hostlist was not saved in datastore\n");
 540     failed = GNUNET_YES;
 541   }
 542   if (learned_hostlist_downloaded == GNUNET_NO)
 543   {
 544     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 545                 "Advertised hostlist could not be downloaded from server\n");
 546     failed = GNUNET_YES;
 547   }
 548   if (adv_sent == GNUNET_NO)
 549   {
 550     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 551                 "Advertised was not sent from server to client\n");
 552     failed = GNUNET_YES;
 553   }
 554   if (GNUNET_YES == failed)
 555     return GNUNET_YES;
 556   return GNUNET_NO;
 557 }
 558
 559
 560 int
 561 main (int argc, char *argv[])
 562 {
 563   int ret;
 564
 565   GNUNET_DISK_purge_cfg_dir ("test_learning_learn_peer.conf",
 566                              "GNUNET_TEST_HOME");
 567   GNUNET_DISK_purge_cfg_dir ("test_learning_adv_peer.conf",
 568                              "GNUNET_TEST_HOME");
 569   GNUNET_log_setup ("test-gnunet-daemon-hostlist",
 570                     "WARNING",
 571                     NULL);
 572   ret = check ();
 573   GNUNET_DISK_purge_cfg_dir ("test_learning_learn_peer.conf",
 574                              "GNUNET_TEST_HOME");
 575   GNUNET_DISK_purge_cfg_dir ("test_learning_adv_peer.conf",
 576                              "GNUNET_TEST_HOME");
 577   if (GNUNET_YES ==
 578       GNUNET_DISK_file_test ("hostlists_learn_peer.file"))
 579   {
 580     if (0 == UNLINK ("hostlists_learn_peer.file"))
 581       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 582                   "Hostlist file hostlists_learn_peer.file was removed\n");
 583   }
 584   return ret;
 585 }
 586
 587 /* end of test_gnunet_daemon_hostlist_learning.c */