GNUnet 0.21.0
seti_api.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2012-2016, 2020 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 */
26#include "platform.h"
27#include "gnunet_util_lib.h"
28#include "gnunet_protocols.h"
29#include "gnunet_seti_service.h"
30#include "seti.h"
31
32
33#define LOG(kind, ...) GNUNET_log_from (kind, "seti-api", __VA_ARGS__)
34
35
40{
45
50
55
60
67
72
77 uint16_t iteration_id;
78
79};
80
81
86{
91 uint32_t accept_id;
92
98};
99
100
106{
112
117
123
129
135
140
145
149 uint32_t request_id;
150
156};
157
158
163{
168
175
181
186
191
196
201
202};
203
204
212static int
213check_result (void *cls,
214 const struct GNUNET_SETI_ResultMessage *msg)
215{
216 /* minimum size was already checked, everything else is OK! */
217 return GNUNET_OK;
218}
219
220
227static void
228handle_result (void *cls,
229 const struct GNUNET_SETI_ResultMessage *msg)
230{
231 struct GNUNET_SETI_Handle *set = cls;
233 struct GNUNET_SETI_Element e;
234 enum GNUNET_SETI_Status result_status;
235 int destroy_set;
236
237 GNUNET_assert (NULL != set->mq);
238 result_status = (enum GNUNET_SETI_Status) ntohs (msg->result_status);
240 "Got result message with status %d\n",
241 result_status);
242 oh = GNUNET_MQ_assoc_get (set->mq,
243 ntohl (msg->request_id));
244 if (NULL == oh)
245 {
246 /* 'oh' can be NULL if we canceled the operation, but the service
247 did not get the cancel message yet. */
249 "Ignoring result from canceled operation\n");
250 return;
251 }
252
253 switch (result_status)
254 {
257 e.data = &msg[1];
258 e.size = ntohs (msg->header.size)
259 - sizeof(struct GNUNET_SETI_ResultMessage);
260 e.element_type = ntohs (msg->element_type);
261 if (NULL != oh->result_cb)
262 oh->result_cb (oh->result_cls,
263 &e,
264 GNUNET_ntohll (msg->current_size),
266 return;
270 ntohl (msg->request_id));
272 set->ops_tail,
273 oh);
274 /* Need to do this calculation _before_ the result callback,
275 as IF the application still has a valid set handle, it
276 may trigger destruction of the set during the callback. */
277 destroy_set = (GNUNET_YES == set->destroy_requested) &&
278 (NULL == set->ops_head);
279 if (NULL != oh->result_cb)
280 {
281 oh->result_cb (oh->result_cls,
282 NULL,
283 GNUNET_ntohll (msg->current_size),
285 }
286 else
287 {
289 "No callback for final status\n");
290 }
291 if (destroy_set)
293 GNUNET_free (oh);
294 return;
295 }
296}
297
298
304static void
306{
307 struct GNUNET_SETI_Handle *set = oh->set;
308 struct GNUNET_SETI_OperationHandle *h_assoc;
309
310 if (NULL != oh->conclude_mqm)
312 /* is the operation already committed? */
313 if (NULL != set)
314 {
316 set->ops_tail,
317 oh);
318 h_assoc = GNUNET_MQ_assoc_remove (set->mq,
319 oh->request_id);
320 GNUNET_assert ((NULL == h_assoc) ||
321 (h_assoc == oh));
322 }
323 GNUNET_free (oh);
324}
325
326
334void
336{
337 struct GNUNET_SETI_Handle *set = oh->set;
339 struct GNUNET_MQ_Envelope *mqm;
340
342 "Cancelling SET operation\n");
343 if (NULL != set)
344 {
346 m->request_id = htonl (oh->request_id);
347 GNUNET_MQ_send (set->mq, mqm);
348 }
350 if ((NULL != set) &&
351 (GNUNET_YES == set->destroy_requested) &&
352 (NULL == set->ops_head))
353 {
355 "Destroying set after operation cancel\n");
357 }
358}
359
360
368static void
370 enum GNUNET_MQ_Error error)
371{
372 struct GNUNET_SETI_Handle *set = cls;
373
375 "Handling client set error %d\n",
376 error);
377 while (NULL != set->ops_head)
378 {
379 if ((NULL != set->ops_head->result_cb) &&
382 NULL,
383 0,
386 }
387 set->invalid = GNUNET_YES;
388}
389
390
398struct GNUNET_SETI_Handle *
400{
401 struct GNUNET_SETI_Handle *set = GNUNET_new (struct GNUNET_SETI_Handle);
402 struct GNUNET_MQ_MessageHandler mq_handlers[] = {
406 set),
408 };
409 struct GNUNET_MQ_Envelope *mqm;
410 struct GNUNET_SETI_CreateMessage *create_msg;
411
412 set->cfg = cfg;
414 "seti",
415 mq_handlers,
417 set);
418 if (NULL == set->mq)
419 {
420 GNUNET_free (set);
421 return NULL;
422 }
424 "Creating new intersection set\n");
425 mqm = GNUNET_MQ_msg (create_msg,
427 GNUNET_MQ_send (set->mq,
428 mqm);
429 return set;
430}
431
432
446int
448 const struct GNUNET_SETI_Element *element,
450 void *cb_cls)
451{
452 struct GNUNET_MQ_Envelope *mqm;
454
456 "adding element of type %u to set %p\n",
457 (unsigned int) element->element_type,
458 set);
459 if (GNUNET_YES == set->invalid)
460 {
461 if (NULL != cb)
462 cb (cb_cls);
463 return GNUNET_SYSERR;
464 }
466 element->size,
468 msg->element_type = htons (element->element_type);
469 GNUNET_memcpy (&msg[1],
470 element->data,
471 element->size);
473 cb,
474 cb_cls);
475 GNUNET_MQ_send (set->mq,
476 mqm);
477 return GNUNET_OK;
478}
479
480
487void
489{
490 /* destroying set while iterator is active is currently
491 not supported; we should expand the API to allow
492 clients to explicitly cancel the iteration! */
493 if ((NULL != set->ops_head) ||
495 {
497 "Set operations are pending, delaying set destruction\n");
499 return;
500 }
502 "Really destroying set\n");
503 if (NULL != set->mq)
504 {
505 GNUNET_MQ_destroy (set->mq);
506 set->mq = NULL;
507 }
508 GNUNET_free (set);
509}
510
511
513GNUNET_SETI_prepare (const struct GNUNET_PeerIdentity *other_peer,
514 const struct GNUNET_HashCode *app_id,
515 const struct GNUNET_MessageHeader *context_msg,
516 const struct GNUNET_SETI_Option options[],
518 void *result_cls)
519{
520 struct GNUNET_MQ_Envelope *mqm;
523
525 oh->result_cb = result_cb;
526 oh->result_cls = result_cls;
529 context_msg);
530 msg->app_id = *app_id;
531 msg->target_peer = *other_peer;
532 for (const struct GNUNET_SETI_Option *opt = options;
533 GNUNET_SETI_OPTION_END != opt->type;
534 opt++)
535 {
536 switch (opt->type)
537 {
539 msg->return_intersection = htonl (GNUNET_YES);
540 break;
541 default:
543 "Option with type %d not recognized\n",
544 (int) opt->type);
545 }
546 }
547 oh->conclude_mqm = mqm;
548 oh->request_id_addr = &msg->request_id;
549 return oh;
550}
551
552
558static void
559listen_connect (void *cls);
560
561
569static int
570check_request (void *cls,
571 const struct GNUNET_SETI_RequestMessage *msg)
572{
573 const struct GNUNET_MessageHeader *context_msg;
574
575 if (ntohs (msg->header.size) == sizeof(*msg))
576 return GNUNET_OK; /* no context message is OK */
577 context_msg = GNUNET_MQ_extract_nested_mh (msg);
578 if (NULL == context_msg)
579 {
580 /* malformed context message is NOT ok */
581 GNUNET_break_op (0);
582 return GNUNET_SYSERR;
583 }
584 return GNUNET_OK;
585}
586
587
594static void
595handle_request (void *cls,
596 const struct GNUNET_SETI_RequestMessage *msg)
597{
598 struct GNUNET_SETI_ListenHandle *lh = cls;
599 struct GNUNET_SETI_Request req;
600 const struct GNUNET_MessageHeader *context_msg;
601 struct GNUNET_MQ_Envelope *mqm;
602 struct GNUNET_SETI_RejectMessage *rmsg;
603
605 "Processing incoming operation request with id %u\n",
606 ntohl (msg->accept_id));
607 /* we got another valid request => reset the backoff */
609 req.accept_id = ntohl (msg->accept_id);
610 req.accepted = GNUNET_NO;
611 context_msg = GNUNET_MQ_extract_nested_mh (msg);
612 /* calling #GNUNET_SETI_accept() in the listen cb will set req->accepted */
613 lh->listen_cb (lh->listen_cls,
614 &msg->peer_id,
615 context_msg,
616 &req);
617 if (GNUNET_YES == req.accepted)
618 return; /* the accept-case is handled in #GNUNET_SETI_accept() */
620 "Rejected request %u\n",
621 ntohl (msg->accept_id));
622 mqm = GNUNET_MQ_msg (rmsg,
624 rmsg->accept_reject_id = msg->accept_id;
625 GNUNET_MQ_send (lh->mq,
626 mqm);
627}
628
629
637static void
639 enum GNUNET_MQ_Error error)
640{
641 struct GNUNET_SETI_ListenHandle *lh = cls;
642
644 "Listener broke down (%d), re-connecting\n",
645 (int) error);
646 GNUNET_MQ_destroy (lh->mq);
647 lh->mq = NULL;
650 lh);
652}
653
654
660static void
661listen_connect (void *cls)
662{
663 struct GNUNET_SETI_ListenHandle *lh = cls;
664 struct GNUNET_MQ_MessageHandler mq_handlers[] = {
668 lh),
670 };
671 struct GNUNET_MQ_Envelope *mqm;
673
674 lh->reconnect_task = NULL;
675 GNUNET_assert (NULL == lh->mq);
676 lh->mq = GNUNET_CLIENT_connect (lh->cfg,
677 "seti",
678 mq_handlers,
680 lh);
681 if (NULL == lh->mq)
682 return;
684 msg->app_id = lh->app_id;
685 GNUNET_MQ_send (lh->mq,
686 mqm);
687}
688
689
703 const struct GNUNET_HashCode *app_id,
705 void *listen_cls)
706{
707 struct GNUNET_SETI_ListenHandle *lh;
708
710 "Starting listener for app %s\n",
713 lh->listen_cb = listen_cb;
715 lh->cfg = cfg;
716 lh->app_id = *app_id;
718 listen_connect (lh);
719 if (NULL == lh->mq)
720 {
721 GNUNET_free (lh);
722 return NULL;
723 }
724 return lh;
725}
726
727
733void
735{
737 "Canceling listener %s\n",
738 GNUNET_h2s (&lh->app_id));
739 if (NULL != lh->mq)
740 {
741 GNUNET_MQ_destroy (lh->mq);
742 lh->mq = NULL;
743 }
744 if (NULL != lh->reconnect_task)
745 {
747 lh->reconnect_task = NULL;
748 }
749 GNUNET_free (lh);
750}
751
752
755 const struct GNUNET_SETI_Option options[],
757 void *result_cls)
758{
759 struct GNUNET_MQ_Envelope *mqm;
762
763 GNUNET_assert (GNUNET_NO == request->accepted);
765 "Client accepts set intersection operation with id %u\n",
766 request->accept_id);
767 request->accepted = GNUNET_YES;
768 mqm = GNUNET_MQ_msg (msg,
770 msg->accept_reject_id = htonl (request->accept_id);
772 oh->result_cb = result_cb;
773 oh->result_cls = result_cls;
774 oh->conclude_mqm = mqm;
775 oh->request_id_addr = &msg->request_id;
776 for (const struct GNUNET_SETI_Option *opt = options;
777 GNUNET_SETI_OPTION_END != opt->type;
778 opt++)
779 {
780 switch (opt->type)
781 {
784 msg->return_intersection = htonl (GNUNET_YES);
785 break;
786 default:
788 "Option with type %d not recognized\n",
789 (int) opt->type);
790 }
791 }
792 return oh;
793}
794
795
809int
811 struct GNUNET_SETI_Handle *set)
812{
813 if (NULL != oh->set)
814 {
815 /* Some other set was already committed for this
816 * operation, there is a logic bug in the client of this API */
817 GNUNET_break (0);
818 return GNUNET_OK;
819 }
820 GNUNET_assert (NULL != set);
821 if (GNUNET_YES == set->invalid)
822 return GNUNET_SYSERR;
824 "Client commits to SET\n");
825 GNUNET_assert (NULL != oh->conclude_mqm);
826 oh->set = set;
828 set->ops_tail,
829 oh);
831 oh);
832 *oh->request_id_addr = htonl (oh->request_id);
833 GNUNET_MQ_send (set->mq,
834 oh->conclude_mqm);
835 oh->conclude_mqm = NULL;
836 oh->request_id_addr = NULL;
837 return GNUNET_OK;
838}
839
840
848void
850 struct GNUNET_HashCode *ret_hash)
851{
853
854 /* It's not guaranteed that the element data is always after the element header,
855 so we need to hash the chunks separately. */
857 &element->size,
858 sizeof(uint16_t));
860 &element->element_type,
861 sizeof(uint16_t));
863 element->data,
864 element->size);
866 ret_hash);
867}
868
869
870/* end of seti_api.c */
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:109
static void listen_cb(void *cls)
We have been notified that our listen socket has something to read.
static struct GNUNET_FS_Handle * ctx
static int result
Global testing status.
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:40
Constants for network protocols.
Two-peer set intersection operations.
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:1057
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_log(kind,...)
void GNUNET_CRYPTO_hash_context_read(struct GNUNET_HashContext *hc, const void *buf, size_t size)
Add data to be hashed.
Definition: crypto_hash.c:366
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
void GNUNET_CRYPTO_hash_context_finish(struct GNUNET_HashContext *hc, struct GNUNET_HashCode *r_hash)
Finish the hash computation.
Definition: crypto_hash.c:390
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_HashContext * GNUNET_CRYPTO_hash_context_start(void)
Start incremental hashing operation.
Definition: crypto_hash.c:350
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#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.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
GNUNET_MQ_Error
Error codes for the queue.
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:304
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
void GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *mqm)
Discard the message queue message, free all allocated resources.
Definition: mq.c:285
#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:63
#define GNUNET_MQ_msg_nested_mh(mvar, type, mh)
Allocate a GNUNET_MQ_Envelope, and append a payload message after the given message struct.
void * GNUNET_MQ_assoc_get(struct GNUNET_MQ_Handle *mq, uint32_t request_id)
Get the data associated with a request_id in a queue.
Definition: mq.c:604
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore.
Definition: mq.c:638
uint32_t GNUNET_MQ_assoc_add(struct GNUNET_MQ_Handle *mq, void *assoc_data)
Associate the assoc_data in mq with a unique request id.
Definition: mq.c:575
void * GNUNET_MQ_assoc_remove(struct GNUNET_MQ_Handle *mq, uint32_t request_id)
Remove the association for a request_id.
Definition: mq.c:622
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:683
#define GNUNET_MQ_extract_nested_mh(var)
Return a pointer to the message at the end of the given message.
#define GNUNET_MESSAGE_TYPE_SETI_LISTEN
Listen for operation requests.
#define GNUNET_MESSAGE_TYPE_SETI_REJECT
Reject a set request.
#define GNUNET_MESSAGE_TYPE_SETI_EVALUATE
Evaluate a set operation.
#define GNUNET_MESSAGE_TYPE_SETI_ADD
Add element to set.
#define GNUNET_MESSAGE_TYPE_SETI_RESULT
Handle result message from operation.
#define GNUNET_MESSAGE_TYPE_SETI_REQUEST
Notify the client of an incoming request from a remote peer.
#define GNUNET_MESSAGE_TYPE_SETI_CREATE
Create a new local set.
#define GNUNET_MESSAGE_TYPE_SETI_CANCEL
Cancel a set operation.
#define GNUNET_MESSAGE_TYPE_SETI_ACCEPT
Accept an incoming set request.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
void(* GNUNET_SCHEDULER_TaskCallback)(void *cls)
Signature of the main function of a task.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1272
GNUNET_SETI_Status
Status for the result callback.
struct GNUNET_SETI_OperationHandle * GNUNET_SETI_accept(struct GNUNET_SETI_Request *request, const struct GNUNET_SETI_Option options[], GNUNET_SETI_ResultIterator result_cb, void *result_cls)
Accept a request we got via GNUNET_SETI_listen().
Definition: seti_api.c:754
void GNUNET_SETI_destroy(struct GNUNET_SETI_Handle *set)
Destroy the set handle if no operations are left, mark the set for destruction otherwise.
Definition: seti_api.c:488
int GNUNET_SETI_add_element(struct GNUNET_SETI_Handle *set, const struct GNUNET_SETI_Element *element, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Add an element to the given set.
Definition: seti_api.c:447
int GNUNET_SETI_commit(struct GNUNET_SETI_OperationHandle *oh, struct GNUNET_SETI_Handle *set)
Commit a set to be used with a set operation.
Definition: seti_api.c:810
void GNUNET_SETI_element_hash(const struct GNUNET_SETI_Element *element, struct GNUNET_HashCode *ret_hash)
Hash a set element.
Definition: seti_api.c:849
struct GNUNET_SETI_ListenHandle * GNUNET_SETI_listen(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_HashCode *app_id, GNUNET_SETI_ListenCallback listen_cb, void *listen_cls)
Wait for set operation requests for the given application id.
Definition: seti_api.c:702
void(* GNUNET_SETI_ListenCallback)(void *cls, const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_MessageHeader *context_msg, struct GNUNET_SETI_Request *request)
Called when another peer wants to do a set operation with the local peer.
struct GNUNET_SETI_OperationHandle * GNUNET_SETI_prepare(const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_HashCode *app_id, const struct GNUNET_MessageHeader *context_msg, const struct GNUNET_SETI_Option options[], GNUNET_SETI_ResultIterator result_cb, void *result_cls)
Prepare a set operation to be evaluated with another peer.
Definition: seti_api.c:513
struct GNUNET_SETI_Handle * GNUNET_SETI_create(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create an empty set.
Definition: seti_api.c:399
void GNUNET_SETI_operation_cancel(struct GNUNET_SETI_OperationHandle *oh)
Cancel the given set operation.
Definition: seti_api.c:335
void(* GNUNET_SETI_ResultIterator)(void *cls, const struct GNUNET_SETI_Element *element, uint64_t current_size, enum GNUNET_SETI_Status status)
Callback for set union operation results.
void GNUNET_SETI_listen_cancel(struct GNUNET_SETI_ListenHandle *lh)
Cancel the given listen operation.
Definition: seti_api.c:734
@ GNUNET_SETI_STATUS_DONE
Success, all elements have been sent (and received).
@ GNUNET_SETI_STATUS_ADD_LOCAL
Element should be added to the result set of the local peer, i.e.
@ GNUNET_SETI_STATUS_FAILURE
The other peer refused to do the operation with us, or something went wrong.
@ GNUNET_SETI_STATUS_DEL_LOCAL
Element should be delete from the result set of the local peer, i.e.
@ GNUNET_SETI_OPTION_RETURN_INTERSECTION
Return the elements remaining in the intersection (GNUNET_SETI_STATUS_ADD_LOCAL).
@ GNUNET_SETI_OPTION_END
List terminator.
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
static int check_result(void *cls, const struct GNUNET_SETI_ResultMessage *msg)
Check that the given msg is well-formed.
Definition: seti_api.c:213
static void handle_client_listener_error(void *cls, enum GNUNET_MQ_Error error)
Our connection with the set service encountered an error, re-initialize with exponential back-off.
Definition: seti_api.c:638
static void handle_result(void *cls, const struct GNUNET_SETI_ResultMessage *msg)
Handle result message for a set operation.
Definition: seti_api.c:228
static void handle_request(void *cls, const struct GNUNET_SETI_RequestMessage *msg)
Handle request message for a listen operation.
Definition: seti_api.c:595
static int check_request(void *cls, const struct GNUNET_SETI_RequestMessage *msg)
Check validity of request message for a listen operation.
Definition: seti_api.c:570
static void handle_client_set_error(void *cls, enum GNUNET_MQ_Error error)
We encountered an error communicating with the set service while performing a set operation.
Definition: seti_api.c:369
static void listen_connect(void *cls)
Connect to the set service in order to listen for requests.
Definition: seti_api.c:661
static void set_operation_destroy(struct GNUNET_SETI_OperationHandle *oh)
Destroy the given set operation.
Definition: seti_api.c:305
#define LOG(kind,...)
Definition: seti_api.c:33
A 512-bit hashcode.
Handle to a message queue.
Definition: mq.c:87
Message handler for a specific message type.
Header for all communications.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Definition: scheduler.c:136
Message sent by a listening client to the service to accept performing the operation with the other p...
Definition: seti.h:77
Sent to the service by the client in order to cancel a set operation.
Definition: seti.h:252
Message sent by the client to the service to ask starting a new set to perform operations with.
Definition: seti.h:40
Message sent by client to the service to add an element to the set.
Definition: seti.h:227
Element stored in a set.
const void * data
Actual data of the element.
uint16_t element_type
Application-specific element type.
uint16_t size
Number of bytes in the buffer pointed to by data.
Message sent by client to service to initiate a set operation as a client (not as listener).
Definition: seti.h:152
struct GNUNET_HashCode app_id
Application id.
Definition: seti.h:172
Opaque handle to a set.
Definition: seti_api.c:40
struct GNUNET_MQ_Handle * mq
Message queue for client.
Definition: seti_api.c:44
struct GNUNET_SETI_OperationHandle * ops_head
Linked list of operations on the set.
Definition: seti_api.c:49
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration, needed when creating (lazy) copies.
Definition: seti_api.c:59
uint16_t iteration_id
Both client and service count the number of iterators created so far to match replies with iterators.
Definition: seti_api.c:77
struct GNUNET_SETI_OperationHandle * ops_tail
Linked list of operations on the set.
Definition: seti_api.c:54
int destroy_requested
Should the set be destroyed once all operations are gone? GNUNET_SYSERR if GNUNET_SETI_destroy() must...
Definition: seti_api.c:66
int invalid
Has the set become invalid (e.g.
Definition: seti_api.c:71
Opaque handle to a listen operation.
Definition: seti_api.c:163
struct GNUNET_HashCode app_id
Application ID we listen for.
Definition: seti_api.c:195
struct GNUNET_TIME_Relative reconnect_backoff
Time to wait until we try to reconnect on failure.
Definition: seti_api.c:200
GNUNET_SETI_ListenCallback listen_cb
Function to call on a new incoming request, or on error.
Definition: seti_api.c:180
struct GNUNET_MQ_Handle * mq
Message queue for the client.
Definition: seti_api.c:167
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration handle for the listener, stored here to be able to reconnect transparently on connectio...
Definition: seti_api.c:174
struct GNUNET_SCHEDULER_Task * reconnect_task
Task for reconnecting when the listener fails.
Definition: seti_api.c:190
void * listen_cls
Closure for listen_cb.
Definition: seti_api.c:185
Message sent by the client to the service to start listening for incoming requests to perform a certa...
Definition: seti.h:54
Handle to an operation.
Definition: seti_api.c:106
void * result_cls
Closure for result_cb.
Definition: seti_api.c:116
struct GNUNET_SETI_OperationHandle * prev
Handles are kept in a linked list.
Definition: seti_api.c:139
uint32_t request_id
Request ID to identify the operation within the set.
Definition: seti_api.c:149
struct GNUNET_SETI_Handle * set
Local set used for the operation, NULL if no set has been provided by conclude yet.
Definition: seti_api.c:122
GNUNET_SETI_ResultIterator result_cb
Function to be called when we have a result, or an error.
Definition: seti_api.c:111
struct GNUNET_SETI_OperationHandle * next
Handles are kept in a linked list.
Definition: seti_api.c:144
uint32_t * request_id_addr
Address of the request if in the conclude message, used to patch the request id into the message when...
Definition: seti_api.c:134
struct GNUNET_MQ_Envelope * conclude_mqm
Message sent to the server on calling conclude, NULL if conclude has been called.
Definition: seti_api.c:128
int return_intersection
Should we return the resulting intersection (ADD) or the elements to remove (DEL)?
Definition: seti_api.c:155
Option for set operations.
Message sent by a listening client to the service to reject performing the operation with the other p...
Definition: seti.h:107
uint32_t accept_reject_id
ID of the incoming request we want to reject.
Definition: seti.h:116
A request for an operation with another client.
Definition: seti.h:124
Handle for a set operation request from another peer.
Definition: seti_api.c:86
uint32_t accept_id
Id of the request, used to identify the request when accepting/rejecting it.
Definition: seti_api.c:91
int accepted
Has the request been accepted already? GNUNET_YES/GNUNET_NO.
Definition: seti_api.c:97
Message sent by the service to the client to indicate an element that is removed (set intersection) o...
Definition: seti.h:192
uint16_t result_status
Was the evaluation successful? Contains an enum GNUNET_SETI_Status in NBO.
Definition: seti.h:212
Time for relative time used by GNUnet, in microseconds.