GNUnet 0.22.2
gnunet_cadet_service.h
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2009-2017 GNUnet e.V.
4
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
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version.
9
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details.
14
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/>.
17
18 SPDX-License-Identifier: AGPL3.0-or-later
19 */
38#ifndef GNUNET_CADET_SERVICE_H
39#define GNUNET_CADET_SERVICE_H
40
41#ifdef __cplusplus
42extern "C" {
43#if 0 /* keep Emacsens' auto-indent happy */
44}
45#endif
46#endif
47
48
49#include "gnunet_util_lib.h"
50
54#define GNUNET_CADET_VERSION 0x00000005
55
56
61
66
71
72
77{
79};
80
81
86{
96 uint32_t cn GNUNET_PACKED;
97};
98
111typedef void *(*GNUNET_CADET_ConnectEventHandler) (
112 void *cls,
113 struct GNUNET_CADET_Channel *channel,
114 const struct GNUNET_PeerIdentity *source);
115
116
129 void *cls,
130 const struct GNUNET_CADET_Channel *channel);
131
132
148 void *cls,
149 const struct GNUNET_CADET_Channel *channel,
150 int window_size);
151
152
159struct GNUNET_CADET_Handle *
161
162
171void
173
174
188struct GNUNET_CADET_Port *
190 const struct GNUNET_HashCode *port,
192 void *connects_cls,
195 const struct GNUNET_MQ_MessageHandler *handlers);
196
197
204void
206
207
230 void *channel_cls,
231 const struct GNUNET_PeerIdentity *destination,
232 const struct GNUNET_HashCode *port,
235 const struct GNUNET_MQ_MessageHandler *handlers);
236
237
247void
249
250
257struct GNUNET_MQ_Handle *
258GNUNET_CADET_get_mq (const struct GNUNET_CADET_Channel *channel);
259
260
268void
270
280const struct GNUNET_HashCode *
281GC_u2h (uint32_t port);
282
284{
292
297{
302
307};
308
309
319const union GNUNET_CADET_ChannelInfo *
322 ...);
323
324
325/******************************************************************************/
326/******************** MONITORING /DEBUG API *************************/
327/******************************************************************************/
328/* The following calls are not useful for normal CADET operation, but for */
329/* debug and monitoring of the cadet state. They can be safely ignored. */
330/* The API can change at any point without notice. */
331/* Please contact the developer if you consider any of this calls useful for */
332/* normal cadet applications. */
333/******************************************************************************/
334
335
340{
345
350
351 // to be expanded!
352};
353
354
362typedef void (*GNUNET_CADET_ChannelCB) (
363 void *cls,
364 const struct GNUNET_CADET_ChannelInternals *info);
365
366
371
372
384 GNUNET_CADET_ChannelCB callback,
385 void *callback_cls);
386
387
394void *
396
397
402{
407
412
416 unsigned int n_paths;
417
421 unsigned int best_path_length;
422};
423
424
434typedef void (*GNUNET_CADET_PeersCB) (
435 void *cls,
436 const struct GNUNET_CADET_PeerListEntry *ple);
437
438
443
444
457 GNUNET_CADET_PeersCB callback,
458 void *callback_cls);
459
460
467void *
469
470
475{
480
484 unsigned int target_offset;
485
489 unsigned int path_length;
490
497};
498
499
507typedef void (*GNUNET_CADET_PathCB) (
508 void *cls,
509 const struct GNUNET_CADET_PeerPathDetail *ppd);
510
511
516
517
529 const struct GNUNET_PeerIdentity *id,
530 GNUNET_CADET_PathCB callback,
531 void *callback_cls);
532
533
540void *
542
543
548{
553
557 uint32_t channels;
558
562 uint32_t connections;
563
567 uint16_t estate;
568
572 uint16_t cstate;
573};
574
575
585typedef void (*GNUNET_CADET_TunnelsCB) (
586 void *cls,
587 const struct GNUNET_CADET_TunnelDetails *td);
588
589
594
595
608 GNUNET_CADET_TunnelsCB callback,
609 void *callback_cls);
610
611
618void *
620
621
622#if 0 /* keep Emacsens' auto-indent happy */
623{
624#endif
625#ifdef __cplusplus
626}
627#endif
628
629/* ifndef GNUNET_CADET_SERVICE_H */
630#endif
631 /* end of group */
633 /* end of group addition */
635
636/* end of gnunet_cadet_service.h */
struct GNUNET_MQ_MessageHandlers handlers[]
Definition: 003.c:1
void * connects(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Definition: 010.c:2
void disconnects(void *cls, const struct GNUNET_PeerIdentity *peer)
Definition: 011.c:2
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:98
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:108
static uint16_t port
Port number.
Definition: gnunet-bcd.c:146
static GstElement * source
Appsrc instance into which we write data for the pipeline.
#define info
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:38
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:894
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Indicate readiness to receive the next message on a channel.
Definition: cadet_api.c:872
void(* GNUNET_CADET_PeersCB)(void *cls, const struct GNUNET_CADET_PeerListEntry *ple)
Method called to retrieve information about all peers in CADET, called once per peer.
struct GNUNET_CADET_PeersLister * GNUNET_CADET_list_peers(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_CADET_PeersCB callback, void *callback_cls)
Request information about peers known to the running cadet service.
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:830
struct GNUNET_CADET_ListTunnels * GNUNET_CADET_list_tunnels(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_CADET_TunnelsCB callback, void *callback_cls)
Request information about tunnels of the running cadet peer.
const struct GNUNET_HashCode * GC_u2h(uint32_t port)
Transitional function to convert an unsigned int port to a hash value.
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected channel.
Definition: cadet_api.c:1066
void(* GNUNET_CADET_DisconnectEventHandler)(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever an MQ-channel is destroyed, unless the destruction was requested by GNUNET_C...
GNUNET_CADET_ChannelInfoOption
void * GNUNET_CADET_get_channel_cancel(struct GNUNET_CADET_ChannelMonitor *cm)
Cancel a channel monitor request.
struct GNUNET_CADET_Port * GNUNET_CADET_open_port(struct GNUNET_CADET_Handle *h, const struct GNUNET_HashCode *port, GNUNET_CADET_ConnectEventHandler connects, void *connects_cls, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Open a port to receive incoming MQ-based channels.
Definition: cadet_api.c:954
void * GNUNET_CADET_list_tunnels_cancel(struct GNUNET_CADET_ListTunnels *lt)
Cancel a monitor request.
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:774
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port.
Definition: cadet_api.c:801
struct GNUNET_CADET_ChannelMonitor * GNUNET_CADET_get_channel(const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_PeerIdentity *peer, GNUNET_CADET_ChannelCB callback, void *callback_cls)
Request information about channels to peer from the local peer.
void(* GNUNET_CADET_PathCB)(void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd)
Method called to retrieve information about a specific path known to the service.
struct GNUNET_CADET_Channel * GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h, void *channel_cls, const struct GNUNET_PeerIdentity *destination, const struct GNUNET_HashCode *port, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Create a new channel towards a remote peer.
Definition: cadet_api.c:1015
void * GNUNET_CADET_get_path_cancel(struct GNUNET_CADET_GetPath *gp)
Cancel gp operation.
void(* GNUNET_CADET_ChannelCB)(void *cls, const struct GNUNET_CADET_ChannelInternals *info)
Method called to retrieve information about a specific channel the cadet peer is aware of,...
const union GNUNET_CADET_ChannelInfo * GNUNET_CADET_channel_get_info(struct GNUNET_CADET_Channel *channel, enum GNUNET_CADET_ChannelInfoOption option,...)
Get information about a channel.
Definition: cadet_api.c:850
void *(* GNUNET_CADET_ConnectEventHandler)(void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *source)
Method called whenever a peer connects to a port in MQ-based CADET.
void * GNUNET_CADET_list_peers_cancel(struct GNUNET_CADET_PeersLister *pl)
Cancel a peer info request.
void(* GNUNET_CADET_TunnelsCB)(void *cls, const struct GNUNET_CADET_TunnelDetails *td)
Method called to retrieve information about all tunnels in CADET, called once per tunnel.
void(* GNUNET_CADET_WindowSizeEventHandler)(void *cls, const struct GNUNET_CADET_Channel *channel, int window_size)
Function called whenever an MQ-channel's transmission window size changes.
struct GNUNET_CADET_GetPath * GNUNET_CADET_get_path(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_PeerIdentity *id, GNUNET_CADET_PathCB callback, void *callback_cls)
Request information about a peer known to the running cadet peer.
@ GNUNET_CADET_OPTION_PEER
Who is the peer at the other end of the channel.
#define GNUNET_PACKED
gcc-ism to get packed structs.
Internal details about a channel.
struct GNUNET_PeerIdentity dest
Destination of the channel.
struct GNUNET_PeerIdentity root
Root of the channel.
struct GNUNET_PeerIdentity peer
Peer we want information about.
Number identifying a CADET channel within a tunnel.
uint32_t cn
Which number does this channel have that uniquely identifies it within its tunnel,...
Opaque handle to a channel.
Definition: cadet.h:116
GNUNET_CADET_WindowSizeEventHandler window_changes
Window change handler.
Definition: cadet.h:159
Hash uniquely identifying a connection below a tunnel.
struct GNUNET_ShortHashCode connection_of_tunnel
Operation handle.
Opaque handle to the service.
Definition: cadet_api.c:39
Information we return per peer.
unsigned int best_path_length
Length of the shortest path (0 = unknown, 1 = ourselves, 2 = direct neighbour).
unsigned int n_paths
Number of disjoint known paths to peer.
struct GNUNET_PeerIdentity peer
Which peer is the information about?
int have_tunnel
Do we have a tunnel to this peer?
Detailed information we return per peer.
unsigned int path_length
Number of entries on the path.
const struct GNUNET_PeerIdentity * path
Array of PEER_IDs representing all paths to reach the peer.
unsigned int target_offset
Offset of the target peer on the path.
struct GNUNET_PeerIdentity peer
Peer this is about.
Opaque handle to a port.
Definition: cadet_api.c:80
GNUNET_CADET_WindowSizeEventHandler window_changes
Window size change handler.
Definition: cadet_api.c:109
void * connects_cls
Closure for connects.
Definition: cadet_api.c:104
Details about a tunnel managed by CADET.
uint16_t cstate
What is our connectivity state?
uint32_t channels
How many channels use the tunnel.
uint16_t estate
What is our encryption state?
struct GNUNET_PeerIdentity peer
Target of the tunnel.
uint32_t connections
How many connections support the tunnel.
A 512-bit hashcode.
Handle to a message queue.
Definition: mq.c:87
Message handler for a specific message type.
The identity of the host (wraps the signing key of the peer).
A 256-bit hashcode.
Union to retrieve info about a channel.
const struct GNUNET_PeerIdentity peer
Peer on the other side of the channel.
int yes_no
GNUNET_YES / GNUNET_NO, for binary flags.