src/conversation/test_conversation_api_reject.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2013, 2014 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  * @file conversation/test_conversation_api_reject.c
  22  * @brief testcase for conversation_api.c
  23  *
  24  * This test performs the operations of a call to a phone
  25  * where the phone user immediately hangs up (rejecting the
  26  * call).
  27  */
  28 #include "platform.h"
  29 #include "gnunet_util_lib.h"
  30 #include "gnunet_testing_lib.h"
  31 #include "gnunet_gnsrecord_lib.h"
  32 #include "gnunet_conversation_service.h"
  33 #include "gnunet_identity_service.h"
  34 #include "gnunet_namestore_service.h"
  35
  36 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 25)
  37
  38 static int ok = 1;
  39
  40 static const struct GNUNET_CONFIGURATION_Handle *cfg;
  41
  42 static struct GNUNET_IDENTITY_Handle *id;
  43
  44 static struct GNUNET_IDENTITY_Operation *op;
  45
  46 static struct GNUNET_CONVERSATION_Phone *phone;
  47
  48 static struct GNUNET_NAMESTORE_Handle *ns;
  49
  50 static struct GNUNET_CONVERSATION_Call *call;
  51
  52 static struct GNUNET_NAMESTORE_QueueEntry *qe;
  53
  54 static char *gns_name;
  55
  56 static char *gns_caller_id;
  57
  58
  59 static int
  60 enable_speaker (void *cls)
  61 {
  62   GNUNET_break (0);
  63   return GNUNET_SYSERR;
  64 }
  65
  66
  67 static void
  68 disable_speaker (void *cls)
  69 {
  70   GNUNET_break (0);
  71 }
  72
  73
  74 static void
  75 play (void *cls,
  76       size_t data_size,
  77       const void *data)
  78 {
  79   GNUNET_break (0);
  80 }
  81
  82
  83 static void
  84 destroy_speaker (void *cls)
  85 {
  86 }
  87
  88
  89 static struct GNUNET_SPEAKER_Handle call_speaker = {
  90   &enable_speaker,
  91   &play,
  92   &disable_speaker,
  93   &destroy_speaker,
  94   "caller"
  95 };
  96
  97
  98 static int
  99 enable_mic (void *cls,
 100             GNUNET_MICROPHONE_RecordedDataCallback rdc,
 101             void *rdc_cls)
 102 {
 103   GNUNET_break (0);
 104   return GNUNET_SYSERR;
 105 }
 106
 107
 108 static void
 109 disable_mic (void *cls)
 110 {
 111   GNUNET_break (0);
 112 }
 113
 114
 115 static void
 116 destroy_mic (void *cls)
 117 {
 118 }
 119
 120
 121 static struct GNUNET_MICROPHONE_Handle call_mic = {
 122   &enable_mic,
 123   &disable_mic,
 124   &destroy_mic,
 125   "caller"
 126 };
 127
 128
 129 /**
 130  * Signature of the main function of a task.
 131  *
 132  * @param cls closure
 133  */
 134 static void
 135 end_test (void *cls)
 136 {
 137   GNUNET_SCHEDULER_shutdown ();
 138   if (NULL != op)
 139   {
 140     GNUNET_IDENTITY_cancel (op);
 141     op = NULL;
 142   }
 143   if (NULL != call)
 144   {
 145     GNUNET_CONVERSATION_call_stop (call);
 146     call = NULL;
 147   }
 148   if (NULL != phone)
 149   {
 150     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 151                 "Disconnecting from PHONE service.\n");
 152     GNUNET_CONVERSATION_phone_destroy (phone);
 153     phone = NULL;
 154   }
 155   if (NULL != id)
 156   {
 157     GNUNET_IDENTITY_disconnect (id);
 158     id = NULL;
 159   }
 160   if (NULL != qe)
 161   {
 162     GNUNET_NAMESTORE_cancel (qe);
 163     qe = NULL;
 164   }
 165   if (NULL != ns)
 166   {
 167     GNUNET_NAMESTORE_disconnect (ns);
 168     ns = NULL;
 169   }
 170 }
 171
 172
 173 static void
 174 phone_event_handler (void *cls,
 175                      enum GNUNET_CONVERSATION_PhoneEventCode code,
 176                      struct GNUNET_CONVERSATION_Caller *caller,
 177                      const struct GNUNET_CRYPTO_EcdsaPublicKey *caller_id)
 178 {
 179   static enum GNUNET_CONVERSATION_PhoneEventCode expect
 180     = GNUNET_CONVERSATION_EC_PHONE_RING;
 181
 182   GNUNET_break (code == expect);
 183   switch (code)
 184   {
 185   case GNUNET_CONVERSATION_EC_PHONE_RING:
 186     GNUNET_CONVERSATION_caller_hang_up (caller);
 187     break;
 188   default:
 189     fprintf (stderr, "Unexpected phone code: %d\n", code);
 190     break;
 191   }
 192 }
 193
 194
 195 static void
 196 call_event_handler (void *cls,
 197                     enum GNUNET_CONVERSATION_CallEventCode code)
 198 {
 199   static enum GNUNET_CONVERSATION_CallEventCode expect
 200     = GNUNET_CONVERSATION_EC_CALL_RINGING;
 201
 202   GNUNET_break (code == expect);
 203   switch (code)
 204   {
 205   case GNUNET_CONVERSATION_EC_CALL_RINGING:
 206     expect = GNUNET_CONVERSATION_EC_CALL_HUNG_UP;
 207     break;
 208   case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
 209     call = NULL;
 210     ok = 0;
 211     GNUNET_SCHEDULER_shutdown ();
 212     expect = -1;
 213     break;
 214   case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
 215   case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
 216   case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
 217   case GNUNET_CONVERSATION_EC_CALL_RESUMED:
 218     fprintf (stderr, "Unexpected call code: %d\n", code);
 219     break;
 220   case GNUNET_CONVERSATION_EC_CALL_ERROR:
 221     fprintf (stderr, "Unexpected call code: %d\n", code);
 222     call = NULL;
 223     break;
 224   }
 225 }
 226
 227
 228 static void
 229 caller_ego_create_cont (void *cls,
 230                         const char *emsg)
 231 {
 232   op = NULL;
 233   GNUNET_assert (NULL == emsg);
 234 }
 235
 236
 237 static void
 238 namestore_put_cont (void *cls,
 239                     int32_t success,
 240                     const char *emsg)
 241 {
 242   qe = NULL;
 243   GNUNET_assert (GNUNET_YES == success);
 244   GNUNET_assert (NULL == emsg);
 245   GNUNET_assert (NULL == op);
 246   op = GNUNET_IDENTITY_create (id, "caller-ego",
 247                                &caller_ego_create_cont, NULL);
 248 }
 249
 250
 251 static void
 252 identity_cb (void *cls,
 253              struct GNUNET_IDENTITY_Ego *ego,
 254              void **ctx,
 255              const char *name)
 256 {
 257   struct GNUNET_GNSRECORD_Data rd;
 258   struct GNUNET_CRYPTO_EcdsaPublicKey pub;
 259
 260   if (NULL == name)
 261     return;
 262   if (NULL == ego)
 263     return;
 264   if (0 == strcmp (name, "phone-ego"))
 265   {
 266     GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
 267     GNUNET_asprintf (&gns_name,
 268                      "phone.%s",
 269                      GNUNET_GNSRECORD_pkey_to_zkey (&pub));
 270     phone = GNUNET_CONVERSATION_phone_create (cfg,
 271                                               ego,
 272                                               &phone_event_handler,
 273                                               NULL);
 274     GNUNET_assert (NULL != phone);
 275     memset (&rd, 0, sizeof (rd));
 276     GNUNET_CONVERSATION_phone_get_record (phone,
 277                                           &rd);
 278     GNUNET_assert (rd.record_type == GNUNET_GNSRECORD_TYPE_PHONE);
 279     rd.expiration_time = UINT64_MAX;
 280     qe = GNUNET_NAMESTORE_records_store (ns,
 281                                          GNUNET_IDENTITY_ego_get_private_key (ego),
 282                                          "phone" /* GNS label */,
 283                                          1,
 284                                          &rd,
 285                                          &namestore_put_cont,
 286                                          NULL);
 287     return;
 288   }
 289   if (0 == strcmp (name, "caller-ego"))
 290   {
 291     GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
 292     GNUNET_asprintf (&gns_caller_id,
 293                      "%s",
 294                      GNUNET_GNSRECORD_pkey_to_zkey (&pub));
 295     call = GNUNET_CONVERSATION_call_start (cfg,
 296                                            ego,
 297                                            ego,
 298                                            gns_name,
 299                                            &call_speaker,
 300                                            &call_mic,
 301                                            &call_event_handler,
 302                                            NULL);
 303     return;
 304   }
 305 }
 306
 307
 308 static void
 309 phone_ego_create_cont (void *cls,
 310                        const char *emsg)
 311 {
 312   op = NULL;
 313   GNUNET_assert (NULL == emsg);
 314 }
 315
 316
 317 static void
 318 run (void *cls,
 319      const struct GNUNET_CONFIGURATION_Handle *c,
 320      struct GNUNET_TESTING_Peer *peer)
 321 {
 322   cfg = c;
 323   GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_test,
 324                                 NULL);
 325   id = GNUNET_IDENTITY_connect (cfg,
 326                                 &identity_cb,
 327                                 NULL);
 328   op = GNUNET_IDENTITY_create (id, "phone-ego", &phone_ego_create_cont, NULL);
 329   ns = GNUNET_NAMESTORE_connect (cfg);
 330 }
 331
 332
 333 int
 334 main (int argc, char *argv[])
 335 {
 336   if (0 != GNUNET_TESTING_peer_run ("test_conversation_api",
 337                                     "test_conversation.conf",
 338                                     &run, NULL))
 339     return 1;
 340   return ok;
 341 }
 342
 343 /* end of test_conversation_api_reject.c */