GNUnet debian-0.24.3-26-g2202bbd4d
gnunet-service-core_sessions.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2009-2014, 2016 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 */
20
26#include "platform.h"
27#include "gnunet-service-core.h"
30#include "gnunet_constants.h"
31#include "core.h"
32
33
38#define MAX_ENCRYPTED_MESSAGE_QUEUE_SIZE 4
39
40
46{
51
56
61
68
74 size_t size;
75};
76
77
81struct Session
82{
87
92
98
104
109
114
115 // TODO
116 // struct GSC_ServicesInfo *services;
117
122
127};
128
129
134
135
143static struct Session *
145{
146 if (NULL == sessions)
147 return NULL;
149}
150
151
158void
160{
161 struct Session *session;
162 struct GSC_ClientActiveRequest *car;
163 struct SessionMessageEntry *sme;
164
165 if (NULL == pid)
166 {
167 /* We might not know the peer_id yet. */
168 return;
169 }
170 session = find_session (pid);
171 if (NULL == session)
172 return;
174 "Destroying session for peer `%s'\n",
175 GNUNET_i2s (session->peer));
176 if (NULL != session->cork_task)
177 {
179 session->cork_task = NULL;
180 }
181 while (NULL != (car = session->active_client_request_head))
182 {
185 car);
187 }
188 while (NULL != (sme = session->sme_head))
189 {
190 GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, sme);
191 GNUNET_free (sme);
192 }
193 // TODO
195 session->class);
197 GNUNET_YES ==
200 gettext_noop ("# peers connected"),
202 GNUNET_NO);
203 // TODO
204 // GSC_SVCI_destroy (session->services);
205 GNUNET_free (session);
206}
207
208
209
210
218void
220 struct GSC_KeyExchangeInfo *kx,
221 enum GNUNET_CORE_PeerClass class)
222{
223 struct Session *session;
224
226 "Creating session for peer `%s'\n",
227 GNUNET_i2s (peer));
228 session = GNUNET_new (struct Session);
229 // TODO
230 //session->services = GSC_SVCI_init ();
231 session->peer = peer;
232 session->kx = kx;
233 session->class = class;
236 sessions,
237 session->peer,
238 session,
241 gettext_noop ("# peers connected"),
243 GNUNET_NO);
244 // TODO
246 session->class);
247}
248
249
258void
260{
261 struct Session *session;
262
263 session = find_session (peer);
264 if (NULL == session)
265 {
266 /* KX/session is new for both sides; thus no need to restart what
267 has not yet begun */
268 return;
269 }
270}
271
272
273
274
283static int
285 const struct GNUNET_PeerIdentity *key,
286 void *value)
287{
288 struct GSC_Client *client = cls;
289 struct Session *session = value;
290
291 // TODO
293 session->peer,
294 session->class);
295 return GNUNET_OK;
296}
297
298
304void
306{
307 /* notify new client about existing sessions */
310 client);
311}
312
313
320static void
321try_transmission (struct Session *session);
322
323
333void
335{
336 struct Session *session;
337
338 session = find_session (&car->target);
339 if (NULL == session)
340 {
342 "Dropped client request for transmission (am disconnected)\n");
343 GNUNET_break (0); /* should have been rejected earlier */
345 return;
346 }
348 {
349 GNUNET_break (0);
351 return;
352 }
354 "Received client transmission request. queueing\n");
357 car);
358 try_transmission (session);
359}
360
361
368void
370{
371 struct Session *session;
372
373 if (0 == memcmp (&car->target,
375 sizeof(struct GNUNET_PeerIdentity)))
376 return;
377 session = find_session (&car->target);
378 GNUNET_assert (NULL != session);
381 car);
382 /* dequeueing of 'high' priority messages may unblock
383 transmission for lower-priority messages, so we also
384 need to try in this case. */
385 try_transmission (session);
386}
387
388
396static void
397solicit_messages (struct Session *session, size_t msize)
398{
399 struct GSC_ClientActiveRequest *car;
400 struct GSC_ClientActiveRequest *nxt;
401 size_t so_size;
403
404 so_size = msize;
406 for (car = session->active_client_request_head; NULL != car; car = car->next)
407 {
408 if (GNUNET_YES == car->was_solicited)
409 continue;
410 pmax = GNUNET_MAX (pmax, car->priority & GNUNET_MQ_PRIORITY_MASK);
411 }
412 nxt = session->active_client_request_head;
413 while (NULL != (car = nxt))
414 {
415 nxt = car->next;
416 if (car->priority < pmax)
417 continue;
419 break;
420 so_size += car->msize;
421 if (GNUNET_YES == car->was_solicited)
422 continue;
425 "Soliciting message with priority %u\n",
426 car->priority);
428 /* The above call may *dequeue* requests and thereby
429 clobber 'nxt'. Hence we need to restart from the
430 head of the list. */
431 nxt = session->active_client_request_head;
432 so_size = msize;
433 }
434}
435
436
443static void
444pop_cork_task (void *cls)
445{
446 struct Session *session = cls;
447
448 session->cork_task = NULL;
449 try_transmission (session);
450}
451
452
460static void
461try_transmission (struct Session *session)
462{
463 struct SessionMessageEntry *pos;
464 size_t msize;
465 struct GNUNET_TIME_Absolute now;
466 struct GNUNET_TIME_Absolute min_deadline;
469 struct GSC_ClientActiveRequest *car;
470 int excess;
471
472 msize = 0;
473 min_deadline = GNUNET_TIME_UNIT_FOREVER_ABS;
474 /* if the peer has excess bandwidth, background traffic is allowed,
475 otherwise not */
478 {
480 "Transmission queue already very long, waiting...\n");
481 return; /* queue already too long */
482 }
483 excess = GSC_NEIGHBOURS_check_excess_bandwidth (session->kx);
484 if (GNUNET_YES == excess)
486 else
488 /* determine highest priority of 'ready' messages we already solicited from clients */
489 pos = session->sme_head;
490 while ((NULL != pos) &&
492 {
494 msize += pos->size;
495 maxp = GNUNET_MAX (maxp, pos->priority & GNUNET_MQ_PRIORITY_MASK);
496 min_deadline = GNUNET_TIME_absolute_min (min_deadline, pos->deadline);
497 pos = pos->next;
498 }
499 GNUNET_log (
501 "Calculating transmission set with %u priority (%s) and %s earliest deadline\n",
502 maxp,
503 (GNUNET_YES == excess) ? "excess bandwidth" : "limited bandwidth",
505 min_deadline),
506 GNUNET_YES));
507
509 {
510 /* if highest already solicited priority from clients is not critical,
511 check if there are higher-priority messages to be solicited from clients */
512 if (GNUNET_YES == excess)
514 else
516 for (car = session->active_client_request_head; NULL != car;
517 car = car->next)
518 {
519 if (GNUNET_YES == car->was_solicited)
520 continue;
521 maxpc = GNUNET_MAX (maxpc, car->priority & GNUNET_MQ_PRIORITY_MASK);
522 }
523 if (maxpc > maxp)
524 {
525 /* we have messages waiting for solicitation that have a higher
526 priority than those that we already accepted; solicit the
527 high-priority messages first */
529 "Soliciting messages based on priority (%u > %u)\n",
530 maxpc,
531 maxp);
532 solicit_messages (session, 0);
533 return;
534 }
535 }
536 else
537 {
538 /* never solicit more, we have critical messages to process */
539 excess = GNUNET_NO;
541 }
543 if (((GNUNET_YES == excess) || (maxpc >= GNUNET_MQ_PRIO_BEST_EFFORT)) &&
544 ((0 == msize) ||
546 (min_deadline.abs_value_us > now.abs_value_us))))
547 {
548 /* not enough ready yet (tiny message & cork possible), or no messages at all,
549 and either excess bandwidth or best-effort or higher message waiting at
550 client; in this case, we try to solicit more */
551 GNUNET_log (
553 "Soliciting messages (excess %d, maxpc %d, message size %u, deadline %s)\n",
554 excess,
555 maxpc,
556 (unsigned int) msize,
559 min_deadline),
560 GNUNET_YES));
561 solicit_messages (session, msize);
562 if (msize > 0)
563 {
564 /* if there is data to send, just not yet, make sure we do transmit
565 * it once the deadline is reached */
567 "Corking until %s\n",
570 GNUNET_YES));
571 if (NULL != session->cork_task)
573 session->cork_task =
574 GNUNET_SCHEDULER_add_at (min_deadline, &pop_cork_task, session);
575 }
576 else
577 {
579 "Queue empty, waiting for solicitations\n");
580 }
581 return;
582 }
584 "Building combined plaintext buffer to transmit message!\n");
585 /* create plaintext buffer of all messages (that fit), encrypt and
586 transmit */
587 {
588 static unsigned long long total_bytes;
589 static unsigned int total_msgs;
590 char pbuf[msize]; /* plaintext */
591 size_t used;
592
593 used = 0;
594 while ((NULL != (pos = session->sme_head)) && (used + pos->size <= msize))
595 {
597 "Adding message of type %d to payload for %s\n",
598 ntohs (((const struct GNUNET_MessageHeader *) &pos[1])->type),
599 GNUNET_i2s (session->peer));
600 GNUNET_memcpy (&pbuf[used], &pos[1], pos->size);
601 used += pos->size;
602 GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, pos);
603 GNUNET_free (pos);
604 }
605 /* compute average payload size */
606 total_bytes += used;
607 total_msgs++;
608 if (0 == total_msgs)
609 {
610 /* 2^32 messages, wrap around... */
611 total_msgs = 1;
612 total_bytes = used;
613 }
615 "# avg payload per encrypted message",
616 total_bytes / total_msgs,
617 GNUNET_NO);
618 /* now actually transmit... */
619 GSC_KX_encrypt_and_transmit (session->kx, pbuf, used);
620 }
621}
622
623
631void
633{
634 struct Session *session;
635
637 "Transport solicits for %s\n",
638 GNUNET_i2s (pid));
639 session = find_session (pid);
640 if (NULL == session)
641 return;
642 try_transmission (session);
643}
644
645
646void
648 const struct GNUNET_MessageHeader *msg,
649 enum GNUNET_MQ_PriorityPreferences priority)
650{
651 struct Session *session;
652 struct SessionMessageEntry *sme;
653 struct SessionMessageEntry *pos;
654 size_t msize;
655
656 session = find_session (&car->target);
657 if (NULL == session)
658 return;
659 msize = ntohs (msg->size);
660 sme = GNUNET_malloc (sizeof(struct SessionMessageEntry) + msize);
661 GNUNET_memcpy (&sme[1], msg, msize);
662 sme->size = msize;
663 sme->priority = priority;
665 {
666 sme->deadline =
669 "Message corked, delaying transmission\n");
670 }
671 pos = session->sme_head;
672 while ((NULL != pos) && (pos->priority >= sme->priority))
673 pos = pos->next;
674 if (NULL == pos)
676 session->sme_tail,
677 sme);
678 else
680 session->sme_tail,
681 pos->prev,
682 sme);
683 try_transmission (session);
684}
685
686
690void
692{
694}
695
696
706static int
708 const struct GNUNET_PeerIdentity *key,
709 void *value)
710{
711 /* struct Session *session = value; */
712
714 return GNUNET_OK;
715}
716
717
721void
723{
724 if (NULL != sessions)
725 {
728 NULL);
730 sessions = NULL;
731 }
732}
733
734
735/* end of gnunet-service-core_sessions.c */
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
common internal definitions for core service
#define gettext_noop(String)
Definition: gettext.h:74
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.
static uint32_t type
Type string converted to DNS type value.
struct GNUNET_PeerIdentity GSC_my_identity
Our identity.
void GSC_CLIENTS_notify_client_about_neighbour(struct GSC_Client *client, const struct GNUNET_PeerIdentity *neighbour, enum GNUNET_CORE_PeerClass class)
Notify a particular client about a change to existing connection to one of our neighbours (check if t...
void GSC_CLIENTS_reject_request(struct GSC_ClientActiveRequest *car, int drop_client)
We will never be ready to transmit the given message in (disconnect or invalid request).
void GSC_CLIENTS_notify_clients_about_neighbour(const struct GNUNET_PeerIdentity *neighbour, enum GNUNET_CORE_PeerClass class)
Notify all clients about a change to existing session.
struct GNUNET_STATISTICS_Handle * GSC_stats
For creating statistics.
void GSC_CLIENTS_solicit_request(struct GSC_ClientActiveRequest *car)
Tell a client that we are ready to receive the message.
Globals for gnunet-service-core.
unsigned int GSC_NEIGHBOURS_get_queue_length(const struct GSC_KeyExchangeInfo *kxinfo)
Check how many messages are queued for the given neighbour.
int GSC_NEIGHBOURS_check_excess_bandwidth(const struct GSC_KeyExchangeInfo *kxinfo)
Check if the given neighbour has excess bandwidth available.
void GSC_KX_encrypt_and_transmit(struct GSC_KeyExchangeInfo *kx, const void *payload, size_t payload_size)
Encrypt and transmit payload.
code for managing the key exchange (SET_KEY, PING, PONG) with other peers
void GSC_SESSIONS_dequeue_request(struct GSC_ClientActiveRequest *car)
Dequeue a request from a client from transmission to a particular peer.
void GSC_SESSIONS_reinit(const struct GNUNET_PeerIdentity *peer)
The other peer has indicated that it 'lost' the session (KX down), reinitialize the session on our en...
static struct Session * find_session(const struct GNUNET_PeerIdentity *peer)
Find the session for the given peer.
static int free_session_helper(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Helper function for GSC_SESSIONS_done() to free all active sessions.
static int notify_client_about_session(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Notify the given client about the session (client is new).
void GSC_SESSIONS_transmit(struct GSC_ClientActiveRequest *car, const struct GNUNET_MessageHeader *msg, enum GNUNET_MQ_PriorityPreferences priority)
Transmit a message to a particular peer.
void GSC_SESSIONS_end(const struct GNUNET_PeerIdentity *pid)
End the session with the given peer (we are no longer connected).
void GSC_SESSIONS_solicit(const struct GNUNET_PeerIdentity *pid)
Traffic is being solicited for the given peer.
static struct GNUNET_CONTAINER_MultiPeerMap * sessions
Map of peer identities to struct Session.
void GSC_SESSIONS_create(const struct GNUNET_PeerIdentity *peer, struct GSC_KeyExchangeInfo *kx, enum GNUNET_CORE_PeerClass class)
Create a session, a key exchange was just completed.
void GSC_SESSIONS_notify_client_about_sessions(struct GSC_Client *client)
We have a new client, notify it about all current sessions.
static void pop_cork_task(void *cls)
Some messages were delayed (corked), but the timeout has now expired.
static void try_transmission(struct Session *session)
Try to perform a transmission on the given session.
static void solicit_messages(struct Session *session, size_t msize)
Solicit messages for transmission, starting with those of the highest priority.
void GSC_SESSIONS_init()
Initialize sessions subsystem.
#define MAX_ENCRYPTED_MESSAGE_QUEUE_SIZE
How many encrypted messages do we queue at most? Needed to bound memory consumption.
void GSC_SESSIONS_queue_request(struct GSC_ClientActiveRequest *car)
Queue a request from a client for transmission to a particular peer.
void GSC_SESSIONS_done()
Shutdown sessions subsystem.
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
#define GNUNET_CONSTANTS_MAX_CORK_DELAY
How long do we delay messages to get larger packet sizes (CORKing)?
#define GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE
What is the maximum size for encrypted messages? Note that this number imposes a clear limit on the m...
GNUNET_CORE_PeerClass
The peer class gives a hint about the capabilities of a peer.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert_after(head, tail, other, element)
Insert an element into a DLL after the given other element.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_log(kind,...)
#define GNUNET_MAX(a, b)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
GNUNET_MQ_PriorityPreferences
Per envelope preferences and priorities.
@ GNUNET_MQ_PRIO_CRITICAL_CONTROL
Highest priority, control traffic (e.g.
@ GNUNET_MQ_PRIORITY_MASK
Bit mask to apply to extract the priority bits.
@ GNUNET_MQ_PRIO_BACKGROUND
Lowest priority, i.e.
@ GNUNET_MQ_PREF_CORK_ALLOWED
Flag to indicate that CORKing is acceptable.
@ GNUNET_MQ_PRIO_BEST_EFFORT
Best-effort traffic (e.g.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run at the specified time.
Definition: scheduler.c:1254
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:980
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:406
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:599
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:316
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_min(struct GNUNET_TIME_Absolute t1, struct GNUNET_TIME_Absolute t2)
Return the minimum of two absolute time values.
Definition: time.c:360
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
Internal representation of the hash map.
Header for all communications.
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Definition: scheduler.c:136
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
Record kept for each request for transmission issued by a client that is still pending.
struct GSC_ClientActiveRequest * next
Active requests are kept in a doubly-linked list of the respective target peer.
struct GNUNET_PeerIdentity target
Which peer is the message going to be for?
int was_solicited
Has this request been solicited yet?
uint16_t msize
How many bytes does the client intend to send?
enum GNUNET_MQ_PriorityPreferences priority
How important is this request.
Data structure for each client connected to the CORE service.
struct GNUNET_SERVICE_Client * client
Handle for the client with the server API.
Information about the status of a key exchange with another peer.
Message ready for encryption.
struct GNUNET_TIME_Absolute deadline
Deadline for transmission, 1s after we received it (if we are not corking), otherwise "now".
size_t size
How long is the message? (number of bytes following the struct MessageEntry, but not including the si...
struct SessionMessageEntry * next
We keep messages in a doubly linked list.
struct SessionMessageEntry * prev
We keep messages in a doubly linked list.
enum GNUNET_MQ_PriorityPreferences priority
How important is this message.
Data kept per session.
struct SessionMessageEntry * sme_head
Head of list of messages ready for encryption.
struct SessionMessageEntry * sme_tail
Tail of list of messages ready for encryption.
const struct GNUNET_PeerIdentity * peer
Identity of the other peer.
struct GSC_ClientActiveRequest * active_client_request_head
Head of list of requests from clients for transmission to this peer.
enum GNUNET_CORE_PeerClass class
Class of the peer.
struct GNUNET_SCHEDULER_Task * cork_task
Task to transmit corked messages with a delay.
struct GSC_KeyExchangeInfo * kx
Key exchange state for this peer.
struct GSC_ClientActiveRequest * active_client_request_tail
Tail of list of requests from clients for transmission to this peer.