GNUnet  0.11.x
Data Structures | Enumerations | Functions
conversation_api_call.c File Reference

call API to the conversation service More...

#include "platform.h"
#include "gnunet_conversation_service.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_gns_service.h"
#include "conversation.h"
Include dependency graph for conversation_api_call.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_CONVERSATION_Call
 Handle for an outgoing call. More...
 

Enumerations

enum  CallState {
  CS_LOOKUP = 0 , CS_RINGING , CS_ACTIVE , CS_SHUTDOWN ,
  CS_SUSPENDED_CALLER , CS_SUSPENDED_CALLEE , CS_SUSPENDED_BOTH , CS_RESOLVING ,
  CS_RINGING , CS_CONNECTED , CS_SUSPENDED
}
 Possible states of the phone. More...
 

Functions

static void fail_call (struct GNUNET_CONVERSATION_Call *call)
 The call got disconnected, reconnect to the service. More...
 
static void transmit_call_audio (void *cls, size_t data_size, const void *data)
 Process recorded audio data. More...
 
static void handle_call_suspend (void *cls, const struct ClientPhoneSuspendMessage *msg)
 We received a GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND. More...
 
static void handle_call_resume (void *cls, const struct ClientPhoneResumeMessage *msg)
 We received a GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME. More...
 
static void handle_call_picked_up (void *cls, const struct ClientPhonePickedupMessage *msg)
 We received a GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP. More...
 
static void handle_call_hangup (void *cls, const struct ClientPhoneHangupMessage *msg)
 We received a #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_HANG_UP. More...
 
static int check_call_audio (void *cls, const struct ClientAudioMessage *am)
 We received a struct ClientAudioMessage, check it is well-formed. More...
 
static void handle_call_audio (void *cls, const struct ClientAudioMessage *am)
 We received a struct ClientAudioMessage More...
 
