src/conversation/test_conversation_api_reject.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2013, 2014 Christian Grothoff (and other contributing authors)
   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., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, 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  * @param tc context information (why was this task triggered now)
 134  */
 135 static void
 136 end_test (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 137 {
 138   GNUNET_SCHEDULER_shutdown ();
 139   if (NULL != op)
 140   {
 141     GNUNET_IDENTITY_cancel (op);
 142     op = NULL;
 143   }
 144   if (NULL != call)
 145   {
 146     GNUNET_CONVERSATION_call_stop (call);
 147     call = NULL;
 148   }
 149   if (NULL != phone)
 150   {
 151     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "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   case GNUNET_CONVERSATION_EC_CALL_ERROR:
 219     fprintf (stderr, "Unexpected call code: %d\n", code);
 220     break;
 221   }
 222 }
 223
 224
 225 static void
 226 caller_ego_create_cont (void *cls,
 227                         const char *emsg)
 228 {
 229   op = NULL;
 230   GNUNET_assert (NULL == emsg);
 231 }
 232
 233
 234 static void
 235 namestore_put_cont (void *cls,
 236                     int32_t success,
 237                     const char *emsg)
 238 {
 239   qe = NULL;
 240   GNUNET_assert (GNUNET_YES == success);
 241   GNUNET_assert (NULL == emsg);
 242   GNUNET_assert (NULL == op);
 243   op = GNUNET_IDENTITY_create (id, "caller-ego",
 244                                &caller_ego_create_cont, NULL);
 245 }
 246
 247
 248 static void
 249 identity_cb (void *cls,
 250              struct GNUNET_IDENTITY_Ego *ego,
 251              void **ctx,
 252              const char *name)
 253 {
 254   struct GNUNET_GNSRECORD_Data rd;
 255   struct GNUNET_CRYPTO_EcdsaPublicKey pub;
 256
 257   if (NULL == name)
 258     return;
 259   if (NULL == ego)
 260     return;
 261   if (0 == strcmp (name, "phone-ego"))
 262   {
 263     GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
 264     GNUNET_asprintf (&gns_name,
 265                      "phone.%s",
 266                      GNUNET_GNSRECORD_pkey_to_zkey (&pub));
 267     phone = GNUNET_CONVERSATION_phone_create (cfg,
 268                                               ego,
 269                                               &phone_event_handler,
 270                                               NULL);
 271     GNUNET_assert (NULL != phone);
 272     memset (&rd, 0, sizeof (rd));
 273     GNUNET_CONVERSATION_phone_get_record (phone,
 274                                           &rd);
 275     GNUNET_assert (rd.record_type == GNUNET_GNSRECORD_TYPE_PHONE);
 276     rd.expiration_time = UINT64_MAX;
 277     qe = GNUNET_NAMESTORE_records_store (ns,
 278                                          GNUNET_IDENTITY_ego_get_private_key (ego),
 279                                          "phone" /* GNS label */,
 280                                          1,
 281                                          &rd,
 282                                          &namestore_put_cont,
 283                                          NULL);
 284     return;
 285   }
 286   if (0 == strcmp (name, "caller-ego"))
 287   {
 288     GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
 289     GNUNET_asprintf (&gns_caller_id,
 290                      "%s",
 291                      GNUNET_GNSRECORD_pkey_to_zkey (&pub));
 292     call = GNUNET_CONVERSATION_call_start (cfg,
 293                                            ego,
 294                                            ego,
 295                                            gns_name,
 296                                            &call_speaker,
 297                                            &call_mic,
 298                                            &call_event_handler,
 299                                            NULL);
 300     return;
 301   }
 302 }
 303
 304
 305 static void
 306 phone_ego_create_cont (void *cls,
 307                        const char *emsg)
 308 {
 309   op = NULL;
 310   GNUNET_assert (NULL == emsg);
 311 }
 312
 313
 314 static void
 315 run (void *cls,
 316      const struct GNUNET_CONFIGURATION_Handle *c,
 317      struct GNUNET_TESTING_Peer *peer)
 318 {
 319   cfg = c;
 320   GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_test,
 321                                 NULL);
 322   id = GNUNET_IDENTITY_connect (cfg,
 323                                 &identity_cb,
 324                                 NULL);
 325   op = GNUNET_IDENTITY_create (id, "phone-ego", &phone_ego_create_cont, NULL);
 326   ns = GNUNET_NAMESTORE_connect (cfg);
 327 }
 328
 329
 330 int
 331 main (int argc, char *argv[])
 332 {
 333   if (0 != GNUNET_TESTING_peer_run ("test_conversation_api",
 334                                     "test_conversation.conf",
 335                                     &run, NULL))
 336     return 1;
 337   return ok;
 338 }
 339
 340 /* end of test_conversation_api_reject.c */