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
   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., 51 Franklin Street, Fifth Floor,
  18  Boston, MA 02110-1301, USA.
  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 static ssize_t
 112 address_generator (void *cls, size_t max, void *buf)
 113 {
 114   size_t *agc = cls;
 115   ssize_t ret;
 116   struct GNUNET_HELLO_Address address;
 117
 118   if (0 == *agc)
 119     return GNUNET_SYSERR; /* Done */
 120   memset (&address.peer, 0, sizeof(struct GNUNET_PeerIdentity));
 121   address.address = "Address";
 122   address.transport_name = "peerinfotest";
 123   address.address_length = *agc;
 124   ret = GNUNET_HELLO_add_address (&address,
 125       GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS), buf, max);
 126   (*agc)--;
 127   return ret;
 128 }
 129
 130 static void
 131 process_w_fo (void *cls, const struct GNUNET_PeerIdentity *peer,
 132     const struct GNUNET_HELLO_Message *hello, const char *err_msg)
 133 {
 134   if (err_msg != NULL )
 135   {
 136     GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 137         _("Error in communication with PEERINFO service\n"));
 138     GNUNET_SCHEDULER_add_now (&done, NULL );
 139     return;
 140   }
 141
 142   if (NULL != peer)
 143   {
 144     GNUNET_log(GNUNET_ERROR_TYPE_INFO,
 145         "Received callback for peer `%s' %s HELLO\n", GNUNET_i2s (peer),
 146         (NULL != hello) ? "with" : "without");
 147
 148     if (NULL == hello)
 149       return;
 150
 151     if (GNUNET_NO == GNUNET_HELLO_is_friend_only (hello))
 152     {
 153       GNUNET_break(0);
 154       return;
 155     }
 156
 157     GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Received %s HELLO for peer `%s'\n",
 158         (GNUNET_YES == GNUNET_HELLO_is_friend_only (hello)) ? "friend only" : "public",
 159         GNUNET_i2s (peer));
 160     if (0 == memcmp (&pid, peer, sizeof(pid)))
 161     {
 162       res_cb_w_fo = GNUNET_YES;
 163       GNUNET_SCHEDULER_add_now (&done, NULL );
 164     }
 165     return;
 166   }
 167 }
 168
 169 static void
 170 process_wo_fo (void *cls, const struct GNUNET_PeerIdentity *peer,
 171     const struct GNUNET_HELLO_Message *hello, const char *err_msg)
 172 {
 173   if (err_msg != NULL )
 174   {
 175     GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 176         _("Error in communication with PEERINFO service\n"));
 177     GNUNET_SCHEDULER_add_now (&done, NULL );
 178     return;
 179   }
 180
 181   if (NULL != peer)
 182   {
 183     GNUNET_log(GNUNET_ERROR_TYPE_INFO,
 184         "Received callback for peer `%s' %s HELLO\n", GNUNET_i2s (peer),
 185         (NULL != hello) ? "with" : "without");
 186
 187     if (NULL == hello)
 188       return;
 189
 190     if (GNUNET_YES == GNUNET_HELLO_is_friend_only (hello))
 191     {
 192       GNUNET_break(0);
 193       return;
 194     }
 195
 196     GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Received %s HELLO for peer `%s'\n",
 197         (GNUNET_YES == GNUNET_HELLO_is_friend_only (hello)) ? "friend only" : "public",
 198         GNUNET_i2s (peer));
 199     if (0 == memcmp (&pid, peer, sizeof(pid)))
 200     {
 201       GNUNET_break(0);
 202       res_cb_wo_fo = GNUNET_YES;
 203     }
 204   }
 205 }
 206
 207 static void
 208 add_peer_done (void *cls, const char *emsg)
 209 {
 210   if (NULL == emsg)
 211   {
 212     return;
 213   }
 214   else
 215   {
 216     GNUNET_break(0);
 217     GNUNET_SCHEDULER_cancel (timeout_task);
 218     timeout_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL );
 219   }
 220 }
 221
 222 static void
 223 add_peer ()
 224 {
 225   struct GNUNET_HELLO_Message *h2;
 226   size_t agc;
 227
 228   agc = 2;
 229   memset (&pid, 32, sizeof(pid));
 230   h2 = GNUNET_HELLO_create (&pid.public_key, &address_generator, &agc,
 231       GNUNET_YES);
 232   GNUNET_PEERINFO_add_peer (h, h2, &add_peer_done, NULL );
 233   GNUNET_free(h2);
 234
 235 }
 236
 237 static void
 238 run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg,
 239     struct GNUNET_TESTING_Peer *peer)
 240 {
 241   timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL );
 242   mycfg = cfg;
 243   pnc_w_fo = GNUNET_PEERINFO_notify (mycfg, GNUNET_YES, &process_w_fo, NULL );
 244   pnc_wo_fo = GNUNET_PEERINFO_notify (mycfg, GNUNET_NO, &process_wo_fo, NULL );
 245   h = GNUNET_PEERINFO_connect (cfg);
 246   GNUNET_assert(NULL != h);
 247   add_peer ();
 248 }
 249
 250 int
 251 main (int argc, char *argv[])
 252 {
 253   res_cb_w_fo = GNUNET_NO;
 254   res_cb_wo_fo = GNUNET_NO;
 255   global_ret = 3;
 256   if (0
 257       != GNUNET_TESTING_service_run ("test-peerinfo-api-friend-only",
 258           "peerinfo", "test_peerinfo_api_data.conf", &run, NULL ))
 259     return 1;
 260   return global_ret;
 261 }
 262
 263 /* end of test_peerinfo_api_notify_friend_only.c */