src/conversation/test_conversation_api_reject.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2013 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 char *caller_id)
 178 {
 179   static enum GNUNET_CONVERSATION_PhoneEventCode expect
 180     = GNUNET_CONVERSATION_EC_PHONE_RING;
 181
 182   GNUNET_break (0 == strcmp (caller_id,
 183                              gns_caller_id));
 184   GNUNET_break (code == expect);
 185   switch (code)
 186   {
 187   case GNUNET_CONVERSATION_EC_PHONE_RING:
 188     GNUNET_CONVERSATION_caller_hang_up (caller);
 189     break;
 190   default:
 191     fprintf (stderr, "Unexpected phone code: %d\n", code);
 192     break;
 193   }
 194 }
 195
 196
 197 static void
 198 call_event_handler (void *cls,
 199                     enum GNUNET_CONVERSATION_CallEventCode code)
 200 {
 201   static enum GNUNET_CONVERSATION_CallEventCode expect
 202     = GNUNET_CONVERSATION_EC_CALL_RINGING;
 203
 204   GNUNET_break (code == expect);
 205   switch (code)
 206   {
 207   case GNUNET_CONVERSATION_EC_CALL_RINGING:
 208     expect = GNUNET_CONVERSATION_EC_CALL_HUNG_UP;
 209     break;
 210   case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
 211     call = NULL;
 212     ok = 0;
 213     GNUNET_SCHEDULER_shutdown ();
 214     expect = -1;
 215     break;
 216   case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
 217   case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
 218   case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
 219   case GNUNET_CONVERSATION_EC_CALL_RESUMED:
 220   case GNUNET_CONVERSATION_EC_CALL_ERROR:
 221     fprintf (stderr, "Unexpected call code: %d\n", code);
 222     break;
 223   }
 224 }
 225
 226
 227 static void
 228 caller_ego_create_cont (void *cls,
 229                         const char *emsg)
 230 {
 231   op = NULL;
 232   GNUNET_assert (NULL == emsg);
 233 }
 234
 235
 236 static void
 237 namestore_put_cont (void *cls,
 238                     int32_t success,
 239                     const char *emsg)
 240 {
 241   qe = NULL;
 242   GNUNET_assert (GNUNET_YES == success);
 243   GNUNET_assert (NULL == emsg);
 244   GNUNET_assert (NULL == op);
 245   op = GNUNET_IDENTITY_create (id, "caller-ego", &caller_ego_create_cont, NULL);
 246 }
 247
 248
 249 static void
 250 identity_cb (void *cls,
 251              struct GNUNET_IDENTITY_Ego *ego,
 252              void **ctx,
 253              const char *name)
 254 {
 255   struct GNUNET_GNSRECORD_Data rd;
 256   struct GNUNET_CRYPTO_EcdsaPublicKey pub;
 257
 258   if (NULL == name)
 259     return;
 260   if (NULL == ego)
 261     return;
 262   if (0 == strcmp (name, "phone-ego"))
 263   {
 264     GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
 265     GNUNET_asprintf (&gns_name,
 266                      "phone.%s",
 267                      GNUNET_GNSRECORD_pkey_to_zkey (&pub));
 268     phone = GNUNET_CONVERSATION_phone_create (cfg,
 269                                               ego,
 270                                               &phone_event_handler,
 271                                               NULL);
 272     GNUNET_assert (NULL != phone);
 273     memset (&rd, 0, sizeof (rd));
 274     GNUNET_CONVERSATION_phone_get_record (phone,
 275                                           &rd);
 276     GNUNET_assert (rd.record_type == GNUNET_GNSRECORD_TYPE_PHONE);
 277     rd.expiration_time = UINT64_MAX;
 278     qe = GNUNET_NAMESTORE_records_store (ns,
 279                                          GNUNET_IDENTITY_ego_get_private_key (ego),
 280                                          "phone" /* GNS label */,
 281                                          1,
 282                                          &rd,
 283                                          &namestore_put_cont,
 284                                          NULL);
 285     return;
 286   }
 287   if (0 == strcmp (name, "caller-ego"))
 288   {
 289     GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
 290     GNUNET_asprintf (&gns_caller_id,
 291                      "%s",
 292                      GNUNET_GNSRECORD_pkey_to_zkey (&pub));
 293     call = GNUNET_CONVERSATION_call_start (cfg,
 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 */