static void handle_gns_response (void *cls, int was_gns, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 Iterator called on obtained result for a GNS lookup. More...
 
static void call_error_handler (void *cls, enum GNUNET_MQ_Error error)
 We encountered an error talking with the conversation service. More...
 
struct GNUNET_CONVERSATION_CallGNUNET_CONVERSATION_call_start (const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_IDENTITY_Ego *caller_id, const char *callee, struct GNUNET_SPEAKER_Handle *speaker, struct GNUNET_MICROPHONE_Handle *mic, GNUNET_CONVERSATION_CallEventHandler event_handler, void *event_handler_cls)
 Call the phone of another user. More...
 
void GNUNET_CONVERSATION_call_stop (struct GNUNET_CONVERSATION_Call *call)
 Terminate a call. More...
 
void GNUNET_CONVERSATION_call_suspend (struct GNUNET_CONVERSATION_Call *call)
 Pause a call. More...
 
void GNUNET_CONVERSATION_call_resume (struct GNUNET_CONVERSATION_Call *call, struct GNUNET_SPEAKER_Handle *speaker, struct GNUNET_MICROPHONE_Handle *mic)
 Resumes a call after GNUNET_CONVERSATION_call_suspend. More...
 

Detailed Description

call API to the conversation service

Author
Simon Dieterle
Andreas Fuchs
Christian Grothoff

Definition in file conversation_api_call.c.

Enumeration Type Documentation

◆ CallState

enum CallState

Possible states of the phone.

Enumerator
CS_LOOKUP 

We still need to lookup the callee.

CS_RINGING 

The call is ringing.

CS_ACTIVE 

The call is in an active conversation.

CS_SHUTDOWN 

The call is in termination.

CS_SUSPENDED_CALLER 

The call was suspended by the caller.

CS_SUSPENDED_CALLEE 

The call was suspended by the callee.

CS_SUSPENDED_BOTH 

The call was suspended by both caller and callee.

CS_RESOLVING 

We are looking up some other participant.

CS_RINGING 

We are now ringing the other participant.

CS_CONNECTED 

The other party accepted our call and we are now connected.

CS_SUSPENDED 

The call is currently suspended (by us).

Definition at line 38 of file conversation_api_call.c.

39 {
43  CS_LOOKUP = 0,
44 
48  CS_RINGING,
49 
53  CS_ACTIVE,
54 
59 
64 
69 
74 };
@ CS_LOOKUP
We still need to lookup the callee.
@ CS_SUSPENDED_CALLEE
The call was suspended by the callee.
@ CS_SHUTDOWN
The call is in termination.
@ CS_SUSPENDED_CALLER
The call was suspended by the caller.
@ CS_SUSPENDED_BOTH
The call was suspended by both caller and callee.
@ CS_ACTIVE
The call is in an active conversation.
@ CS_RINGING
The call is ringing.

Function Documentation

◆ fail_call()

static void fail_call ( struct GNUNET_CONVERSATION_Call call)
static

The call got disconnected, reconnect to the service.

The call got disconnected, destroy the handle.

Parameters
callcall to reconnect

Definition at line 526 of file conversation_api_call.c.

527 {
528  if (CS_ACTIVE == call->state)
529  {
532  }
533  if (NULL != call->mq)
534  {
536  call->mq = NULL;
537  }
542 }
static struct GNUNET_CONVERSATION_Call * call
Call handle (for active outgoing call).
void GNUNET_CONVERSATION_call_stop(struct GNUNET_CONVERSATION_Call *call)
Terminate a call.
@ GNUNET_CONVERSATION_EC_CALL_ERROR
We had an error handing the call, and are now restarting it (back to lookup).
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:837
void * event_handler_cls
Closure for event_handler.
struct GNUNET_MICROPHONE_Handle * mic
Our microphone.
enum CallState state
State machine for the call.
struct GNUNET_MQ_Handle * mq
Handle for transmitting to the CONVERSATION service.
struct GNUNET_SPEAKER_Handle * speaker
Our speaker.
GNUNET_CONVERSATION_CallEventHandler event_handler
Function to call with events.
void * cls
Closure for the callbacks.
GNUNET_MICROPHONE_DisableCallback disable_microphone
Turn the microphone off.
void * cls
Closure for the callbacks.
GNUNET_SPEAKER_DisableCallback disable_speaker
Turn the speaker off.

References call, GNUNET_MICROPHONE_Handle::cls, GNUNET_SPEAKER_Handle::cls, CS_ACTIVE, CS_SHUTDOWN, GNUNET_MICROPHONE_Handle::disable_microphone, GNUNET_SPEAKER_Handle::disable_speaker, GNUNET_CONVERSATION_Call::event_handler, GNUNET_CONVERSATION_Call::event_handler_cls, GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_EC_CALL_ERROR, GNUNET_MQ_destroy(), GNUNET_CONVERSATION_Call::mic, GNUNET_CONVERSATION_Call::mq, GNUNET_CONVERSATION_Call::speaker, and GNUNET_CONVERSATION_Call::state.

Referenced by call_error_handler(), handle_call_audio(), handle_call_hangup(), handle_call_picked_up(), handle_call_resume(), and handle_call_suspend().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ transmit_call_audio()

static void transmit_call_audio ( void *  cls,
size_t  data_size,
const void *  data 
)
static

Process recorded audio data.

Parameters
clsclosure with the struct GNUNET_CONVERSATION_Call
data_sizenumber of bytes in data
dataaudio data to play

Definition at line 161 of file conversation_api_call.c.

164 {
165  struct GNUNET_CONVERSATION_Call *call = cls;
166  struct GNUNET_MQ_Envelope *e;
167  struct ClientAudioMessage *am;
168 
170  e = GNUNET_MQ_msg_extra (am,
171  data_size,
173  GNUNET_memcpy (&am[1],
174  data,
175  data_size);
177  e);
178 }
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
static struct Experiment * e
uint32_t data
The data value.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:52
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO
Client <-> Server message to send audio data.
Message Client <-> Service to transmit the audio.
Definition: conversation.h:191
Handle for an outgoing call.

References call, CS_ACTIVE, data, data_size, e, GNUNET_assert, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_CONVERSATION_Call::mq, and GNUNET_CONVERSATION_Call::state.

Referenced by GNUNET_CONVERSATION_call_resume(), handle_call_picked_up(), and handle_call_resume().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_call_suspend()

static void handle_call_suspend ( void *  cls,
const struct ClientPhoneSuspendMessage msg 
)
static

We received a GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND.

Parameters
clsthe struct GNUNET_CONVERSATION_Call
msgthe message

Definition at line 188 of file conversation_api_call.c.

190 {
191  struct GNUNET_CONVERSATION_Call *call = cls;
192 
193  (void) msg;
194  switch (call->state)
195  {
196  case CS_LOOKUP:
197  GNUNET_break (0);
198  fail_call (call);
199  break;
200 
201  case CS_RINGING:
202  GNUNET_break_op (0);
203  fail_call (call);
204  break;
205 
206  case CS_SUSPENDED_CALLER:
210  break;
211 
212  case CS_SUSPENDED_CALLEE:
213  case CS_SUSPENDED_BOTH:
214  GNUNET_break_op (0);
215  break;
216 
217  case CS_ACTIVE:
223  break;
224 
225  case CS_SHUTDOWN:
227  break;
228  }
229 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static void fail_call(struct GNUNET_CONVERSATION_Call *call)
The call got disconnected, reconnect to the service.
@ GNUNET_CONVERSATION_EC_CALL_SUSPENDED
We are the caller and the callee suspended the call.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.

References call, GNUNET_MICROPHONE_Handle::cls, GNUNET_SPEAKER_Handle::cls, CS_ACTIVE, CS_LOOKUP, CS_RINGING, CS_SHUTDOWN, CS_SUSPENDED_BOTH, CS_SUSPENDED_CALLEE, CS_SUSPENDED_CALLER, GNUNET_MICROPHONE_Handle::disable_microphone, GNUNET_SPEAKER_Handle::disable_speaker, GNUNET_CONVERSATION_Call::event_handler, GNUNET_CONVERSATION_Call::event_handler_cls, fail_call(), GNUNET_break, GNUNET_break_op, GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_EC_CALL_SUSPENDED, GNUNET_CONVERSATION_Call::mic, msg, GNUNET_CONVERSATION_Call::speaker, and GNUNET_CONVERSATION_Call::state.

Here is the call graph for this function:

◆ handle_call_resume()

static void handle_call_resume ( void *  cls,
const struct ClientPhoneResumeMessage msg 
)
static

We received a GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME.

Parameters
clsthe struct GNUNET_CONVERSATION_Call
msgthe message

Definition at line 239 of file conversation_api_call.c.

241 {
242  struct GNUNET_CONVERSATION_Call *call = cls;
243 
244  (void) msg;
245  switch (call->state)
246  {
247  case CS_LOOKUP:
248  GNUNET_break (0);
249  fail_call (call);
250  break;
251 
252  case CS_RINGING:
253  GNUNET_break_op (0);
254  fail_call (call);
255  break;
256 
257  case CS_SUSPENDED_CALLER:
258  GNUNET_break_op (0);
259  break;
260 
261  case CS_SUSPENDED_CALLEE:
262  call->state = CS_ACTIVE;
266  call);
269  break;
270 
271  case CS_SUSPENDED_BOTH:
275  break;
276 
277  case CS_ACTIVE:
278  GNUNET_break_op (0);
279  break;
280 
281  case CS_SHUTDOWN:
283  break;
284  }
285 }
static void transmit_call_audio(void *cls, size_t data_size, const void *data)
Process recorded audio data.
@ GNUNET_CONVERSATION_EC_CALL_RESUMED
We are the caller and the callee suspended the call.
GNUNET_MICROPHONE_EnableCallback enable_microphone
Turn on the microphone.
GNUNET_SPEAKER_EnableCallback enable_speaker
Turn on the speaker.

References call, GNUNET_MICROPHONE_Handle::cls, GNUNET_SPEAKER_Handle::cls, CS_ACTIVE, CS_LOOKUP, CS_RINGING, CS_SHUTDOWN, CS_SUSPENDED_BOTH, CS_SUSPENDED_CALLEE, CS_SUSPENDED_CALLER, GNUNET_MICROPHONE_Handle::enable_microphone, GNUNET_SPEAKER_Handle::enable_speaker, GNUNET_CONVERSATION_Call::event_handler, GNUNET_CONVERSATION_Call::event_handler_cls, fail_call(), GNUNET_break, GNUNET_break_op, GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_EC_CALL_RESUMED, GNUNET_CONVERSATION_Call::mic, msg, GNUNET_CONVERSATION_Call::speaker, GNUNET_CONVERSATION_Call::state, and transmit_call_audio().

Here is the call graph for this function:

◆ handle_call_picked_up()

static void handle_call_picked_up ( void *  cls,
const struct ClientPhonePickedupMessage msg 
)
static

We received a GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP.

Parameters
clsthe struct GNUNET_CONVERSATION_Call
msgthe message

Definition at line 295 of file conversation_api_call.c.

297 {
298  struct GNUNET_CONVERSATION_Call *call = cls;
299 
300  (void) msg;
301  switch (call->state)
302  {
303  case CS_LOOKUP:
304  GNUNET_break (0);
305  fail_call (call);
306  break;
307 
308  case CS_RINGING:
309  call->state = CS_ACTIVE;
313  call);
316  break;
317 
318  case CS_SUSPENDED_CALLER:
319  case CS_SUSPENDED_CALLEE:
320  case CS_SUSPENDED_BOTH:
321  case CS_ACTIVE:
322  GNUNET_break (0);
323  fail_call (call);
324  break;
325 
326  case CS_SHUTDOWN:
328  break;
329  }
330 }
@ GNUNET_CONVERSATION_EC_CALL_PICKED_UP
We are the caller and are now ready to talk as the callee picked up.

