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