cadet.h File Reference

#include <stdint.h>
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_core_service.h"
#include "gnunet_cadet_service.h"
#include "gnunet_protocols.h"

Include dependency graph for cadet.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	GNUNET_CADET_ClientChannelNumber
	Number uniquely identifying a channel of a client. More...
struct	GNUNET_CADET_Channel
	Opaque handle to a channel. More...
struct	GNUNET_CADET_PortMessage
	Message for a client to create and destroy channels. More...
struct	GNUNET_CADET_LocalChannelCreateMessage
	Message for a client to create channels. More...
struct	GNUNET_CADET_LocalChannelDestroyMessage
	Message for or to a client to destroy tunnel. More...
struct	GNUNET_CADET_LocalData
	Message for cadet data traffic. More...
struct	GNUNET_CADET_LocalAck
	Message to allow the client send more data to the service (always service -> client). More...
struct	GNUNET_CADET_LocalInfo
	Message to inform the client about channels in the service. More...
struct	GNUNET_CADET_RequestDropCadetMessage
	Message to drop another message of specific type. More...
struct	GNUNET_CADET_RequestPathInfoMessage
	Message to inform the client about channels in the service. More...
struct	GNUNET_CADET_ChannelInfoMessage
	Message to inform the client about channels in the service. More...
struct	GNUNET_CADET_RequestChannelInfoMessage
	Message to as the service about information on a channel. More...
struct	GNUNET_CADET_LocalInfoPath
	Message to inform the client about one of the paths known to the service. More...
struct	GNUNET_CADET_LocalInfoPeers
	Message to inform the client about one of the peers in the service. More...
struct	GNUNET_CADET_LocalInfoTunnel
	Message to inform the client about one of the tunnels in the service. More...

Macros
#define	CADET_TIMING_START
#define	CADET_TIMING_END
#define	GNUNET_CADET_LOCAL_CHANNEL_ID_CLI   0x80000000U
	Minimum value for channel IDs of local clients.
#define	HIGH_PID   0xFF000000
	FIXME.
#define	LOW_PID   0x00FFFFFF
	FIXME.
#define	PID_OVERFLOW(pid, max)   (((pid) > HIGH_PID) && ((max) < LOW_PID))
	Test if the two PIDs (of type uint32_t) are in the range where we have to worry about overflows.

Functions
GNUNET_NETWORK_STRUCT_END char *	GC_f2s (int fwd)
	Translate a fwd variable into a string representation, for logging.
int	GC_is_pid_bigger (uint32_t bigger, uint32_t smaller)
	Check if one pid is bigger than other, accounting for overflow.
uint32_t	GC_max_pid (uint32_t a, uint32_t b)
	Get the higher ACK value out of two values, taking in account overflow.
uint32_t	GC_min_pid (uint32_t a, uint32_t b)
	Get the lower ACK value out of two values, taking in account overflow.
size_t	GC_bin2s (void *bin, unsigned int len, char **output)
	Allocate a string with a hexdump of any binary data.
const char *	GC_m2s (uint16_t m)
	Convert a message type into a string to help debug Generated with: FIND: "#define ([^ ]+)[ ]*([0-9]+)" REPLACE: " case \2: return "\1"; break;".

Detailed Description

Author

Bartlomiej Polot

Definition in file cadet.h.

Macro Definition Documentation

CADET_TIMING_START

#define CADET_TIMING_START

Value:

  struct GNUNET_TIME_Absolute __timestamp; \
  __timestamp = GNUNET_TIME_absolute_get ()

Definition at line 39 of file cadet.h.

{
  uint32_t channel_of_client GNUNET_PACKED;
};
 
struct GNUNET_CADET_Channel
{
 
  struct GNUNET_PeerIdentity peer;
 
  struct GNUNET_CADET_Handle *cadet;
 
  struct GNUNET_CADET_Port *incoming_port;
 
  void *ctx;
 
  struct GNUNET_MQ_Handle *mq;
 
  struct GNUNET_SCHEDULER_Task *mq_cont;
 
  struct GNUNET_MQ_Envelope *pending_env;
 
  GNUNET_CADET_WindowSizeEventHandler window_changes;
 
  GNUNET_CADET_DisconnectEventHandler disconnects;
 
  struct GNUNET_CADET_ClientChannelNumber ccn;
 
  unsigned int allow_send;
};
 
struct GNUNET_CADET_PortMessage
{
  struct GNUNET_MessageHeader header;
 
  struct GNUNET_HashCode port GNUNET_PACKED;
};
 
 
struct GNUNET_CADET_LocalChannelCreateMessage
{
  struct GNUNET_MessageHeader header;
 
  struct GNUNET_CADET_ClientChannelNumber ccn;
 
  struct GNUNET_PeerIdentity peer;
 
  struct GNUNET_HashCode port;
 
  uint32_t opt GNUNET_PACKED;
};
 
 
struct GNUNET_CADET_LocalChannelDestroyMessage
{
  struct GNUNET_MessageHeader header;
 
  struct GNUNET_CADET_ClientChannelNumber ccn;
};
 
 
struct GNUNET_CADET_LocalData
{
  struct GNUNET_MessageHeader header;
 
  struct GNUNET_CADET_ClientChannelNumber ccn;
 
  uint32_t pp GNUNET_PACKED;
 
};
 
 
struct GNUNET_CADET_LocalAck
{
  struct GNUNET_MessageHeader header;
 
  struct GNUNET_CADET_ClientChannelNumber ccn;
};
 
 
struct GNUNET_CADET_LocalInfo
{
  struct GNUNET_MessageHeader header;
 
  struct GNUNET_CADET_ClientChannelNumber ccn;
 
  struct GNUNET_PeerIdentity peer;
};
 
struct GNUNET_CADET_RequestDropCadetMessage
{
 