References call, GNUNET_MICROPHONE_Handle::cls, GNUNET_SPEAKER_Handle::cls, CS_ACTIVE, CS_LOOKUP, CS_RINGING, CS_SHUTDOWN, CS_SUSPENDED_BOTH, CS_SUSPENDED_CALLEE, CS_SUSPENDED_CALLER, GNUNET_MICROPHONE_Handle::enable_microphone, GNUNET_SPEAKER_Handle::enable_speaker, GNUNET_CONVERSATION_Call::event_handler, GNUNET_CONVERSATION_Call::event_handler_cls, fail_call(), GNUNET_break, GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_EC_CALL_PICKED_UP, GNUNET_CONVERSATION_Call::mic, msg, GNUNET_CONVERSATION_Call::speaker, GNUNET_CONVERSATION_Call::state, and transmit_call_audio().

Here is the call graph for this function:

◆ handle_call_hangup()

static void handle_call_hangup ( void *  cls,
const struct ClientPhoneHangupMessage msg 
)
static

We received a #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_HANG_UP.

Parameters
clsthe struct GNUNET_CONVERSATION_Call
msgthe message

Definition at line 340 of file conversation_api_call.c.

342 {
343  struct GNUNET_CONVERSATION_Call *call = cls;
345  void *eh_cls;
346 
347  (void) msg;
348  switch (call->state)
349  {
350  case CS_LOOKUP:
351  GNUNET_break (0);
352  fail_call (call);
353  break;
354 
355  case CS_RINGING:
356  case CS_SUSPENDED_CALLER:
357  case CS_SUSPENDED_CALLEE:
358  case CS_SUSPENDED_BOTH:
359  case CS_ACTIVE:
360  eh = call->event_handler;
361  eh_cls = call->event_handler_cls;
363  eh (eh_cls,
365  return;
366 
367  case CS_SHUTDOWN:
369  break;
370  }
371 }
void(* GNUNET_CONVERSATION_CallEventHandler)(void *cls, enum GNUNET_CONVERSATION_CallEventCode code)
Function called with an event emitted for a call.
@ GNUNET_CONVERSATION_EC_CALL_HUNG_UP
We are the caller and the callee called GNUNET_CONVERSATION_caller_hang_up.

References call, CS_ACTIVE, CS_LOOKUP, CS_RINGING, CS_SHUTDOWN, CS_SUSPENDED_BOTH, CS_SUSPENDED_CALLEE, CS_SUSPENDED_CALLER, GNUNET_CONVERSATION_Call::event_handler, GNUNET_CONVERSATION_Call::event_handler_cls, fail_call(), GNUNET_break, GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_EC_CALL_HUNG_UP, msg, and GNUNET_CONVERSATION_Call::state.

Here is the call graph for this function:

◆ check_call_audio()

static int check_call_audio ( void *  cls,
const struct ClientAudioMessage am 
)
static

We received a struct ClientAudioMessage, check it is well-formed.

Parameters
clsthe struct GNUNET_CONVERSATION_Call
msgthe message
Returns
GNUNET_OK (always well-formed)

Definition at line 382 of file conversation_api_call.c.

384 {
385  (void) cls;
386  (void) am;
387  /* any payload is OK */
388  return GNUNET_OK;
389 }
@ GNUNET_OK
Definition: gnunet_common.h:95

References GNUNET_OK.

◆ handle_call_audio()

static void handle_call_audio ( void *  cls,
const struct ClientAudioMessage am 
)
static

We received a struct ClientAudioMessage

Parameters
clsthe struct GNUNET_CONVERSATION_Call
msgthe message

Definition at line 399 of file conversation_api_call.c.

401 {
402  struct GNUNET_CONVERSATION_Call *call = cls;
403 
404  switch (call->state)
405  {
406  case CS_LOOKUP:
407  GNUNET_break (0);
408  fail_call (call);
409  break;
410 
411  case CS_RINGING:
412  GNUNET_break (0);
413  fail_call (call);
414  break;
415 
416  case CS_SUSPENDED_CALLER:
417  /* can happen: we suspended, other peer did not yet
418  learn about this. */
419  break;
420 
421  case CS_SUSPENDED_CALLEE:
422  case CS_SUSPENDED_BOTH:
423  /* can (rarely) also happen: other peer suspended, but cadet might
424  have had delayed data on the unreliable channel */
425  break;
426 
427  case CS_ACTIVE:
429  ntohs (am->header.size) - sizeof(struct
431  &am[1]);
432  break;
433 
434  case CS_SHUTDOWN:
436  break;
437  }
438 }
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO.
Definition: conversation.h:195
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
GNUNET_SPEAKER_PlayCallback play
Play audio.

References call, GNUNET_SPEAKER_Handle::cls, CS_ACTIVE, CS_LOOKUP, CS_RINGING, CS_SHUTDOWN, CS_SUSPENDED_BOTH, CS_SUSPENDED_CALLEE, CS_SUSPENDED_CALLER, fail_call(), GNUNET_break, GNUNET_CONVERSATION_call_stop(), ClientAudioMessage::header, GNUNET_SPEAKER_Handle::play, GNUNET_MessageHeader::size, GNUNET_CONVERSATION_Call::speaker, and GNUNET_CONVERSATION_Call::state.

Here is the call graph for this function:

◆ handle_gns_response()

static void handle_gns_response ( void *  cls,
int  was_gns,
uint32_t  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

Iterator called on obtained result for a GNS lookup.

Parameters
clsclosure with the struct GNUNET_CONVERSATION_Call
was_gnsGNUNET_NO if name was not a GNS name
rd_countnumber of records in rd
rdthe records in reply

Definition at line 450 of file conversation_api_call.c.

454 {
455  struct GNUNET_CONVERSATION_Call *call = cls;
456  struct GNUNET_MQ_Envelope *e;
457  struct ClientCallMessage *ccm;
458 
459  (void) was_gns;
460  GNUNET_break (NULL != call->gns_lookup);
462  call->gns_lookup = NULL;
463  for (uint32_t i = 0; i < rd_count; i++)
464  {
465  if (GNUNET_GNSRECORD_TYPE_PHONE == rd[i].record_type)
466  {
467  if (rd[i].data_size != sizeof(struct GNUNET_CONVERSATION_PhoneRecord))
468  {
469  GNUNET_break_op (0);
470  continue;
471  }
473  rd[i].data,
474  rd[i].data_size);
475  e = GNUNET_MQ_msg (ccm,
478  ccm->target = call->phone_record.peer;
481  e);
482  call->state = CS_RINGING;
485  return;
486  }
487  }
488  /* not found */
492 }
#define GNUNET_GNSRECORD_TYPE_PHONE
Endpoint for conversation.
@ GNUNET_CONVERSATION_EC_CALL_GNS_FAIL
We are the caller and failed to locate a phone record in GNS.
@ GNUNET_CONVERSATION_EC_CALL_RINGING
We are the caller and are now ringing the other party (GNS lookup succeeded).
const struct GNUNET_IDENTITY_PrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:639
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL
Client <- Server message to indicate a ringing phone.
Client -> Service message to call a phone.
Definition: conversation.h:211
struct GNUNET_HashCode line_port
Which phone line to call at the peer?
Definition: conversation.h:230
struct GNUNET_IDENTITY_PrivateKey caller_id
Identity of the caller.
Definition: conversation.h:235
struct GNUNET_PeerIdentity target
Which peer is hosting the line?
Definition: conversation.h:225
struct GNUNET_GNS_LookupWithTldRequest * gns_lookup
Active GNS lookup (or NULL).
struct GNUNET_CONVERSATION_PhoneRecord phone_record
Target phone record, only valid after the lookup is done.
struct GNUNET_IDENTITY_Ego * caller_id
Our caller identity.
A phone record specifies which peer is hosting a given user and may also specify the phone line that ...
struct GNUNET_HashCode line_port
Phone line (CADET port) to connect to.
struct GNUNET_PeerIdentity peer
Identity of the peer hosting the phone service.

References call, ClientCallMessage::caller_id, GNUNET_CONVERSATION_Call::caller_id, CS_LOOKUP, CS_RINGING, GNUNET_GNSRECORD_Data::data, data_size, GNUNET_GNSRECORD_Data::data_size, e, GNUNET_CONVERSATION_Call::event_handler, GNUNET_CONVERSATION_Call::event_handler_cls, GNUNET_CONVERSATION_Call::gns_lookup, GNUNET_break, GNUNET_break_op, GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_EC_CALL_GNS_FAIL, GNUNET_CONVERSATION_EC_CALL_RINGING, GNUNET_GNSRECORD_TYPE_PHONE, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL, GNUNET_MQ_msg, GNUNET_MQ_send(), ClientCallMessage::line_port, GNUNET_CONVERSATION_PhoneRecord::line_port, GNUNET_CONVERSATION_Call::mq, GNUNET_CONVERSATION_PhoneRecord::peer, GNUNET_CONVERSATION_Call::phone_record, GNUNET_CONVERSATION_Call::state, and ClientCallMessage::target.

Referenced by GNUNET_CONVERSATION_call_start().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ call_error_handler()

static void call_error_handler ( void *  cls,
enum GNUNET_MQ_Error  error 
)
static

We encountered an error talking with the conversation service.

Parameters
clsthe struct GNUNET_CONVERSATION_Call
errordetails about the error

Definition at line 502 of file conversation_api_call.c.

504 {
505  struct GNUNET_CONVERSATION_Call *call = cls;
506 
507  (void) error;
508  if (CS_SHUTDOWN == call->state)
509  {
511  return;
512  }
514  _ (
515  "Connection to conversation service lost, trying to reconnect\n"));
516  fail_call (call);
517 }
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_WARNING
#define _(String)
GNU gettext support macro.
Definition: platform.h:177

References _, call, CS_SHUTDOWN, fail_call(), GNUNET_CONVERSATION_call_stop(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, and GNUNET_CONVERSATION_Call::state.

Referenced by GNUNET_CONVERSATION_call_start().

Here is the call graph for this function:
Here is the caller graph for this function: