aboutsummaryrefslogtreecommitdiff
path: root/src/conversation/conversation_api_call.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/conversation/conversation_api_call.c')
-rw-r--r--src/conversation/conversation_api_call.c695
1 files changed, 350 insertions, 345 deletions
diff --git a/src/conversation/conversation_api_call.c b/src/conversation/conversation_api_call.c
index 08fab57b4..2be7886fa 100644
--- a/src/conversation/conversation_api_call.c
+++ b/src/conversation/conversation_api_call.c
@@ -35,7 +35,8 @@
35/** 35/**
36 * Possible states of the phone. 36 * Possible states of the phone.
37 */ 37 */
38enum CallState { 38enum CallState
39{
39 /** 40 /**
40 * We still need to lookup the callee. 41 * We still need to lookup the callee.
41 */ 42 */
@@ -76,7 +77,8 @@ enum CallState {
76/** 77/**
77 * Handle for an outgoing call. 78 * Handle for an outgoing call.
78 */ 79 */
79struct GNUNET_CONVERSATION_Call { 80struct GNUNET_CONVERSATION_Call
81{
80 /** 82 /**
81 * Our configuration. 83 * Our configuration.
82 */ 84 */
@@ -145,7 +147,7 @@ struct GNUNET_CONVERSATION_Call {
145 * @param call call to reconnect 147 * @param call call to reconnect
146 */ 148 */
147static void 149static void
148fail_call(struct GNUNET_CONVERSATION_Call *call); 150fail_call (struct GNUNET_CONVERSATION_Call *call);
149 151
150 152
151/** 153/**
@@ -156,23 +158,23 @@ fail_call(struct GNUNET_CONVERSATION_Call *call);
156 * @param data audio data to play 158 * @param data audio data to play
157 */ 159 */
158static void 160static void
159transmit_call_audio(void *cls, 161transmit_call_audio (void *cls,
160 size_t data_size, 162 size_t data_size,
161 const void *data) 163 const void *data)
162{ 164{
163 struct GNUNET_CONVERSATION_Call *call = cls; 165 struct GNUNET_CONVERSATION_Call *call = cls;
164 struct GNUNET_MQ_Envelope *e; 166 struct GNUNET_MQ_Envelope *e;
165 struct ClientAudioMessage *am; 167 struct ClientAudioMessage *am;
166 168
167 GNUNET_assert(CS_ACTIVE == call->state); 169 GNUNET_assert (CS_ACTIVE == call->state);
168 e = GNUNET_MQ_msg_extra(am, 170 e = GNUNET_MQ_msg_extra (am,
169 data_size, 171 data_size,
170 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO); 172 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO);
171 GNUNET_memcpy(&am[1], 173 GNUNET_memcpy (&am[1],
172 data, 174 data,
173 data_size); 175 data_size);
174 GNUNET_MQ_send(call->mq, 176 GNUNET_MQ_send (call->mq,
175 e); 177 e);
176} 178}
177 179
178 180
@@ -183,47 +185,47 @@ transmit_call_audio(void *cls,
183 * @param msg the message 185 * @param msg the message
184 */ 186 */
185static void 187static void
186handle_call_suspend(void *cls, 188handle_call_suspend (void *cls,
187 const struct ClientPhoneSuspendMessage *msg) 189 const struct ClientPhoneSuspendMessage *msg)
188{ 190{
189 struct GNUNET_CONVERSATION_Call *call = cls; 191 struct GNUNET_CONVERSATION_Call *call = cls;
190 192
191 (void)msg; 193 (void) msg;
192 switch (call->state) 194 switch (call->state)
193 { 195 {
194 case CS_LOOKUP: 196 case CS_LOOKUP:
195 GNUNET_break(0); 197 GNUNET_break (0);
196 fail_call(call); 198 fail_call (call);
197 break; 199 break;
198 200
199 case CS_RINGING: 201 case CS_RINGING:
200 GNUNET_break_op(0); 202 GNUNET_break_op (0);
201 fail_call(call); 203 fail_call (call);
202 break; 204 break;
203 205
204 case CS_SUSPENDED_CALLER: 206 case CS_SUSPENDED_CALLER:
205 call->state = CS_SUSPENDED_BOTH; 207 call->state = CS_SUSPENDED_BOTH;
206 call->event_handler(call->event_handler_cls, 208 call->event_handler (call->event_handler_cls,
207 GNUNET_CONVERSATION_EC_CALL_SUSPENDED); 209 GNUNET_CONVERSATION_EC_CALL_SUSPENDED);
208 break; 210 break;
209 211
210 case CS_SUSPENDED_CALLEE: 212 case CS_SUSPENDED_CALLEE:
211 case CS_SUSPENDED_BOTH: 213 case CS_SUSPENDED_BOTH:
212 GNUNET_break_op(0); 214 GNUNET_break_op (0);
213 break; 215 break;
214 216
215 case CS_ACTIVE: 217 case CS_ACTIVE:
216 call->state = CS_SUSPENDED_CALLEE; 218 call->state = CS_SUSPENDED_CALLEE;
217 call->speaker->disable_speaker(call->speaker->cls); 219 call->speaker->disable_speaker (call->speaker->cls);
218 call->mic->disable_microphone(call->mic->cls); 220 call->mic->disable_microphone (call->mic->cls);
219 call->event_handler(call->event_handler_cls, 221 call->event_handler (call->event_handler_cls,
220 GNUNET_CONVERSATION_EC_CALL_SUSPENDED); 222 GNUNET_CONVERSATION_EC_CALL_SUSPENDED);
221 break; 223 break;
222 224
223 case CS_SHUTDOWN: 225 case CS_SHUTDOWN:
224 GNUNET_CONVERSATION_call_stop(call); 226 GNUNET_CONVERSATION_call_stop (call);
225 break; 227 break;
226 } 228 }
227} 229}
228 230
229 231
@@ -234,52 +236,52 @@ handle_call_suspend(void *cls,
234 * @param msg the message 236 * @param msg the message
235 */ 237 */
236static void 238static void
237handle_call_resume(void *cls, 239handle_call_resume (void *cls,
238 const struct ClientPhoneResumeMessage *msg) 240 const struct ClientPhoneResumeMessage *msg)
239{ 241{
240 struct GNUNET_CONVERSATION_Call *call = cls; 242 struct GNUNET_CONVERSATION_Call *call = cls;
241 243
242 (void)msg; 244 (void) msg;
243 switch (call->state) 245 switch (call->state)
244 { 246 {
245 case CS_LOOKUP: 247 case CS_LOOKUP:
246 GNUNET_break(0); 248 GNUNET_break (0);
247 fail_call(call); 249 fail_call (call);
248 break; 250 break;
249 251
250 case CS_RINGING: 252 case CS_RINGING:
251 GNUNET_break_op(0); 253 GNUNET_break_op (0);
252 fail_call(call); 254 fail_call (call);
253 break; 255 break;
254 256
255 case CS_SUSPENDED_CALLER: 257 case CS_SUSPENDED_CALLER:
256 GNUNET_break_op(0); 258 GNUNET_break_op (0);
257 break; 259 break;
258 260
259 case CS_SUSPENDED_CALLEE: 261 case CS_SUSPENDED_CALLEE:
260 call->state = CS_ACTIVE; 262 call->state = CS_ACTIVE;
261 call->speaker->enable_speaker(call->speaker->cls); 263 call->speaker->enable_speaker (call->speaker->cls);
262 call->mic->enable_microphone(call->mic->cls, 264 call->mic->enable_microphone (call->mic->cls,
263 &transmit_call_audio, 265 &transmit_call_audio,
264 call); 266 call);
265 call->event_handler(call->event_handler_cls, 267 call->event_handler (call->event_handler_cls,
266 GNUNET_CONVERSATION_EC_CALL_RESUMED); 268 GNUNET_CONVERSATION_EC_CALL_RESUMED);
267 break; 269 break;
268 270
269 case CS_SUSPENDED_BOTH: 271 case CS_SUSPENDED_BOTH:
270 call->state = CS_SUSPENDED_CALLER; 272 call->state = CS_SUSPENDED_CALLER;
271 call->event_handler(call->event_handler_cls, 273 call->event_handler (call->event_handler_cls,
272 GNUNET_CONVERSATION_EC_CALL_RESUMED); 274 GNUNET_CONVERSATION_EC_CALL_RESUMED);
273 break; 275 break;
274 276
275 case CS_ACTIVE: 277 case CS_ACTIVE:
276 GNUNET_break_op(0); 278 GNUNET_break_op (0);
277 break; 279 break;
278 280
279 case CS_SHUTDOWN: 281 case CS_SHUTDOWN:
280 GNUNET_CONVERSATION_call_stop(call); 282 GNUNET_CONVERSATION_call_stop (call);
281 break; 283 break;
282 } 284 }
283} 285}
284 286
285 287
@@ -290,41 +292,41 @@ handle_call_resume(void *cls,
290 * @param msg the message 292 * @param msg the message
291 */ 293 */
292static void 294static void
293handle_call_picked_up(void *cls, 295handle_call_picked_up (void *cls,
294 const struct ClientPhonePickedupMessage *msg) 296 const struct ClientPhonePickedupMessage *msg)
295{ 297{
296 struct GNUNET_CONVERSATION_Call *call = cls; 298 struct GNUNET_CONVERSATION_Call *call = cls;
297 299
298 (void)msg; 300 (void) msg;
299 switch (call->state) 301 switch (call->state)
300 { 302 {
301 case CS_LOOKUP: 303 case CS_LOOKUP:
302 GNUNET_break(0); 304 GNUNET_break (0);
303 fail_call(call); 305 fail_call (call);
304 break; 306 break;
305 307
306 case CS_RINGING: 308 case CS_RINGING:
307 call->state = CS_ACTIVE; 309 call->state = CS_ACTIVE;
308 call->speaker->enable_speaker(call->speaker->cls); 310 call->speaker->enable_speaker (call->speaker->cls);
309 call->mic->enable_microphone(call->mic->cls, 311 call->mic->enable_microphone (call->mic->cls,
310 &transmit_call_audio, 312 &transmit_call_audio,
311 call); 313 call);
312 call->event_handler(call->event_handler_cls, 314 call->event_handler (call->event_handler_cls,
313 GNUNET_CONVERSATION_EC_CALL_PICKED_UP); 315 GNUNET_CONVERSATION_EC_CALL_PICKED_UP);
314 break; 316 break;
315 317
316 case CS_SUSPENDED_CALLER: 318 case CS_SUSPENDED_CALLER:
317 case CS_SUSPENDED_CALLEE: 319 case CS_SUSPENDED_CALLEE:
318 case CS_SUSPENDED_BOTH: 320 case CS_SUSPENDED_BOTH:
319 case CS_ACTIVE: 321 case CS_ACTIVE:
320 GNUNET_break(0); 322 GNUNET_break (0);
321 fail_call(call); 323 fail_call (call);
322 break; 324 break;
323 325
324 case CS_SHUTDOWN: 326 case CS_SHUTDOWN:
325 GNUNET_CONVERSATION_call_stop(call); 327 GNUNET_CONVERSATION_call_stop (call);
326 break; 328 break;
327 } 329 }
328} 330}
329 331
330 332
@@ -335,37 +337,37 @@ handle_call_picked_up(void *cls,
335 * @param msg the message 337 * @param msg the message
336 */ 338 */
337static void 339static void
338handle_call_hangup(void *cls, 340handle_call_hangup (void *cls,
339 const struct ClientPhoneHangupMessage *msg) 341 const struct ClientPhoneHangupMessage *msg)
340{ 342{
341 struct GNUNET_CONVERSATION_Call *call = cls; 343 struct GNUNET_CONVERSATION_Call *call = cls;
342 GNUNET_CONVERSATION_CallEventHandler eh; 344 GNUNET_CONVERSATION_CallEventHandler eh;
343 void *eh_cls; 345 void *eh_cls;
344 346
345 (void)msg; 347 (void) msg;
346 switch (call->state) 348 switch (call->state)
347 { 349 {
348 case CS_LOOKUP: 350 case CS_LOOKUP:
349 GNUNET_break(0); 351 GNUNET_break (0);
350 fail_call(call); 352 fail_call (call);
351 break; 353 break;
352 354
353 case CS_RINGING: 355 case CS_RINGING:
354 case CS_SUSPENDED_CALLER: 356 case CS_SUSPENDED_CALLER:
355 case CS_SUSPENDED_CALLEE: 357 case CS_SUSPENDED_CALLEE:
356 case CS_SUSPENDED_BOTH: 358 case CS_SUSPENDED_BOTH:
357 case CS_ACTIVE: 359 case CS_ACTIVE:
358 eh = call->event_handler; 360 eh = call->event_handler;
359 eh_cls = call->event_handler_cls; 361 eh_cls = call->event_handler_cls;
360 GNUNET_CONVERSATION_call_stop(call); 362 GNUNET_CONVERSATION_call_stop (call);
361 eh(eh_cls, 363 eh (eh_cls,
362 GNUNET_CONVERSATION_EC_CALL_HUNG_UP); 364 GNUNET_CONVERSATION_EC_CALL_HUNG_UP);
363 return; 365 return;
364 366
365 case CS_SHUTDOWN: 367 case CS_SHUTDOWN:
366 GNUNET_CONVERSATION_call_stop(call); 368 GNUNET_CONVERSATION_call_stop (call);
367 break; 369 break;
368 } 370 }
369} 371}
370 372
371 373
@@ -377,11 +379,11 @@ handle_call_hangup(void *cls,
377 * @return #GNUNET_OK (always well-formed) 379 * @return #GNUNET_OK (always well-formed)
378 */ 380 */
379static int 381static int
380check_call_audio(void *cls, 382check_call_audio (void *cls,
381 const struct ClientAudioMessage *am) 383 const struct ClientAudioMessage *am)
382{ 384{
383 (void)cls; 385 (void) cls;
384 (void)am; 386 (void) am;
385 /* any payload is OK */ 387 /* any payload is OK */
386 return GNUNET_OK; 388 return GNUNET_OK;
387} 389}
@@ -394,44 +396,45 @@ check_call_audio(void *cls,
394 * @param msg the message 396 * @param msg the message
395 */ 397 */
396static void 398static void
397handle_call_audio(void *cls, 399handle_call_audio (void *cls,
398 const struct ClientAudioMessage *am) 400 const struct ClientAudioMessage *am)
399{ 401{
400 struct GNUNET_CONVERSATION_Call *call = cls; 402 struct GNUNET_CONVERSATION_Call *call = cls;
401 403
402 switch (call->state) 404 switch (call->state)
403 { 405 {
404 case CS_LOOKUP: 406 case CS_LOOKUP:
405 GNUNET_break(0); 407 GNUNET_break (0);
406 fail_call(call); 408 fail_call (call);
407 break; 409 break;
408 410
409 case CS_RINGING: 411 case CS_RINGING:
410 GNUNET_break(0); 412 GNUNET_break (0);
411 fail_call(call); 413 fail_call (call);
412 break; 414 break;
413 415
414 case CS_SUSPENDED_CALLER: 416 case CS_SUSPENDED_CALLER:
415 /* can happen: we suspended, other peer did not yet 417 /* can happen: we suspended, other peer did not yet
416 learn about this. */ 418 learn about this. */
417 break; 419 break;
418 420
419 case CS_SUSPENDED_CALLEE: 421 case CS_SUSPENDED_CALLEE:
420 case CS_SUSPENDED_BOTH: 422 case CS_SUSPENDED_BOTH:
421 /* can (rarely) also happen: other peer suspended, but cadet might 423 /* can (rarely) also happen: other peer suspended, but cadet might
422 have had delayed data on the unreliable channel */ 424 have had delayed data on the unreliable channel */
423 break; 425 break;
424 426
425 case CS_ACTIVE: 427 case CS_ACTIVE:
426 call->speaker->play(call->speaker->cls, 428 call->speaker->play (call->speaker->cls,
427 ntohs(am->header.size) - sizeof(struct ClientAudioMessage), 429 ntohs (am->header.size) - sizeof(struct
428 &am[1]); 430 ClientAudioMessage),
429 break; 431 &am[1]);
430 432 break;
431 case CS_SHUTDOWN: 433
432 GNUNET_CONVERSATION_call_stop(call); 434 case CS_SHUTDOWN:
433 break; 435 GNUNET_CONVERSATION_call_stop (call);
434 } 436 break;
437 }
435} 438}
436 439
437 440
@@ -444,48 +447,48 @@ handle_call_audio(void *cls,
444 * @param rd the records in reply 447 * @param rd the records in reply
445 */ 448 */
446static void 449static void
447handle_gns_response(void *cls, 450handle_gns_response (void *cls,
448 int was_gns, 451 int was_gns,
449 uint32_t rd_count, 452 uint32_t rd_count,
450 const struct GNUNET_GNSRECORD_Data *rd) 453 const struct GNUNET_GNSRECORD_Data *rd)
451{ 454{
452 struct GNUNET_CONVERSATION_Call *call = cls; 455 struct GNUNET_CONVERSATION_Call *call = cls;
453 struct GNUNET_MQ_Envelope *e; 456 struct GNUNET_MQ_Envelope *e;
454 struct ClientCallMessage *ccm; 457 struct ClientCallMessage *ccm;
455 458
456 (void)was_gns; 459 (void) was_gns;
457 GNUNET_break(NULL != call->gns_lookup); 460 GNUNET_break (NULL != call->gns_lookup);
458 GNUNET_break(CS_LOOKUP == call->state); 461 GNUNET_break (CS_LOOKUP == call->state);
459 call->gns_lookup = NULL; 462 call->gns_lookup = NULL;
460 for (uint32_t i = 0; i < rd_count; i++) 463 for (uint32_t i = 0; i < rd_count; i++)
464 {
465 if (GNUNET_GNSRECORD_TYPE_PHONE == rd[i].record_type)
461 { 466 {
462 if (GNUNET_GNSRECORD_TYPE_PHONE == rd[i].record_type) 467 if (rd[i].data_size != sizeof(struct GNUNET_CONVERSATION_PhoneRecord))
463 { 468 {
464 if (rd[i].data_size != sizeof(struct GNUNET_CONVERSATION_PhoneRecord)) 469 GNUNET_break_op (0);
465 { 470 continue;
466 GNUNET_break_op(0); 471 }
467 continue; 472 GNUNET_memcpy (&call->phone_record,
468 } 473 rd[i].data,
469 GNUNET_memcpy(&call->phone_record, 474 rd[i].data_size);
470 rd[i].data, 475 e = GNUNET_MQ_msg (ccm,
471 rd[i].data_size); 476 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL);
472 e = GNUNET_MQ_msg(ccm, 477 ccm->line_port = call->phone_record.line_port;
473 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL); 478 ccm->target = call->phone_record.peer;
474 ccm->line_port = call->phone_record.line_port; 479 ccm->caller_id = *GNUNET_IDENTITY_ego_get_private_key (call->caller_id);
475 ccm->target = call->phone_record.peer; 480 GNUNET_MQ_send (call->mq,
476 ccm->caller_id = *GNUNET_IDENTITY_ego_get_private_key(call->caller_id); 481 e);
477 GNUNET_MQ_send(call->mq, 482 call->state = CS_RINGING;
478 e); 483 call->event_handler (call->event_handler_cls,
479 call->state = CS_RINGING; 484 GNUNET_CONVERSATION_EC_CALL_RINGING);
480 call->event_handler(call->event_handler_cls, 485 return;
481 GNUNET_CONVERSATION_EC_CALL_RINGING);
482 return;
483 }
484 } 486 }
487 }
485 /* not found */ 488 /* not found */
486 call->event_handler(call->event_handler_cls, 489 call->event_handler (call->event_handler_cls,
487 GNUNET_CONVERSATION_EC_CALL_GNS_FAIL); 490 GNUNET_CONVERSATION_EC_CALL_GNS_FAIL);
488 GNUNET_CONVERSATION_call_stop(call); 491 GNUNET_CONVERSATION_call_stop (call);
489} 492}
490 493
491 494
@@ -496,20 +499,21 @@ handle_gns_response(void *cls,
496 * @param error details about the error 499 * @param error details about the error
497 */ 500 */
498static void 501static void
499call_error_handler(void *cls, 502call_error_handler (void *cls,
500 enum GNUNET_MQ_Error error) 503 enum GNUNET_MQ_Error error)
501{ 504{
502 struct GNUNET_CONVERSATION_Call *call = cls; 505 struct GNUNET_CONVERSATION_Call *call = cls;
503 506
504 (void)error; 507 (void) error;
505 if (CS_SHUTDOWN == call->state) 508 if (CS_SHUTDOWN == call->state)
506 { 509 {
507 GNUNET_CONVERSATION_call_stop(call); 510 GNUNET_CONVERSATION_call_stop (call);
508 return; 511 return;
509 } 512 }
510 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 513 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
511 _("Connection to conversation service lost, trying to reconnect\n")); 514 _ (
512 fail_call(call); 515 "Connection to conversation service lost, trying to reconnect\n"));
516 fail_call (call);
513} 517}
514 518
515 519
@@ -519,22 +523,22 @@ call_error_handler(void *cls,
519 * @param call call to reconnect 523 * @param call call to reconnect
520 */ 524 */
521static void 525static void
522fail_call(struct GNUNET_CONVERSATION_Call *call) 526fail_call (struct GNUNET_CONVERSATION_Call *call)
523{ 527{
524 if (CS_ACTIVE == call->state) 528 if (CS_ACTIVE == call->state)
525 { 529 {
526 call->speaker->disable_speaker(call->speaker->cls); 530 call->speaker->disable_speaker (call->speaker->cls);
527 call->mic->disable_microphone(call->mic->cls); 531 call->mic->disable_microphone (call->mic->cls);
528 } 532 }
529 if (NULL != call->mq) 533 if (NULL != call->mq)
530 { 534 {
531 GNUNET_MQ_destroy(call->mq); 535 GNUNET_MQ_destroy (call->mq);
532 call->mq = NULL; 536 call->mq = NULL;
533 } 537 }
534 call->state = CS_SHUTDOWN; 538 call->state = CS_SHUTDOWN;
535 call->event_handler(call->event_handler_cls, 539 call->event_handler (call->event_handler_cls,
536 GNUNET_CONVERSATION_EC_CALL_ERROR); 540 GNUNET_CONVERSATION_EC_CALL_ERROR);
537 GNUNET_CONVERSATION_call_stop(call); 541 GNUNET_CONVERSATION_call_stop (call);
538} 542}
539 543
540 544
@@ -554,76 +558,77 @@ fail_call(struct GNUNET_CONVERSATION_Call *call)
554 * @return handle for the call, NULL on hard errors 558 * @return handle for the call, NULL on hard errors
555 */ 559 */
556struct GNUNET_CONVERSATION_Call * 560struct GNUNET_CONVERSATION_Call *
557GNUNET_CONVERSATION_call_start(const struct GNUNET_CONFIGURATION_Handle *cfg, 561GNUNET_CONVERSATION_call_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
558 struct GNUNET_IDENTITY_Ego *caller_id, 562 struct GNUNET_IDENTITY_Ego *caller_id,
559 const char *callee, 563 const char *callee,
560 struct GNUNET_SPEAKER_Handle *speaker, 564 struct GNUNET_SPEAKER_Handle *speaker,
561 struct GNUNET_MICROPHONE_Handle *mic, 565 struct GNUNET_MICROPHONE_Handle *mic,
562 GNUNET_CONVERSATION_CallEventHandler event_handler, 566 GNUNET_CONVERSATION_CallEventHandler
563 void *event_handler_cls) 567 event_handler,
568 void *event_handler_cls)
564{ 569{
565 struct GNUNET_CONVERSATION_Call *call 570 struct GNUNET_CONVERSATION_Call *call
566 = GNUNET_new(struct GNUNET_CONVERSATION_Call); 571 = GNUNET_new (struct GNUNET_CONVERSATION_Call);
567 struct GNUNET_MQ_MessageHandler handlers[] = { 572 struct GNUNET_MQ_MessageHandler handlers[] = {
568 GNUNET_MQ_hd_fixed_size(call_suspend, 573 GNUNET_MQ_hd_fixed_size (call_suspend,
569 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND, 574 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND,
570 struct ClientPhoneSuspendMessage, 575 struct ClientPhoneSuspendMessage,
571 call), 576 call),
572 GNUNET_MQ_hd_fixed_size(call_resume, 577 GNUNET_MQ_hd_fixed_size (call_resume,
573 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME, 578 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME,
574 struct ClientPhoneResumeMessage, 579 struct ClientPhoneResumeMessage,
575 call), 580 call),
576 GNUNET_MQ_hd_fixed_size(call_picked_up, 581 GNUNET_MQ_hd_fixed_size (call_picked_up,
577 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP, 582 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP,
578 struct ClientPhonePickedupMessage, 583 struct ClientPhonePickedupMessage,
579 call), 584 call),
580 GNUNET_MQ_hd_fixed_size(call_hangup, 585 GNUNET_MQ_hd_fixed_size (call_hangup,
581 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP, 586 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP,
582 struct ClientPhoneHangupMessage, 587 struct ClientPhoneHangupMessage,
583 call), 588 call),
584 GNUNET_MQ_hd_var_size(call_audio, 589 GNUNET_MQ_hd_var_size (call_audio,
585 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO, 590 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO,
586 struct ClientAudioMessage, 591 struct ClientAudioMessage,
587 call), 592 call),
588 GNUNET_MQ_handler_end() 593 GNUNET_MQ_handler_end ()
589 }; 594 };
590 595
591 call->mq = GNUNET_CLIENT_connect(cfg, 596 call->mq = GNUNET_CLIENT_connect (cfg,
592 "conversation", 597 "conversation",
593 handlers, 598 handlers,
594 &call_error_handler, 599 &call_error_handler,
595 call); 600 call);
596 if (NULL == call->mq) 601 if (NULL == call->mq)
597 { 602 {
598 GNUNET_break(0); 603 GNUNET_break (0);
599 GNUNET_free(call); 604 GNUNET_free (call);
600 return NULL; 605 return NULL;
601 } 606 }
602 call->cfg = cfg; 607 call->cfg = cfg;
603 call->caller_id = caller_id; 608 call->caller_id = caller_id;
604 call->callee = GNUNET_strdup(callee); 609 call->callee = GNUNET_strdup (callee);
605 call->speaker = speaker; 610 call->speaker = speaker;
606 call->mic = mic; 611 call->mic = mic;
607 call->event_handler = event_handler; 612 call->event_handler = event_handler;
608 call->event_handler_cls = event_handler_cls; 613 call->event_handler_cls = event_handler_cls;
609 call->gns = GNUNET_GNS_connect(cfg); 614 call->gns = GNUNET_GNS_connect (cfg);
610 if (NULL == call->gns) 615 if (NULL == call->gns)
611 { 616 {
612 GNUNET_CONVERSATION_call_stop(call); 617 GNUNET_CONVERSATION_call_stop (call);
613 return NULL; 618 return NULL;
614 } 619 }
615 call->state = CS_LOOKUP; 620 call->state = CS_LOOKUP;
616 call->gns_lookup = GNUNET_GNS_lookup_with_tld(call->gns, 621 call->gns_lookup = GNUNET_GNS_lookup_with_tld (call->gns,
617 call->callee, 622 call->callee,
618 GNUNET_GNSRECORD_TYPE_PHONE, 623 GNUNET_GNSRECORD_TYPE_PHONE,
619 GNUNET_NO, 624 GNUNET_NO,
620 &handle_gns_response, 625 &handle_gns_response,
621 call); 626 call);
622 if (NULL == call->gns_lookup) 627 if (NULL == call->gns_lookup)
623 { 628 {
624 GNUNET_CONVERSATION_call_stop(call); 629 GNUNET_CONVERSATION_call_stop (call);
625 return NULL; 630 return NULL;
626 } 631 }
627 return call; 632 return call;
628} 633}
629 634
@@ -634,35 +639,35 @@ GNUNET_CONVERSATION_call_start(const struct GNUNET_CONFIGURATION_Handle *cfg,
634 * @param call call to terminate 639 * @param call call to terminate
635 */ 640 */
636void 641void
637GNUNET_CONVERSATION_call_stop(struct GNUNET_CONVERSATION_Call *call) 642GNUNET_CONVERSATION_call_stop (struct GNUNET_CONVERSATION_Call *call)
638{ 643{
639 if ((NULL != call->speaker) && 644 if ((NULL != call->speaker) &&
640 (CS_ACTIVE == call->state)) 645 (CS_ACTIVE == call->state))
641 call->speaker->disable_speaker(call->speaker->cls); 646 call->speaker->disable_speaker (call->speaker->cls);
642 if ((NULL != call->mic) && 647 if ((NULL != call->mic) &&
643 (CS_ACTIVE == call->state)) 648 (CS_ACTIVE == call->state))
644 call->mic->disable_microphone(call->mic->cls); 649 call->mic->disable_microphone (call->mic->cls);
645 if (CS_SHUTDOWN != call->state) 650 if (CS_SHUTDOWN != call->state)
646 { 651 {
647 call->state = CS_SHUTDOWN; 652 call->state = CS_SHUTDOWN;
648 } 653 }
649 if (NULL != call->mq) 654 if (NULL != call->mq)
650 { 655 {
651 GNUNET_MQ_destroy(call->mq); 656 GNUNET_MQ_destroy (call->mq);
652 call->mq = NULL; 657 call->mq = NULL;
653 } 658 }
654 if (NULL != call->gns_lookup) 659 if (NULL != call->gns_lookup)
655 { 660 {
656 GNUNET_GNS_lookup_with_tld_cancel(call->gns_lookup); 661 GNUNET_GNS_lookup_with_tld_cancel (call->gns_lookup);
657 call->gns_lookup = NULL; 662 call->gns_lookup = NULL;
658 } 663 }
659 if (NULL != call->gns) 664 if (NULL != call->gns)
660 { 665 {
661 GNUNET_GNS_disconnect(call->gns); 666 GNUNET_GNS_disconnect (call->gns);
662 call->gns = NULL; 667 call->gns = NULL;
663 } 668 }
664 GNUNET_free(call->callee); 669 GNUNET_free (call->callee);
665 GNUNET_free(call); 670 GNUNET_free (call);
666} 671}
667 672
668 673
@@ -673,24 +678,24 @@ GNUNET_CONVERSATION_call_stop(struct GNUNET_CONVERSATION_Call *call)
673 * @param call call to pause 678 * @param call call to pause
674 */ 679 */
675void 680void
676GNUNET_CONVERSATION_call_suspend(struct GNUNET_CONVERSATION_Call *call) 681GNUNET_CONVERSATION_call_suspend (struct GNUNET_CONVERSATION_Call *call)
677{ 682{
678 struct GNUNET_MQ_Envelope *e; 683 struct GNUNET_MQ_Envelope *e;
679 struct ClientPhoneSuspendMessage *suspend; 684 struct ClientPhoneSuspendMessage *suspend;
680 685
681 GNUNET_assert((CS_SUSPENDED_CALLEE == call->state) || 686 GNUNET_assert ((CS_SUSPENDED_CALLEE == call->state) ||
682 (CS_ACTIVE == call->state)); 687 (CS_ACTIVE == call->state));
683 if (CS_ACTIVE == call->state) 688 if (CS_ACTIVE == call->state)
684 { 689 {
685 call->speaker->disable_speaker(call->speaker->cls); 690 call->speaker->disable_speaker (call->speaker->cls);
686 call->mic->disable_microphone(call->mic->cls); 691 call->mic->disable_microphone (call->mic->cls);
687 } 692 }
688 call->speaker = NULL; 693 call->speaker = NULL;
689 call->mic = NULL; 694 call->mic = NULL;
690 e = GNUNET_MQ_msg(suspend, 695 e = GNUNET_MQ_msg (suspend,
691 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND); 696 GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND);
692 GNUNET_MQ_send(call->mq, 697 GNUNET_MQ_send (call->mq,
693 e); 698 e);
694 if (CS_SUSPENDED_CALLER == call->state) 699 if (CS_SUSPENDED_CALLER == call->state)
695 call->state = CS_SUSPENDED_BOTH; 700 call->state = CS_SUSPENDED_BOTH;
696 else 701 else
@@ -707,31 +712,31 @@ GNUNET_CONVERSATION_call_suspend(struct GNUNET_CONVERSATION_Call *call)
707 * @param mic microphone to use 712 * @param mic microphone to use
708 */ 713 */
709void 714void
710GNUNET_CONVERSATION_call_resume(struct GNUNET_CONVERSATION_Call *call, 715GNUNET_CONVERSATION_call_resume (struct GNUNET_CONVERSATION_Call *call,
711 struct GNUNET_SPEAKER_Handle *speaker, 716 struct GNUNET_SPEAKER_Handle *speaker,
712 struct GNUNET_MICROPHONE_Handle *mic) 717 struct GNUNET_MICROPHONE_Handle *mic)
713{ 718{
714 struct GNUNET_MQ_Envelope *e; 719 struct GNUNET_MQ_Envelope *e;
715 struct ClientPhoneResumeMessage *resume; 720 struct ClientPhoneResumeMessage *resume;
716 721
717 GNUNET_assert((CS_SUSPENDED_CALLER == call->state) || 722 GNUNET_assert ((CS_SUSPENDED_CALLER == call->state) ||
718 (CS_SUSPENDED_BOTH == call->state)); 723 (CS_SUSPENDED_BOTH == call->state));
719 e = GNUNET_MQ_msg(resume, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME); 724 e = GNUNET_MQ_msg (resume, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME);
720 GNUNET_MQ_send(call->mq, e); 725 GNUNET_MQ_send (call->mq, e);
721 call->speaker = speaker; 726 call->speaker = speaker;
722 call->mic = mic; 727 call->mic = mic;
723 if (CS_SUSPENDED_CALLER == call->state) 728 if (CS_SUSPENDED_CALLER == call->state)
724 { 729 {
725 call->state = CS_ACTIVE; 730 call->state = CS_ACTIVE;
726 call->speaker->enable_speaker(call->speaker->cls); 731 call->speaker->enable_speaker (call->speaker->cls);
727 call->mic->enable_microphone(call->mic->cls, 732 call->mic->enable_microphone (call->mic->cls,
728 &transmit_call_audio, 733 &transmit_call_audio,
729 call); 734 call);
730 } 735 }
731 else 736 else
732 { 737 {
733 call->state = CS_SUSPENDED_CALLEE; 738 call->state = CS_SUSPENDED_CALLEE;
734 } 739 }
735} 740}
736 741
737 742