  struct GNUNET_MessageHeader header;
 
  uint16_t type;
 
  struct GNUNET_CADET_ClientChannelNumber ccn;
 
};
 
struct GNUNET_CADET_RequestPathInfoMessage
{
  struct GNUNET_MessageHeader header;
 
  uint32_t resered GNUNET_PACKED;
 
  struct GNUNET_PeerIdentity peer;
};
 
 
struct GNUNET_CADET_ChannelInfoMessage
{
  struct GNUNET_MessageHeader header;
 
  struct GNUNET_PeerIdentity root;
 
  struct GNUNET_PeerIdentity dest;
 
  /* FIXME: expand! */
};
 
 
struct GNUNET_CADET_RequestChannelInfoMessage
{
  struct GNUNET_MessageHeader header;
 
  struct GNUNET_PeerIdentity target;
};
 
 
struct GNUNET_CADET_LocalInfoPath
{
  struct GNUNET_MessageHeader header;
 
  uint32_t off GNUNET_PACKED;
};
 
 
struct GNUNET_CADET_LocalInfoPeers
{
  struct GNUNET_MessageHeader header;
 
  uint16_t paths GNUNET_PACKED;
 
  int16_t tunnel GNUNET_PACKED;
 
  uint32_t best_path_length GNUNET_PACKED;
 
  struct GNUNET_PeerIdentity destination;
};
 
 
struct GNUNET_CADET_LocalInfoTunnel
{
  struct GNUNET_MessageHeader header;
 
  uint32_t channels GNUNET_PACKED;
 
  struct GNUNET_PeerIdentity destination;
 
  uint32_t connections GNUNET_PACKED;
 
  uint16_t estate GNUNET_PACKED;
 
  uint16_t cstate GNUNET_PACKED;
 
  /* If TUNNEL (no 'S'): struct GNUNET_CADET_ConnectionTunnelIdentifier connection_ids[connections] */
  /* If TUNNEL (no 'S'): uint32_t channel_ids[channels] */
};
 
 
GNUNET_NETWORK_STRUCT_END
 
 
char *
GC_f2s (int fwd);
 
 
int
GC_is_pid_bigger (uint32_t bigger, uint32_t smaller);
 
 
uint32_t
GC_max_pid (uint32_t a, uint32_t b);
 
 
uint32_t
GC_min_pid (uint32_t a, uint32_t b);
 
 
size_t
GC_bin2s (void *bin, unsigned int len, char **output);
 
 
const char *
GC_m2s (uint16_t m);
 
#if 0 /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
}
#endif
 
#endif

CADET_TIMING_END

#define CADET_TIMING_END

Value:

  struct GNUNET_TIME_Relative __duration;                       \
  __duration = GNUNET_TIME_absolute_get_duration (__timestamp); \
  LOG (GNUNET_ERROR_TYPE_INFO,                                  \
       " %s duration %s\n",                                     \
       __FUNCTION__,                                            \
       GNUNET_STRINGS_relative_time_to_string (__duration, GNUNET_YES));

Definition at line 43 of file cadet.h.

GNUNET_CADET_LOCAL_CHANNEL_ID_CLI

#define GNUNET_CADET_LOCAL_CHANNEL_ID_CLI   0x80000000U

Minimum value for channel IDs of local clients.

Definition at line 70 of file cadet.h.

HIGH_PID

#define HIGH_PID   0xFF000000

FIXME.

Definition at line 75 of file cadet.h.

LOW_PID

#define LOW_PID   0x00FFFFFF

FIXME.

Definition at line 80 of file cadet.h.

PID_OVERFLOW

#define PID_OVERFLOW	(		pid,
			max
	)		(((pid) > HIGH_PID) && ((max) < LOW_PID))

Test if the two PIDs (of type uint32_t) are in the range where we have to worry about overflows.

This is the case when pid is large and max is small, useful when comparing pid smaller than max.

Definition at line 89 of file cadet.h.

Function Documentation

GC_f2s()

GNUNET_NETWORK_STRUCT_END char * GC_f2s

(

int

fwd

)

Translate a fwd variable into a string representation, for logging.

Parameters

fwd	Is FWD? (GNUNET_YES or GNUNET_NO)

Returns

String representing FWD or BCK.

GC_is_pid_bigger()

int GC_is_pid_bigger	(	uint32_t	bigger,
		uint32_t	smaller
	)

Check if one pid is bigger than other, accounting for overflow.

Parameters

bigger	Argument that should be bigger.
smaller	Argument that should be smaller.

Returns

True if bigger (arg1) has a higher value than smaller (arg 2).

GC_max_pid()

uint32_t GC_max_pid	(	uint32_t	a,
		uint32_t	b
	)

Get the higher ACK value out of two values, taking in account overflow.

Parameters

a	First ACK value.
b	Second ACK value.

Returns

Highest ACK value from the two.

GC_min_pid()

uint32_t GC_min_pid	(	uint32_t	a,
		uint32_t	b
	)

Get the lower ACK value out of two values, taking in account overflow.

Parameters

a	First ACK value.
b	Second ACK value.

Returns

Lowest ACK value from the two.

GC_bin2s()

size_t GC_bin2s	(	void *	bin,
		unsigned int	len,
		char **	output
	)

Allocate a string with a hexdump of any binary data.

Parameters

bin	Arbitrary binary data.
len	Length of bin in bytes.
output	Where to write the output (if *output be NULL it's allocated).

Returns

The size of the output.

GC_m2s()

const char * GC_m2s

(

uint16_t

m

)

Convert a message type into a string to help debug Generated with: FIND: "#define ([^ ]+)[ ]*([0-9]+)" REPLACE: " case \2: return "\1"; break;".

Parameters

m	Message type.

Returns

Human readable string description.