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