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
 328     case GNUNET_CONVERSATION_EC_PHONE_HUNG_UP:
 329       GNUNET_break(caller == active_caller);
 330       active_caller = NULL;
 331       if (1 == ok)
 332         ok = 0;
 333       GNUNET_SCHEDULER_shutdown();
 334       break;
 335
 336     default:
 337       fprintf(stderr, "Unexpected phone code: %d\n", code);
 338       break;
 339     }
 340 }
 341
 342
 343 static void
 344 call_event_handler(void *cls, enum GNUNET_CONVERSATION_CallEventCode code)
 345 {
 346   static enum GNUNET_CONVERSATION_CallEventCode expect =
 347     GNUNET_CONVERSATION_EC_CALL_RINGING;
 348
 349   (void)cls;
 350   GNUNET_break(code == expect);
 351   switch (code)
 352     {
 353     case GNUNET_CONVERSATION_EC_CALL_RINGING:
 354       expect = GNUNET_CONVERSATION_EC_CALL_PICKED_UP;
 355       break;
 356
 357     case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
 358       expect = -1;
 359       break;
 360
 361     case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
 362     case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
 363       call = NULL;
 364       ok = 2;
 365       GNUNET_break(0);
 366       fprintf(stderr, "Unexpected call code: %d\n", code);
 367       break;
 368
 369     case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
 370     case GNUNET_CONVERSATION_EC_CALL_RESUMED:
 371       GNUNET_break(0);
 372       fprintf(stderr, "Unexpected call code: %d\n", code);
 373       ok = 2;
 374       break;
 375
 376     case GNUNET_CONVERSATION_EC_CALL_ERROR:
 377       GNUNET_break(0);
 378       fprintf(stderr, "Unexpected call code: %d\n", code);
 379       call = NULL;
 380       ok = 2;
 381       break;
 382     }
 383 }
 384
 385
 386 static void
 387 caller_ego_create_cont(void *cls,
 388                        const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk,
 389                        const char *emsg)
 390 {
 391   (void)cls;
 392   op = NULL;
 393   GNUNET_assert(NULL == emsg);
 394 }
 395
 396
 397 static void
 398 namestore_put_cont(void *cls, int32_t success, const char *emsg)
 399 {
 400   (void)cls;
 401   qe = NULL;
 402   GNUNET_assert(GNUNET_YES == success);
 403   GNUNET_assert(NULL == emsg);
 404   GNUNET_assert(NULL == op);
 405   op = GNUNET_IDENTITY_create(id, "caller-ego", &caller_ego_create_cont, NULL);
 406 }
 407
 408
 409 static void
 410 identity_cb(void *cls,
 411             struct GNUNET_IDENTITY_Ego *ego,
 412             void **ctx,
 413             const char *name)
 414 {
 415   struct GNUNET_GNSRECORD_Data rd;
 416   struct GNUNET_CRYPTO_EcdsaPublicKey pub;
 417
 418   (void)cls;
 419   (void)ctx;
 420   if (NULL == name)
 421     return;
 422   if (NULL == ego)
 423     return;
 424   if (0 == strcmp(name, "phone-ego"))
 425     {
 426       GNUNET_IDENTITY_ego_get_public_key(ego, &pub);
 427       GNUNET_asprintf(&gns_name,
 428                       "phone.%s",
 429                       GNUNET_GNSRECORD_pkey_to_zkey(&pub));
 430       phone =
 431         GNUNET_CONVERSATION_phone_create(cfg, ego, &phone_event_handler, NULL);
 432       GNUNET_assert(NULL != phone);
 433       memset(&rd, 0, sizeof(rd));
 434       GNUNET_CONVERSATION_phone_get_record(phone, &rd);
 435       GNUNET_assert(rd.record_type == GNUNET_GNSRECORD_TYPE_PHONE);
 436       rd.expiration_time = UINT64_MAX;
 437       qe =
 438         GNUNET_NAMESTORE_records_store(ns,
 439                                        GNUNET_IDENTITY_ego_get_private_key(ego),
 440                                        "phone" /* GNS label */,
 441                                        1,
 442                                        &rd,
 443                                        &namestore_put_cont,
 444                                        NULL);
 445       return;
 446     }
 447   if (0 == strcmp(name, "caller-ego"))
 448     {
 449       GNUNET_IDENTITY_ego_get_public_key(ego, &pub);
 450       GNUNET_asprintf(&gns_caller_id,
 451                       "%s",
 452                       GNUNET_GNSRECORD_pkey_to_zkey(&pub));
 453       call = GNUNET_CONVERSATION_call_start(cfg,
 454                                             ego,
 455                                             gns_name,
 456                                             &call_speaker,
 457                                             &call_mic,
 458                                             &call_event_handler,
 459                                             NULL);
 460       return;
 461     }
 462 }
 463
 464
 465 static void
 466 phone_ego_create_cont(void *cls,
 467                       const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk,
 468                       const char *emsg)
 469 {
 470   (void)cls;
 471   op = NULL;
 472   GNUNET_assert(NULL == emsg);
 473 }
 474
 475
 476 static void
 477 run(void *cls,
 478     const struct GNUNET_CONFIGURATION_Handle *c,
 479     struct GNUNET_TESTING_Peer *peer)
 480 {
 481   (void)cls;
 482   (void)peer;
 483   cfg = c;
 484   GNUNET_SCHEDULER_add_delayed(TIMEOUT, &end_test, NULL);
 485   id = GNUNET_IDENTITY_connect(cfg, &identity_cb, NULL);
 486   op = GNUNET_IDENTITY_create(id, "phone-ego", &phone_ego_create_cont, NULL);
 487   ns = GNUNET_NAMESTORE_connect(cfg);
 488 }
 489
 490
 491 int
 492 main(int argc, char *argv[])
 493 {
 494   (void)argc;
 495   (void)argv;
 496   if (0 != GNUNET_TESTING_peer_run("test_conversation_api",
 497                                    "test_conversation.conf",
 498                                    &run,
 499                                    NULL))
 500     return 1;
 501   return ok;
 502 }
 503
 504 /* end of test_conversation_api.c */