src/peerinfo/test_peerinfo_api_notify_friend_only.c

   1 /*
   2    This file is part of GNUnet.
   3    Copyright (C) 2004, 2009 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 /**
  22  * @file peerinfo/test_peerinfo_api_notify_friend_only.c
  23  * @brief testcase friend only HELLO restrictions in for peerinfo
  24  * @author Christian Grothoff
  25  * @author Matthias Wachs
  26  *
  27  * TODO:
  28  * - test merging of HELLOs (add same peer twice...)
  29  */
  30 #include "platform.h"
  31 #include "gnunet_hello_lib.h"
  32 #include "gnunet_util_lib.h"
  33 #include "gnunet_peerinfo_service.h"
  34 #include "gnunet_testing_lib.h"
  35 #include "peerinfo.h"
  36
  37 #define TIMEOUT  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
  38
  39 static struct GNUNET_PEERINFO_Handle *h;
  40 static struct GNUNET_PEERINFO_NotifyContext *pnc_w_fo;
  41 static struct GNUNET_PEERINFO_NotifyContext *pnc_wo_fo;
  42
  43 static const struct GNUNET_CONFIGURATION_Handle *mycfg;
  44
  45 static int global_ret;
  46
  47 /**
  48  * Did we get a HELLO callback for notification handle with friend HELLOS
  49  * (expected)
  50  */
  51 static int res_cb_w_fo;
  52
  53 /**
  54  * Did we get a HELLO callback for notification handle without friend HELLOS
  55  * (not expected)
  56  */
  57 static int res_cb_wo_fo;
  58
  59 struct GNUNET_PeerIdentity pid;
  60
  61 struct GNUNET_SCHEDULER_Task *timeout_task;
  62
  63 static void
  64 end_badly (void *cls)
  65 {
  66   timeout_task = NULL;
  67   GNUNET_break (0);
  68   if (NULL != pnc_wo_fo)
  69   {
  70     GNUNET_PEERINFO_notify_cancel (pnc_wo_fo);
  71     pnc_wo_fo = NULL;
  72   }
  73   if (NULL != pnc_w_fo)
  74   {
  75     GNUNET_PEERINFO_notify_cancel (pnc_w_fo);
  76     pnc_w_fo = NULL;
  77   }
  78   if (NULL != h)
  79   {
  80     GNUNET_PEERINFO_disconnect (h);
  81     h = NULL;
  82   }
  83   global_ret = 255;
  84 }
  85
  86
  87 static void
  88 done (void *cls)
  89 {
  90   if (NULL != pnc_w_fo)
  91     GNUNET_PEERINFO_notify_cancel (pnc_w_fo);
  92   pnc_w_fo = NULL;
  93   if (NULL != pnc_wo_fo)
  94     GNUNET_PEERINFO_notify_cancel (pnc_wo_fo);
  95   pnc_wo_fo = NULL;
  96   GNUNET_PEERINFO_disconnect (h);
  97   h = NULL;
  98
  99   if (NULL != timeout_task)
 100   {
 101     GNUNET_SCHEDULER_cancel (timeout_task);
 102     timeout_task = NULL;
 103   }
 104
 105   if ((GNUNET_YES == res_cb_w_fo) && (GNUNET_NO == res_cb_wo_fo))
 106     global_ret = 0;
 107   else
 108     GNUNET_break (0);
 109 }
 110
 111
 112 static ssize_t
 113 address_generator (void *cls, size_t max, void *buf)
 114 {
 115   size_t *agc = cls;
 116   ssize_t ret;
 117   struct GNUNET_HELLO_Address address;
 118
 119   if (0 == *agc)
 120     return GNUNET_SYSERR; /* Done */
 121   memset (&address.peer, 0, sizeof(struct GNUNET_PeerIdentity));
 122   address.address = "Address";
 123   address.transport_name = "peerinfotest";
 124   address.address_length = *agc;
 125   ret = GNUNET_HELLO_add_address (&address,
 126                                   GNUNET_TIME_relative_to_absolute (
 127                                     GNUNET_TIME_UNIT_HOURS), buf, max);
 128   (*agc)--;
 129   return ret;
 130 }
 131
 132
 133 static void
 134 process_w_fo (void *cls,
 135               const struct GNUNET_PeerIdentity *peer,
 136               const struct GNUNET_HELLO_Message *hello,
 137               const char *err_msg)
 138 {
 139   if (err_msg != NULL)
 140   {
 141     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 142                 _ ("Error in communication with PEERINFO service\n"));
 143     GNUNET_SCHEDULER_add_now (&done, NULL);
 144     return;
 145   }
 146
 147   if (NULL != peer)
 148   {
 149     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 150                 "Received callback for peer `%s' %s HELLO\n", GNUNET_i2s (peer),
 151                 (NULL != hello) ? "with" : "without");
 152
 153     if (NULL == hello)
 154       return;
 155
 156     if (GNUNET_NO == GNUNET_HELLO_is_friend_only (hello))
 157     {
 158       GNUNET_break (0);
 159       return;
 160     }
 161
 162     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Received %s HELLO for peer `%s'\n",
 163                 (GNUNET_YES == GNUNET_HELLO_is_friend_only (hello)) ?
 164                 "friend only" : "public",
 165                 GNUNET_i2s (peer));
 166     if (0 == GNUNET_memcmp (&pid, peer))
 167     {
 168       res_cb_w_fo = GNUNET_YES;
 169       GNUNET_SCHEDULER_add_now (&done, NULL);
 170     }
 171     return;
 172   }
 173 }
 174
 175
 176 static void
 177 process_wo_fo (void *cls, const struct GNUNET_PeerIdentity *peer,
 178                const struct GNUNET_HELLO_Message *hello, const char *err_msg)
 179 {
 180   if (err_msg != NULL)
 181   {
 182     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 183                 _ ("Error in communication with PEERINFO service\n"));
 184     GNUNET_SCHEDULER_add_now (&done, NULL);
 185     return;
 186   }
 187
 188   if (NULL != peer)
 189   {
 190     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 191                 "Received callback for peer `%s' %s HELLO\n", GNUNET_i2s (peer),
 192                 (NULL != hello) ? "with" : "without");
 193
 194     if (NULL == hello)
 195       return;
 196
 197     if (GNUNET_YES == GNUNET_HELLO_is_friend_only (hello))
 198     {
 199       GNUNET_break (0);
 200       return;
 201     }
 202
 203     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Received %s HELLO for peer `%s'\n",
 204                 (GNUNET_YES == GNUNET_HELLO_is_friend_only (hello)) ?
 205                 "friend only" : "public",
 206                 GNUNET_i2s (peer));
 207     if (0 == GNUNET_memcmp (&pid, peer))
 208     {
 209       GNUNET_break (0);
 210       res_cb_wo_fo = GNUNET_YES;
 211     }
 212   }
 213 }
 214
 215
 216 static void
 217 add_peer ()
 218 {
 219   struct GNUNET_HELLO_Message *h2;
 220   size_t agc;
 221
 222   agc = 2;
 223   memset (&pid, 32, sizeof(pid));
 224   h2 = GNUNET_HELLO_create (&pid.public_key, &address_generator, &agc,
 225                             GNUNET_YES);
 226   GNUNET_PEERINFO_add_peer (h, h2, NULL, NULL);
 227   GNUNET_free (h2);
 228 }
 229
 230
 231 static void
 232 run (void *cls,
 233      const struct GNUNET_CONFIGURATION_Handle *cfg,
 234      struct GNUNET_TESTING_Peer *peer)
 235 {
 236   timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
 237   mycfg = cfg;
 238   pnc_w_fo = GNUNET_PEERINFO_notify (mycfg, GNUNET_YES, &process_w_fo, NULL);
 239   pnc_wo_fo = GNUNET_PEERINFO_notify (mycfg, GNUNET_NO, &process_wo_fo, NULL);
 240   h = GNUNET_PEERINFO_connect (cfg);
 241   GNUNET_assert (NULL != h);
 242   add_peer ();
 243 }
 244
 245
 246 int
 247 main (int argc, char *argv[])
 248 {
 249   res_cb_w_fo = GNUNET_NO;
 250   res_cb_wo_fo = GNUNET_NO;
 251   global_ret = 3;
 252   if (0 != GNUNET_TESTING_service_run ("test-peerinfo-api-friend-only",
 253                                        "peerinfo",
 254                                        "test_peerinfo_api_data.conf",
 255                                        &run, NULL))
 256     return 1;
 257   return global_ret;
 258 }
 259
 260
 261 /* end of test_peerinfo_api_notify_friend_only.c */