summaryrefslogtreecommitdiff
path: root/src/conversation/test_conversation_api.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/conversation/test_conversation_api.c')
-rw-r--r--src/conversation/test_conversation_api.c496
1 files changed, 248 insertions, 248 deletions
diff --git a/src/conversation/test_conversation_api.c b/src/conversation/test_conversation_api.c
index e58f89e7a..66b800304 100644
--- a/src/conversation/test_conversation_api.c
+++ b/src/conversation/test_conversation_api.c
@@ -33,9 +33,9 @@
33#include "gnunet_identity_service.h" 33#include "gnunet_identity_service.h"
34#include "gnunet_namestore_service.h" 34#include "gnunet_namestore_service.h"
35 35
36#define FREQ GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 250) 36#define FREQ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)
37 37
38#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 25) 38#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 25)
39 39
40static int ok = 1; 40static int ok = 1;
41 41
@@ -73,91 +73,91 @@ static struct GNUNET_SCHEDULER_Task *call_task;
73 73
74 74
75static void 75static void
76phone_send(void *cls) 76phone_send (void *cls)
77{ 77{
78 static unsigned int i; 78 static unsigned int i;
79 char buf[32]; 79 char buf[32];
80 80
81 (void)cls; 81 (void) cls;
82 GNUNET_assert(NULL != phone_rdc); 82 GNUNET_assert (NULL != phone_rdc);
83 GNUNET_snprintf(buf, sizeof(buf), "phone-%u", i++); 83 GNUNET_snprintf (buf, sizeof(buf), "phone-%u", i++);
84 phone_rdc(phone_rdc_cls, strlen(buf) + 1, buf); 84 phone_rdc (phone_rdc_cls, strlen (buf) + 1, buf);
85 phone_task = GNUNET_SCHEDULER_add_delayed(FREQ, &phone_send, NULL); 85 phone_task = GNUNET_SCHEDULER_add_delayed (FREQ, &phone_send, NULL);
86} 86}
87 87
88 88
89static void 89static void
90call_send(void *cls) 90call_send (void *cls)
91{ 91{
92 static unsigned int i; 92 static unsigned int i;
93 char buf[32]; 93 char buf[32];
94 94
95 (void)cls; 95 (void) cls;
96 GNUNET_assert(NULL != call_rdc); 96 GNUNET_assert (NULL != call_rdc);
97 GNUNET_snprintf(buf, sizeof(buf), "call-%u", i++); 97 GNUNET_snprintf (buf, sizeof(buf), "call-%u", i++);
98 call_rdc(call_rdc_cls, strlen(buf) + 1, buf); 98 call_rdc (call_rdc_cls, strlen (buf) + 1, buf);
99 call_task = GNUNET_SCHEDULER_add_delayed(FREQ, &call_send, NULL); 99 call_task = GNUNET_SCHEDULER_add_delayed (FREQ, &call_send, NULL);
100} 100}
101 101
102 102
103static int 103static int
104enable_speaker(void *cls) 104enable_speaker (void *cls)
105{ 105{
106 const char *origin = cls; 106 const char *origin = cls;
107 107
108 fprintf(stderr, "Speaker %s enabled\n", origin); 108 fprintf (stderr, "Speaker %s enabled\n", origin);
109 return GNUNET_OK; 109 return GNUNET_OK;
110} 110}
111 111
112 112
113static void 113static void
114disable_speaker(void *cls) 114disable_speaker (void *cls)
115{ 115{
116 const char *origin = cls; 116 const char *origin = cls;
117 117
118 fprintf(stderr, "Speaker %s disabled\n", origin); 118 fprintf (stderr, "Speaker %s disabled\n", origin);
119} 119}
120 120
121 121
122static void 122static void
123play(void *cls, size_t data_size, const void *data) 123play (void *cls, size_t data_size, const void *data)
124{ 124{
125 const char *origin = cls; 125 const char *origin = cls;
126 static unsigned int phone_i = 1; 126 static unsigned int phone_i = 1;
127 static unsigned int call_i; 127 static unsigned int call_i;
128 char buf[32]; 128 char buf[32];
129 129
130 if (0 == strcmp(origin, "phone")) 130 if (0 == strcmp (origin, "phone"))
131 GNUNET_snprintf(buf, sizeof(buf), "call-%u", call_i++); 131 GNUNET_snprintf (buf, sizeof(buf), "call-%u", call_i++);
132 else 132 else
133 GNUNET_snprintf(buf, sizeof(buf), "phone-%u", phone_i++); 133 GNUNET_snprintf (buf, sizeof(buf), "phone-%u", phone_i++);
134 if ((data_size != strlen(buf) + 1) || (0 != strncmp(buf, data, data_size))) 134 if ((data_size != strlen (buf) + 1) || (0 != strncmp (buf, data, data_size)))
135 { 135 {
136 fprintf(stderr, 136 fprintf (stderr,
137 "Expected %s, received %.*s\n", 137 "Expected %s, received %.*s\n",
138 buf, 138 buf,
139 (int)data_size, 139 (int) data_size,
140 (const char *)data); 140 (const char *) data);
141 } 141 }
142 else 142 else
143 { 143 {
144 fprintf(stderr, "."); 144 fprintf (stderr, ".");
145 } 145 }
146 if ((20 < call_i) && (20 < phone_i) && (NULL != call)) 146 if ((20 < call_i) && (20 < phone_i) && (NULL != call))
147 { 147 {
148 /* time to hang up ... */ 148 /* time to hang up ... */
149 GNUNET_CONVERSATION_call_stop(call); 149 GNUNET_CONVERSATION_call_stop (call);
150 call = NULL; 150 call = NULL;
151 } 151 }
152} 152}
153 153
154 154
155static void 155static void
156destroy_speaker(void *cls) 156destroy_speaker (void *cls)
157{ 157{
158 const char *origin = cls; 158 const char *origin = cls;
159 159
160 fprintf(stderr, "Speaker %s destroyed\n", origin); 160 fprintf (stderr, "Speaker %s destroyed\n", origin);
161} 161}
162 162
163 163
@@ -176,58 +176,58 @@ static struct GNUNET_SPEAKER_Handle phone_speaker = { &enable_speaker,
176 176
177 177
178static int 178static int
179enable_mic(void *cls, 179enable_mic (void *cls,
180 GNUNET_MICROPHONE_RecordedDataCallback rdc, 180 GNUNET_MICROPHONE_RecordedDataCallback rdc,
181 void *rdc_cls) 181 void *rdc_cls)
182{ 182{
183 const char *origin = cls; 183 const char *origin = cls;
184 184
185 fprintf(stderr, "Mic %s enabled\n", origin); 185 fprintf (stderr, "Mic %s enabled\n", origin);
186 if (0 == strcmp(origin, "phone")) 186 if (0 == strcmp (origin, "phone"))
187 { 187 {
188 phone_rdc = rdc; 188 phone_rdc = rdc;
189 phone_rdc_cls = rdc_cls; 189 phone_rdc_cls = rdc_cls;
190 phone_task = GNUNET_SCHEDULER_add_now(&phone_send, NULL); 190 phone_task = GNUNET_SCHEDULER_add_now (&phone_send, NULL);
191 } 191 }
192 else 192 else
193 { 193 {
194 call_rdc = rdc; 194 call_rdc = rdc;
195 call_rdc_cls = rdc_cls; 195 call_rdc_cls = rdc_cls;
196 call_task = GNUNET_SCHEDULER_add_now(&call_send, NULL); 196 call_task = GNUNET_SCHEDULER_add_now (&call_send, NULL);
197 } 197 }
198 return GNUNET_OK; 198 return GNUNET_OK;
199} 199}
200 200
201 201
202static void 202static void
203disable_mic(void *cls) 203disable_mic (void *cls)
204{ 204{
205 const char *origin = cls; 205 const char *origin = cls;
206 206
207 fprintf(stderr, "Mic %s disabled\n", origin); 207 fprintf (stderr, "Mic %s disabled\n", origin);
208 if (0 == strcmp(origin, "phone")) 208 if (0 == strcmp (origin, "phone"))
209 { 209 {
210 phone_rdc = NULL; 210 phone_rdc = NULL;
211 phone_rdc_cls = NULL; 211 phone_rdc_cls = NULL;
212 GNUNET_SCHEDULER_cancel(phone_task); 212 GNUNET_SCHEDULER_cancel (phone_task);
213 phone_task = NULL; 213 phone_task = NULL;
214 } 214 }
215 else 215 else
216 { 216 {
217 call_rdc = NULL; 217 call_rdc = NULL;
218 call_rdc_cls = NULL; 218 call_rdc_cls = NULL;
219 GNUNET_SCHEDULER_cancel(call_task); 219 GNUNET_SCHEDULER_cancel (call_task);
220 call_task = NULL; 220 call_task = NULL;
221 } 221 }
222} 222}
223 223
224 224
225static void 225static void
226destroy_mic(void *cls) 226destroy_mic (void *cls)
227{ 227{
228 const char *origin = cls; 228 const char *origin = cls;
229 229
230 fprintf(stderr, "Mic %s destroyed\n", origin); 230 fprintf (stderr, "Mic %s destroyed\n", origin);
231} 231}
232 232
233 233
@@ -249,254 +249,254 @@ static struct GNUNET_MICROPHONE_Handle phone_mic = { &enable_mic,
249 * @param cls closure 249 * @param cls closure
250 */ 250 */
251static void 251static void
252end_test(void *cls) 252end_test (void *cls)
253{ 253{
254 (void)cls; 254 (void) cls;
255 GNUNET_SCHEDULER_shutdown(); 255 GNUNET_SCHEDULER_shutdown ();
256 if (NULL != op) 256 if (NULL != op)
257 { 257 {
258 GNUNET_IDENTITY_cancel(op); 258 GNUNET_IDENTITY_cancel (op);
259 op = NULL; 259 op = NULL;
260 } 260 }
261 if (NULL != call) 261 if (NULL != call)
262 { 262 {
263 GNUNET_CONVERSATION_call_stop(call); 263 GNUNET_CONVERSATION_call_stop (call);
264 call = NULL; 264 call = NULL;
265 } 265 }
266 if (NULL != phone) 266 if (NULL != phone)
267 { 267 {
268 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from PHONE service.\n"); 268 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from PHONE service.\n");
269 GNUNET_CONVERSATION_phone_destroy(phone); 269 GNUNET_CONVERSATION_phone_destroy (phone);
270 phone = NULL; 270 phone = NULL;
271 } 271 }
272 if (NULL != id) 272 if (NULL != id)
273 { 273 {
274 GNUNET_IDENTITY_disconnect(id); 274 GNUNET_IDENTITY_disconnect (id);
275 id = NULL; 275 id = NULL;
276 } 276 }
277 if (NULL != qe) 277 if (NULL != qe)
278 { 278 {
279 GNUNET_NAMESTORE_cancel(qe); 279 GNUNET_NAMESTORE_cancel (qe);
280 qe = NULL; 280 qe = NULL;
281 } 281 }
282 if (NULL != ns) 282 if (NULL != ns)
283 { 283 {
284 GNUNET_NAMESTORE_disconnect(ns); 284 GNUNET_NAMESTORE_disconnect (ns);
285 ns = NULL; 285 ns = NULL;
286 } 286 }
287} 287}
288 288
289 289
290static void 290static void
291caller_event_handler(void *cls, enum GNUNET_CONVERSATION_CallerEventCode code) 291caller_event_handler (void *cls, enum GNUNET_CONVERSATION_CallerEventCode code)
292{ 292{
293 (void)cls; 293 (void) cls;
294 switch (code) 294 switch (code)
295 { 295 {
296 case GNUNET_CONVERSATION_EC_CALLER_SUSPEND: 296 case GNUNET_CONVERSATION_EC_CALLER_SUSPEND:
297 case GNUNET_CONVERSATION_EC_CALLER_RESUME: 297 case GNUNET_CONVERSATION_EC_CALLER_RESUME:
298 fprintf(stderr, "Unexpected caller code: %d\n", code); 298 fprintf (stderr, "Unexpected caller code: %d\n", code);
299 break; 299 break;
300 } 300 }
301} 301}
302 302
303 303
304static void 304static void
305phone_event_handler(void *cls, 305phone_event_handler (void *cls,
306 enum GNUNET_CONVERSATION_PhoneEventCode code, 306 enum GNUNET_CONVERSATION_PhoneEventCode code,
307 struct GNUNET_CONVERSATION_Caller *caller, 307 struct GNUNET_CONVERSATION_Caller *caller,
308 const struct GNUNET_CRYPTO_EcdsaPublicKey *caller_id) 308 const struct GNUNET_CRYPTO_EcdsaPublicKey *caller_id)
309{ 309{
310 static enum GNUNET_CONVERSATION_PhoneEventCode expect = 310 static enum GNUNET_CONVERSATION_PhoneEventCode expect =
311 GNUNET_CONVERSATION_EC_PHONE_RING; 311 GNUNET_CONVERSATION_EC_PHONE_RING;
312 312
313 (void)cls; 313 (void) cls;
314 (void)caller_id; 314 (void) caller_id;
315 GNUNET_break(code == expect); 315 GNUNET_break (code == expect);
316 switch (code) 316 switch (code)
317 { 317 {
318 case GNUNET_CONVERSATION_EC_PHONE_RING: 318 case GNUNET_CONVERSATION_EC_PHONE_RING:
319 active_caller = caller; 319 active_caller = caller;
320 GNUNET_CONVERSATION_caller_pick_up(caller, 320 GNUNET_CONVERSATION_caller_pick_up (caller,
321 &caller_event_handler, 321 &caller_event_handler,
322 NULL, 322 NULL,
323 &phone_speaker, 323 &phone_speaker,
324 &phone_mic); 324 &phone_mic);
325 expect = GNUNET_CONVERSATION_EC_PHONE_HUNG_UP; 325 expect = GNUNET_CONVERSATION_EC_PHONE_HUNG_UP;
326 break; 326 break;
327 327
328 case GNUNET_CONVERSATION_EC_PHONE_HUNG_UP: 328 case GNUNET_CONVERSATION_EC_PHONE_HUNG_UP:
329 GNUNET_break(caller == active_caller); 329 GNUNET_break (caller == active_caller);
330 active_caller = NULL; 330 active_caller = NULL;
331 if (1 == ok) 331 if (1 == ok)
332 ok = 0; 332 ok = 0;
333 GNUNET_SCHEDULER_shutdown(); 333 GNUNET_SCHEDULER_shutdown ();
334 break; 334 break;
335 335
336 default: 336 default:
337 fprintf(stderr, "Unexpected phone code: %d\n", code); 337 fprintf (stderr, "Unexpected phone code: %d\n", code);
338 break; 338 break;
339 } 339 }
340} 340}
341 341
342 342
343static void 343static void
344call_event_handler(void *cls, enum GNUNET_CONVERSATION_CallEventCode code) 344call_event_handler (void *cls, enum GNUNET_CONVERSATION_CallEventCode code)
345{ 345{
346 static enum GNUNET_CONVERSATION_CallEventCode expect = 346 static enum GNUNET_CONVERSATION_CallEventCode expect =
347 GNUNET_CONVERSATION_EC_CALL_RINGING; 347 GNUNET_CONVERSATION_EC_CALL_RINGING;
348 348
349 (void)cls; 349 (void) cls;
350 GNUNET_break(code == expect); 350 GNUNET_break (code == expect);
351 switch (code) 351 switch (code)
352 { 352 {
353 case GNUNET_CONVERSATION_EC_CALL_RINGING: 353 case GNUNET_CONVERSATION_EC_CALL_RINGING:
354 expect = GNUNET_CONVERSATION_EC_CALL_PICKED_UP; 354 expect = GNUNET_CONVERSATION_EC_CALL_PICKED_UP;
355 break; 355 break;
356 356
357 case GNUNET_CONVERSATION_EC_CALL_PICKED_UP: 357 case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
358 expect = -1; 358 expect = -1;
359 break; 359 break;
360 360
361 case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL: 361 case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
362 case GNUNET_CONVERSATION_EC_CALL_HUNG_UP: 362 case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
363 call = NULL; 363 call = NULL;
364 ok = 2; 364 ok = 2;
365 GNUNET_break(0); 365 GNUNET_break (0);
366 fprintf(stderr, "Unexpected call code: %d\n", code); 366 fprintf (stderr, "Unexpected call code: %d\n", code);
367 break; 367 break;
368 368
369 case GNUNET_CONVERSATION_EC_CALL_SUSPENDED: 369 case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
370 case GNUNET_CONVERSATION_EC_CALL_RESUMED: 370 case GNUNET_CONVERSATION_EC_CALL_RESUMED:
371 GNUNET_break(0); 371 GNUNET_break (0);
372 fprintf(stderr, "Unexpected call code: %d\n", code); 372 fprintf (stderr, "Unexpected call code: %d\n", code);
373 ok = 2; 373 ok = 2;
374 break; 374 break;
375 375
376 case GNUNET_CONVERSATION_EC_CALL_ERROR: 376 case GNUNET_CONVERSATION_EC_CALL_ERROR:
377 GNUNET_break(0); 377 GNUNET_break (0);
378 fprintf(stderr, "Unexpected call code: %d\n", code); 378 fprintf (stderr, "Unexpected call code: %d\n", code);
379 call = NULL; 379 call = NULL;
380 ok = 2; 380 ok = 2;
381 break; 381 break;
382 } 382 }
383} 383}
384 384
385 385
386static void 386static void
387caller_ego_create_cont(void *cls, 387caller_ego_create_cont (void *cls,
388 const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk, 388 const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk,
389 const char *emsg) 389 const char *emsg)
390{ 390{
391 (void)cls; 391 (void) cls;
392 op = NULL; 392 op = NULL;
393 GNUNET_assert(NULL == emsg); 393 GNUNET_assert (NULL == emsg);
394} 394}
395 395
396 396
397static void 397static void
398namestore_put_cont(void *cls, int32_t success, const char *emsg) 398namestore_put_cont (void *cls, int32_t success, const char *emsg)
399{ 399{
400 (void)cls; 400 (void) cls;
401 qe = NULL; 401 qe = NULL;
402 GNUNET_assert(GNUNET_YES == success); 402 GNUNET_assert (GNUNET_YES == success);
403 GNUNET_assert(NULL == emsg); 403 GNUNET_assert (NULL == emsg);
404 GNUNET_assert(NULL == op); 404 GNUNET_assert (NULL == op);
405 op = GNUNET_IDENTITY_create(id, "caller-ego", &caller_ego_create_cont, NULL); 405 op = GNUNET_IDENTITY_create (id, "caller-ego", &caller_ego_create_cont, NULL);
406} 406}
407 407
408 408
409static void 409static void
410identity_cb(void *cls, 410identity_cb (void *cls,
411 struct GNUNET_IDENTITY_Ego *ego, 411 struct GNUNET_IDENTITY_Ego *ego,
412 void **ctx, 412 void **ctx,
413 const char *name) 413 const char *name)
414{ 414{
415 struct GNUNET_GNSRECORD_Data rd; 415 struct GNUNET_GNSRECORD_Data rd;
416 struct GNUNET_CRYPTO_EcdsaPublicKey pub; 416 struct GNUNET_CRYPTO_EcdsaPublicKey pub;
417 417
418 (void)cls; 418 (void) cls;
419 (void)ctx; 419 (void) ctx;
420 if (NULL == name) 420 if (NULL == name)
421 return; 421 return;
422 if (NULL == ego) 422 if (NULL == ego)
423 return; 423 return;
424 if (0 == strcmp(name, "phone-ego")) 424 if (0 == strcmp (name, "phone-ego"))
425 { 425 {
426 GNUNET_IDENTITY_ego_get_public_key(ego, &pub); 426 GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
427 GNUNET_asprintf(&gns_name, 427 GNUNET_asprintf (&gns_name,
428 "phone.%s", 428 "phone.%s",
429 GNUNET_GNSRECORD_pkey_to_zkey(&pub)); 429 GNUNET_GNSRECORD_pkey_to_zkey (&pub));
430 phone = 430 phone =
431 GNUNET_CONVERSATION_phone_create(cfg, ego, &phone_event_handler, NULL); 431 GNUNET_CONVERSATION_phone_create (cfg, ego, &phone_event_handler, NULL);
432 GNUNET_assert(NULL != phone); 432 GNUNET_assert (NULL != phone);
433 memset(&rd, 0, sizeof(rd)); 433 memset (&rd, 0, sizeof(rd));
434 GNUNET_CONVERSATION_phone_get_record(phone, &rd); 434 GNUNET_CONVERSATION_phone_get_record (phone, &rd);
435 GNUNET_assert(rd.record_type == GNUNET_GNSRECORD_TYPE_PHONE); 435 GNUNET_assert (rd.record_type == GNUNET_GNSRECORD_TYPE_PHONE);
436 rd.expiration_time = UINT64_MAX; 436 rd.expiration_time = UINT64_MAX;
437 qe = 437 qe =
438 GNUNET_NAMESTORE_records_store(ns, 438 GNUNET_NAMESTORE_records_store (ns,
439 GNUNET_IDENTITY_ego_get_private_key(ego), 439 GNUNET_IDENTITY_ego_get_private_key (ego),
440 "phone" /* GNS label */, 440 "phone" /* GNS label */,
441 1, 441 1,
442 &rd, 442 &rd,
443 &namestore_put_cont, 443 &namestore_put_cont,
444 NULL); 444 NULL);
445 return; 445 return;
446 } 446 }
447 if (0 == strcmp(name, "caller-ego")) 447 if (0 == strcmp (name, "caller-ego"))
448 { 448 {
449 GNUNET_IDENTITY_ego_get_public_key(ego, &pub); 449 GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
450 GNUNET_asprintf(&gns_caller_id, 450 GNUNET_asprintf (&gns_caller_id,
451 "%s", 451 "%s",
452 GNUNET_GNSRECORD_pkey_to_zkey(&pub)); 452 GNUNET_GNSRECORD_pkey_to_zkey (&pub));
453 call = GNUNET_CONVERSATION_call_start(cfg, 453 call = GNUNET_CONVERSATION_call_start (cfg,
454 ego, 454 ego,
455 gns_name, 455 gns_name,
456 &call_speaker, 456 &call_speaker,
457 &call_mic, 457 &call_mic,
458 &call_event_handler, 458 &call_event_handler,
459 NULL); 459 NULL);
460 return; 460 return;
461 } 461 }
462} 462}
463 463
464 464
465static void 465static void
466phone_ego_create_cont(void *cls, 466phone_ego_create_cont (void *cls,
467 const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk, 467 const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk,
468 const char *emsg) 468 const char *emsg)
469{ 469{
470 (void)cls; 470 (void) cls;
471 op = NULL; 471 op = NULL;
472 GNUNET_assert(NULL == emsg); 472 GNUNET_assert (NULL == emsg);
473} 473}
474 474
475 475
476static void 476static void
477run(void *cls, 477run (void *cls,
478 const struct GNUNET_CONFIGURATION_Handle *c, 478 const struct GNUNET_CONFIGURATION_Handle *c,
479 struct GNUNET_TESTING_Peer *peer) 479 struct GNUNET_TESTING_Peer *peer)
480{ 480{
481 (void)cls; 481 (void) cls;
482 (void)peer; 482 (void) peer;
483 cfg = c; 483 cfg = c;
484 GNUNET_SCHEDULER_add_delayed(TIMEOUT, &end_test, NULL); 484 GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_test, NULL);
485 id = GNUNET_IDENTITY_connect(cfg, &identity_cb, NULL); 485 id = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL);
486 op = GNUNET_IDENTITY_create(id, "phone-ego", &phone_ego_create_cont, NULL); 486 op = GNUNET_IDENTITY_create (id, "phone-ego", &phone_ego_create_cont, NULL);
487 ns = GNUNET_NAMESTORE_connect(cfg); 487 ns = GNUNET_NAMESTORE_connect (cfg);
488} 488}
489 489
490 490
491int 491int
492main(int argc, char *argv[]) 492main (int argc, char *argv[])
493{ 493{
494 (void)argc; 494 (void) argc;
495 (void)argv; 495 (void) argv;
496 if (0 != GNUNET_TESTING_peer_run("test_conversation_api", 496 if (0 != GNUNET_TESTING_peer_run ("test_conversation_api",
497 "test_conversation.conf", 497 "test_conversation.conf",
498 &run, 498 &run,
499 NULL)) 499 NULL))
500 return 1; 500 return 1;
501 return ok; 501 return ok;
502} 502}