src/conversation/test_conversation_api.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2013, 2014, 2018 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your 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      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19 */
  20 /**
  21  * @file conversation/test_conversation_api.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 picks up and then the call is
  26  * terminated by the party that initiated the 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 FREQ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)
  37
  38 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 25)
  39
  40 static int ok = 1;
  41
  42 static const struct GNUNET_CONFIGURATION_Handle *cfg;
  43
  44 static struct GNUNET_IDENTITY_Handle *id;
  45
  46 static struct GNUNET_IDENTITY_Operation *op;
  47
  48 static struct GNUNET_CONVERSATION_Phone *phone;
  49
  50 static struct GNUNET_NAMESTORE_Handle *ns;
  51
  52 static struct GNUNET_CONVERSATION_Call *call;
  53
  54 static struct GNUNET_NAMESTORE_QueueEntry *qe;
  55
  56 static struct GNUNET_CONVERSATION_Caller *active_caller;
  57
  58 static char *gns_name;
  59
  60 static char *gns_caller_id;
  61
  62 static GNUNET_MICROPHONE_RecordedDataCallback phone_rdc;
  63
  64 static void *phone_rdc_cls;
  65
  66 static GNUNET_MICROPHONE_RecordedDataCallback call_rdc;
  67
  68 static void *call_rdc_cls;
  69
  70 static struct GNUNET_SCHEDULER_Task *phone_task;
  71
  72 static struct GNUNET_SCHEDULER_Task *call_task;
  73
  74
  75 static void
  76 phone_send (void *cls)
  77 {
  78   static unsigned int i;
  79   char buf[32];
  80
  81   (void) cls;
  82   GNUNET_assert (NULL != phone_rdc);
  83   GNUNET_snprintf (buf, sizeof (buf), "phone-%u", i++);
  84   phone_rdc (phone_rdc_cls, strlen (buf) + 1, buf);
  85   phone_task = GNUNET_SCHEDULER_add_delayed (FREQ, &phone_send, NULL);
  86 }
  87
  88
  89 static void
  90 call_send (void *cls)
  91 {
  92   static unsigned int i;
  93   char buf[32];
  94
  95   (void) cls;
  96   GNUNET_assert (NULL != call_rdc);
  97   GNUNET_snprintf (buf, sizeof (buf), "call-%u", i++);
  98   call_rdc (call_rdc_cls, strlen (buf) + 1, buf);
  99   call_task = GNUNET_SCHEDULER_add_delayed (FREQ, &call_send, NULL);
 100 }
 101
 102
 103 static int
 104 enable_speaker (void *cls)
 105 {
 106   const char *origin = cls;
 107
 108   fprintf (stderr, "Speaker %s enabled\n", origin);
 109   return GNUNET_OK;
 110 }
 111
 112
 113 static void
 114 disable_speaker (void *cls)
 115 {
 116   const char *origin = cls;
 117
 118   fprintf (stderr, "Speaker %s disabled\n", origin);
 119 }
 120
 121
 122 static void
 123 play (void *cls, size_t data_size, const void *data)
 124 {
 125   const char *origin = cls;
 126   static unsigned int phone_i = 1;
 127   static unsigned int call_i;
 128   char buf[32];
 129
 130   if (0 == strcmp (origin, "phone"))
 131     GNUNET_snprintf (buf, sizeof (buf), "call-%u", call_i++);
 132   else
 133     GNUNET_snprintf (buf, sizeof (buf), "phone-%u", phone_i++);
 134   if ((data_size != strlen (buf) + 1) || (0 != strncmp (buf, data, data_size)))
 135   {
 136     fprintf (stderr,
 137              "Expected %s, received %.*s\n",
 138              buf,
 139              (int) data_size,
 140              (const char *) data);
 141   }
 142   else
 143   {
 144     fprintf (stderr, ".");
 145   }
 146   if ((20 < call_i) && (20 < phone_i) && (NULL != call))
 147   {
 148     /* time to hang up ... */
 149     GNUNET_CONVERSATION_call_stop (call);
 150     call = NULL;
 151   }
 152 }
 153
 154
 155 static void
 156 destroy_speaker (void *cls)
 157 {
 158   const char *origin = cls;
 159
 160   fprintf (stderr, "Speaker %s destroyed\n", origin);
 161 }
 162
 163
 164 static struct GNUNET_SPEAKER_Handle call_speaker = {&enable_speaker,
 165                                                     &play,
 166                                                     &disable_speaker,
 167                                                     &destroy_speaker,
 168                                                     "caller"};
 169
 170
 171 static struct GNUNET_SPEAKER_Handle phone_speaker = {&enable_speaker,
 172                                                      &play,
 173                                                      &disable_speaker,
 174                                                      &destroy_speaker,
 175                                                      "phone"};
 176
 177
 178 static int
 179 enable_mic (void *cls,
 180             GNUNET_MICROPHONE_RecordedDataCallback rdc,
 181             void *rdc_cls)
 182 {
 183   const char *origin = cls;
 184
 185   fprintf (stderr, "Mic %s enabled\n", origin);
 186   if (0 == strcmp (origin, "phone"))
 187   {
 188     phone_rdc = rdc;
 189     phone_rdc_cls = rdc_cls;
 190     phone_task = GNUNET_SCHEDULER_add_now (&phone_send, NULL);
 191   }
 192   else
 193   {
 194     call_rdc = rdc;
 195     call_rdc_cls = rdc_cls;
 196     call_task = GNUNET_SCHEDULER_add_now (&call_send, NULL);
 197   }
 198   return GNUNET_OK;
 199 }
 200
 201
 202 static void
 203 disable_mic (void *cls)
 204 {
 205   const char *origin = cls;
 206
 207   fprintf (stderr, "Mic %s disabled\n", origin);
 208   if (0 == strcmp (origin, "phone"))
 209   {
 210     phone_rdc = NULL;
 211     phone_rdc_cls = NULL;
 212     GNUNET_SCHEDULER_cancel (phone_task);
 213     phone_task = NULL;
 214   }
 215   else
 216   {
 217     call_rdc = NULL;
 218     call_rdc_cls = NULL;
 219     GNUNET_SCHEDULER_cancel (call_task);
 220     call_task = NULL;
 221   }
 222 }
 223
 224
 225 static void
 226 destroy_mic (void *cls)
 227 {
 228   const char *origin = cls;
 229
 230   fprintf (stderr, "Mic %s destroyed\n", origin);
 231 }
 232
 233
 234 static struct GNUNET_MICROPHONE_Handle call_mic = {&enable_mic,
 235                                                    &disable_mic,
 236                                                    &destroy_mic,
 237                                                    "caller"};
 238
 239
 240 static struct GNUNET_MICROPHONE_Handle phone_mic = {&enable_mic,
 241                                                     &disable_mic,
 242                                                     &destroy_mic,
 243                                                     "phone"};
 244
 245
 246 /**
 247  * Signature of the main function of a task.
 248  *
 249  * @param cls closure
 250  */
 251 static void
 252 end_test (void *cls)
 253 {
 254   (void) cls;
 255   GNUNET_SCHEDULER_shutdown ();
 256   if (NULL != op)
 257   {
 258     GNUNET_IDENTITY_cancel (op);
 259     op = NULL;
 260   }
 261   if (NULL != call)
 262   {
 263     GNUNET_CONVERSATION_call_stop (call);
 264     call = NULL;
 265   }
 266   if (NULL != phone)
 267   {
 268     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from PHONE service.\n");
 269     GNUNET_CONVERSATION_phone_destroy (phone);
 270     phone = NULL;
 271   }
 272   if (NULL != id)
 273   {
 274     GNUNET_IDENTITY_disconnect (id);
 275     id = NULL;
 276   }
 277   if (NULL != qe)
 278   {
 279     GNUNET_NAMESTORE_cancel (qe);
 280     qe = NULL;
 281   }
 282   if (NULL != ns)
 283   {
 284     GNUNET_NAMESTORE_disconnect (ns);
 285     ns = NULL;
 286   }
 287 }
 288
 289
 290 static void
 291 caller_event_handler (void *cls, enum GNUNET_CONVERSATION_CallerEventCode code)
 292 {
 293   (void) cls;
 294   switch (code)
 295   {
 296   case GNUNET_CONVERSATION_EC_CALLER_SUSPEND:
 297   case GNUNET_CONVERSATION_EC_CALLER_RESUME:
 298     fprintf (stderr, "Unexpected caller code: %d\n", code);
 299     break;
 300   }
 301 }
 302
 303
 304 static void
 305 phone_event_handler (void *cls,
 306                      enum GNUNET_CONVERSATION_PhoneEventCode code,
 307                      struct GNUNET_CONVERSATION_Caller *caller,
 308                      const struct GNUNET_CRYPTO_EcdsaPublicKey *caller_id)
 309 {
 310   static enum GNUNET_CONVERSATION_PhoneEventCode expect =
 311     GNUNET_CONVERSATION_EC_PHONE_RING;
 312
 313   (void) cls;
 314   (void) caller_id;
 315   GNUNET_break (code == expect);
 316   switch (code)
 317   {
 318   case GNUNET_CONVERSATION_EC_PHONE_RING:
 319     active_caller = caller;
 320     GNUNET_CONVERSATION_caller_pick_up (caller,
 321                                         &caller_event_handler,
 322                                         NULL,
 323                                         &phone_speaker,
 324                                         &phone_mic);
 325     expect = GNUNET_CONVERSATION_EC_PHONE_HUNG_UP;
 326     break;
 327   case GNUNET_CONVERSATION_EC_PHONE_HUNG_UP:
 328     GNUNET_break (caller == active_caller);
 329     active_caller = NULL;
 330     if (1 == ok)
 331       ok = 0;
 332     GNUNET_SCHEDULER_shutdown ();
 333     break;
 334   default:
 335     fprintf (stderr, "Unexpected phone code: %d\n", code);
 336     break;
 337   }
 338 }
 339
 340
 341 static void
 342 call_event_handler (void *cls, enum GNUNET_CONVERSATION_CallEventCode code)
 343 {
 344   static enum GNUNET_CONVERSATION_CallEventCode expect =
 345     GNUNET_CONVERSATION_EC_CALL_RINGING;
 346
 347   (void) cls;
 348   GNUNET_break (code == expect);
 349   switch (code)
 350   {
 351   case GNUNET_CONVERSATION_EC_CALL_RINGING:
 352     expect = GNUNET_CONVERSATION_EC_CALL_PICKED_UP;
 353     break;
 354   case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
 355     expect = -1;
 356     break;
 357   case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
 358   case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
 359     call = NULL;
 360     ok = 2;
 361     GNUNET_break (0);
 362     fprintf (stderr, "Unexpected call code: %d\n", code);
 363     break;
 364   case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
 365   case GNUNET_CONVERSATION_EC_CALL_RESUMED:
 366     GNUNET_break (0);
 367     fprintf (stderr, "Unexpected call code: %d\n", code);
 368     ok = 2;
 369     break;
 370   case GNUNET_CONVERSATION_EC_CALL_ERROR:
 371     GNUNET_break (0);
 372     fprintf (stderr, "Unexpected call code: %d\n", code);
 373     call = NULL;
 374     ok = 2;
 375     break;
 376   }
 377 }
 378
 379
 380 static void
 381 caller_ego_create_cont (void *cls,
 382                         const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk,
 383                         const char *emsg)
 384 {
 385   (void) cls;
 386   op = NULL;
 387   GNUNET_assert (NULL == emsg);
 388 }
 389
 390
 391 static void
 392 namestore_put_cont (void *cls, int32_t success, const char *emsg)
 393 {
 394   (void) cls;
 395   qe = NULL;
 396   GNUNET_assert (GNUNET_YES == success);
 397   GNUNET_assert (NULL == emsg);
 398   GNUNET_assert (NULL == op);
 399   op = GNUNET_IDENTITY_create (id, "caller-ego", &caller_ego_create_cont, NULL);
 400 }
 401
 402
 403 static void
 404 identity_cb (void *cls,
 405              struct GNUNET_IDENTITY_Ego *ego,
 406              void **ctx,
 407              const char *name)
 408 {
 409   struct GNUNET_GNSRECORD_Data rd;
 410   struct GNUNET_CRYPTO_EcdsaPublicKey pub;
 411
 412   (void) cls;
 413   (void) ctx;
 414   if (NULL == name)
 415     return;
 416   if (NULL == ego)
 417     return;
 418   if (0 == strcmp (name, "phone-ego"))
 419   {
 420     GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
 421     GNUNET_asprintf (&gns_name,
 422                      "phone.%s",
 423                      GNUNET_GNSRECORD_pkey_to_zkey (&pub));
 424     phone =
 425       GNUNET_CONVERSATION_phone_create (cfg, ego, &phone_event_handler, NULL);
 426     GNUNET_assert (NULL != phone);
 427     memset (&rd, 0, sizeof (rd));
 428     GNUNET_CONVERSATION_phone_get_record (phone, &rd);
 429     GNUNET_assert (rd.record_type == GNUNET_GNSRECORD_TYPE_PHONE);
 430     rd.expiration_time = UINT64_MAX;
 431     qe =
 432       GNUNET_NAMESTORE_records_store (ns,
 433                                       GNUNET_IDENTITY_ego_get_private_key (ego),
 434                                       "phone" /* GNS label */,
 435                                       1,
 436                                       &rd,
 437                                       &namestore_put_cont,
 438                                       NULL);
 439     return;
 440   }
 441   if (0 == strcmp (name, "caller-ego"))
 442   {
 443     GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
 444     GNUNET_asprintf (&gns_caller_id,
 445                      "%s",
 446                      GNUNET_GNSRECORD_pkey_to_zkey (&pub));
 447     call = GNUNET_CONVERSATION_call_start (cfg,
 448                                            ego,
 449                                            gns_name,
 450                                            &call_speaker,
 451                                            &call_mic,
 452                                            &call_event_handler,
 453                                            NULL);
 454     return;
 455   }
 456 }
 457
 458
 459 static void
 460 phone_ego_create_cont (void *cls, const char *emsg)
 461 {
 462   (void) cls;
 463   op = NULL;
 464   GNUNET_assert (NULL == emsg);
 465 }
 466
 467
 468 static void
 469 run (void *cls,
 470      const struct GNUNET_CONFIGURATION_Handle *c,
 471      struct GNUNET_TESTING_Peer *peer)
 472 {
 473   (void) cls;
 474   (void) peer;
 475   cfg = c;
 476   GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_test, NULL);
 477   id = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL);
 478   op = GNUNET_IDENTITY_create (id, "phone-ego", &phone_ego_create_cont, NULL);
 479   ns = GNUNET_NAMESTORE_connect (cfg);
 480 }
 481
 482
 483 int
 484 main (int argc, char *argv[])
 485 {
 486   (void) argc;
 487   (void) argv;
 488   if (0 != GNUNET_TESTING_peer_run ("test_conversation_api",
 489                                     "test_conversation.conf",
 490                                     &run,
 491                                     NULL))
 492     return 1;
 493   return ok;
 494 }
 495
 496 /* end of test_conversation_api.c */