diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/conversation/conversation_api_call.c | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/conversation/conversation_api_call.c')
-rw-r--r-- | src/conversation/conversation_api_call.c | 695 |
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 | */ |
38 | enum CallState { | 38 | enum 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 | */ |
79 | struct GNUNET_CONVERSATION_Call { | 80 | struct 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 | */ |
147 | static void | 149 | static void |
148 | fail_call(struct GNUNET_CONVERSATION_Call *call); | 150 | fail_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 | */ |
158 | static void | 160 | static void |
159 | transmit_call_audio(void *cls, | 161 | transmit_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 | */ |
185 | static void | 187 | static void |
186 | handle_call_suspend(void *cls, | 188 | handle_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 | */ |
236 | static void | 238 | static void |
237 | handle_call_resume(void *cls, | 239 | handle_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 | */ |
292 | static void | 294 | static void |
293 | handle_call_picked_up(void *cls, | 295 | handle_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 | */ |
337 | static void | 339 | static void |
338 | handle_call_hangup(void *cls, | 340 | handle_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 | */ |
379 | static int | 381 | static int |
380 | check_call_audio(void *cls, | 382 | check_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 | */ |
396 | static void | 398 | static void |
397 | handle_call_audio(void *cls, | 399 | handle_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 | */ |
446 | static void | 449 | static void |
447 | handle_gns_response(void *cls, | 450 | handle_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 | */ |
498 | static void | 501 | static void |
499 | call_error_handler(void *cls, | 502 | call_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 | */ |
521 | static void | 525 | static void |
522 | fail_call(struct GNUNET_CONVERSATION_Call *call) | 526 | fail_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 | */ |
556 | struct GNUNET_CONVERSATION_Call * | 560 | struct GNUNET_CONVERSATION_Call * |
557 | GNUNET_CONVERSATION_call_start(const struct GNUNET_CONFIGURATION_Handle *cfg, | 561 | GNUNET_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 | */ |
636 | void | 641 | void |
637 | GNUNET_CONVERSATION_call_stop(struct GNUNET_CONVERSATION_Call *call) | 642 | GNUNET_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 | */ |
675 | void | 680 | void |
676 | GNUNET_CONVERSATION_call_suspend(struct GNUNET_CONVERSATION_Call *call) | 681 | GNUNET_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 | */ |
709 | void | 714 | void |
710 | GNUNET_CONVERSATION_call_resume(struct GNUNET_CONVERSATION_Call *call, | 715 | GNUNET_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 | ||