1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
/*
This file is part of GNUnet.
(C) 2009, 2010, 2011 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
by the Free Software Foundation; either version 3, or (at your
option) any later version.
GNUnet is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
/**
* @file core/gnunet-service-core_neighbours.h
* @brief code for managing of 'encrypted' sessions (key exchange done)
* @author Christian Grothoff
*/
#ifndef GNUNET_SERVICE_CORE_SESSIONS_H
#define GNUNET_SERVICE_CORE_SESSIONS_H
#include "gnunet-service-core.h"
#include "gnunet-service-core_kx.h"
/**
* Create a session, a key exchange was just completed.
*
* @param peer peer that is now connected
* @param kx key exchange that completed
*/
void
GSC_SESSIONS_create (const struct GNUNET_PeerIdentity *peer,
struct GSC_KeyExchangeInfo *kx);
/**
* End the session with the given peer (we are no longer
* connected).
*
* @param pid identity of peer to kill session with
*/
void
GSC_SESSIONS_end (const struct GNUNET_PeerIdentity *pid);
/**
* Traffic is being solicited for the given peer. This means that the
* message queue on the transport-level (NEIGHBOURS subsystem) is now
* empty and it is now OK to transmit another (non-control) message.
*
* @param pid identity of peer ready to receive data
*/
void
GSC_SESSIONS_solicit (const struct GNUNET_PeerIdentity *pid);
/**
* Queue a request from a client for transmission to a particular peer.
*
* @param car request to queue; this handle is then shared between
* the caller (CLIENTS subsystem) and SESSIONS and must not
* be released by either until either 'GNUNET_SESSIONS_dequeue',
* or 'GNUNET_CLIENTS_failed'
* have been invoked on it
*/
void
GSC_SESSIONS_queue_request (struct GSC_ClientActiveRequest *car);
/**
* Dequeue a request from a client from transmission to a particular peer.
*
* @param car request to dequeue; this handle will then be 'owned' by
* the caller (CLIENTS sysbsystem)
*/
void
GSC_SESSIONS_dequeue_request (struct GSC_ClientActiveRequest *car);
/**
* Transmit a message to a particular peer.
*
* @param car original request that was queued and then solicited,
* ownership does not change (dequeue will be called soon).
* @param msg message to transmit
* @param cork is corking allowed?
*/
void
GSC_SESSIONS_transmit (struct GSC_ClientActiveRequest *car,
const struct GNUNET_MessageHeader *msg, int cork);
/**
* Broadcast a message to all neighbours.
*
* @param msg message to transmit
*/
void
GSC_SESSIONS_broadcast (const struct GNUNET_MessageHeader *msg);
/**
* We have a new client, notify it about all current sessions.
*
* @param client the new client
*/
void
GSC_SESSIONS_notify_client_about_sessions (struct GSC_Client *client);
/**
* We've received a typemap message from a peer, update ours.
* Notifies clients about the session.
*
* @param peer peer this is about
* @param msg typemap update message
*/
void
GSC_SESSIONS_set_typemap (const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_MessageHeader *msg);
/**
* The given peer send a message of the specified type. Make sure the
* respective bit is set in its type-map and that clients are notified
* about the session.
*
* @param peer peer this is about
* @param type type of the message
*/
void
GSC_SESSIONS_add_to_typemap (const struct GNUNET_PeerIdentity *peer,
uint16_t type);
/**
* Handle CORE_ITERATE_PEERS request. For this request type, the client
* does not have to have transmitted an INIT request. All current peers
* are returned, regardless of which message types they accept.
*
* @param cls unused
* @param client client sending the iteration request
* @param message iteration request message
*/
void
GSC_SESSIONS_handle_client_iterate_peers (void *cls,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader
*message);
/**
* Handle CORE_PEER_CONNECTED request. Notify client about connection
* to the given neighbour. For this request type, the client does not
* have to have transmitted an INIT request. All current peers are
* returned, regardless of which message types they accept.
*
* @param cls unused
* @param client client sending the iteration request
* @param message iteration request message
*/
void
GSC_SESSIONS_handle_client_have_peer (void *cls,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader
*message);
/**
* Initialize sessions subsystem.
*/
void
GSC_SESSIONS_init (void);
/**
* Shutdown sessions subsystem.
*/
void
GSC_SESSIONS_done (void);
#endif
|
