aboutsummaryrefslogtreecommitdiff
path: root/src/abd/abd_api.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/abd/abd_api.c')
-rw-r--r--src/abd/abd_api.c564
1 files changed, 0 insertions, 564 deletions
diff --git a/src/abd/abd_api.c b/src/abd/abd_api.c
deleted file mode 100644
index cc25d06da..000000000
--- a/src/abd/abd_api.c
+++ /dev/null
@@ -1,564 +0,0 @@
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2009-2013, 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/**
21 * @file abd/abd_api.c
22 * @brief library to access the ABD service
23 * @author Martin Schanzenbach
24 */
25#include "platform.h"
26#include "gnunet_util_lib.h"
27#include "gnunet_constants.h"
28#include "gnunet_arm_service.h"
29#include "gnunet_hello_lib.h"
30#include "gnunet_protocols.h"
31#include "gnunet_signatures.h"
32#include "abd.h"
33#include "abd_serialization.h"
34#include "gnunet_abd_service.h"
35#include "gnunet_identity_service.h"
36
37
38#define LOG(kind, ...) GNUNET_log_from (kind, "abd-api", __VA_ARGS__)
39
40/**
41 * Handle to a verify request
42 */
43struct GNUNET_ABD_Request
44{
45
46 /**
47 * DLL
48 */
49 struct GNUNET_ABD_Request *next;
50
51 /**
52 * DLL
53 */
54 struct GNUNET_ABD_Request *prev;
55
56 /**
57 * handle to abd service
58 */
59 struct GNUNET_ABD_Handle *abd_handle;
60
61 /**
62 * processor to call on verify result
63 */
64 GNUNET_ABD_CredentialResultProcessor verify_proc;
65
66 /**
67 * @e verify_proc closure
68 */
69 void *proc_cls;
70
71 /**
72 * processor to call on intermediate result
73 */
74 GNUNET_ABD_IntermediateResultProcessor int_proc;
75
76 /**
77 * @e verify_proc2 closure
78 */
79 void *proc2_cls;
80
81 /**
82 * Envelope with the message for this queue entry.
83 */
84 struct GNUNET_MQ_Envelope *env;
85
86 /**
87 * request id
88 */
89 uint32_t r_id;
90};
91
92
93/**
94 * Connection to the ABD service.
95 */
96struct GNUNET_ABD_Handle
97{
98
99 /**
100 * Configuration to use.
101 */
102 const struct GNUNET_CONFIGURATION_Handle *cfg;
103
104 /**
105 * Connection to service (if available).
106 */
107 struct GNUNET_MQ_Handle *mq;
108
109 /**
110 * Head of linked list of active verify requests.
111 */
112 struct GNUNET_ABD_Request *request_head;
113
114 /**
115 * Tail of linked list of active verify requests.
116 */
117 struct GNUNET_ABD_Request *request_tail;
118
119 /**
120 * Reconnect task
121 */
122 struct GNUNET_SCHEDULER_Task *reconnect_task;
123
124 /**
125 * How long do we wait until we try to reconnect?
126 */
127 struct GNUNET_TIME_Relative reconnect_backoff;
128
129 /**
130 * Request Id generator. Incremented by one for each request.
131 */
132 uint32_t r_id_gen;
133};
134
135
136/**
137 * Reconnect to ABD service.
138 *
139 * @param handle the handle to the ABD service
140 */
141static void
142reconnect (struct GNUNET_ABD_Handle *handle);
143
144
145/**
146 * Reconnect to ABD
147 *
148 * @param cls the handle
149 */
150static void
151reconnect_task (void *cls)
152{
153 struct GNUNET_ABD_Handle *handle = cls;
154
155 handle->reconnect_task = NULL;
156 reconnect (handle);
157}
158
159
160/**
161 * Disconnect from service and then reconnect.
162 *
163 * @param handle our handle
164 */
165static void
166force_reconnect (struct GNUNET_ABD_Handle *handle)
167{
168 GNUNET_MQ_destroy (handle->mq);
169 handle->mq = NULL;
170 handle->reconnect_backoff =
171 GNUNET_TIME_STD_BACKOFF (handle->reconnect_backoff);
172 handle->reconnect_task =
173 GNUNET_SCHEDULER_add_delayed (handle->reconnect_backoff,
174 &reconnect_task,
175 handle);
176}
177
178
179/**
180 * Generic error handler, called with the appropriate error code and
181 * the same closure specified at the creation of the message queue.
182 * Not every message queue implementation supports an error handler.
183 *
184 * @param cls closure with the `struct GNUNET_ABD_Handle *`
185 * @param error error code
186 */
187static void
188mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
189{
190 struct GNUNET_ABD_Handle *handle = cls;
191
192 force_reconnect (handle);
193}
194
195
196/**
197 * Check validity of message received from the ABD service
198 *
199 * @param cls the `struct GNUNET_ABD_Handle *`
200 * @param vr_msg the incoming message
201 */
202static int
203check_result (void *cls, const struct DelegationChainResultMessage *vr_msg)
204{
205 // TODO
206 return GNUNET_OK;
207}
208
209
210/**
211 * Handler for messages received from the ABD service
212 *
213 * @param cls the `struct GNUNET_ABD_Handle *`
214 * @param vr_msg the incoming message
215 */
216static void
217handle_result (void *cls, const struct DelegationChainResultMessage *vr_msg)
218{
219 struct GNUNET_ABD_Handle *handle = cls;
220 uint32_t r_id = ntohl (vr_msg->id);
221 struct GNUNET_ABD_Request *vr;
222 size_t mlen = ntohs (vr_msg->header.size) - sizeof (*vr_msg);
223 uint32_t d_count = ntohl (vr_msg->d_count);
224 uint32_t c_count = ntohl (vr_msg->c_count);
225 struct GNUNET_ABD_Delegation d_chain[d_count];
226 struct GNUNET_ABD_Delegate dels[c_count];
227 GNUNET_ABD_CredentialResultProcessor proc;
228 void *proc_cls;
229
230 LOG (GNUNET_ERROR_TYPE_DEBUG,
231 "Received verify reply from ABD service\n");
232 for (vr = handle->request_head; NULL != vr; vr = vr->next)
233 if (vr->r_id == r_id)
234 break;
235 if (NULL == vr)
236 return;
237 proc = vr->verify_proc;
238 proc_cls = vr->proc_cls;
239 GNUNET_CONTAINER_DLL_remove (handle->request_head, handle->request_tail, vr);
240 GNUNET_MQ_discard (vr->env);
241 GNUNET_free (vr);
242 GNUNET_assert (
243 GNUNET_OK ==
244 GNUNET_ABD_delegation_chain_deserialize (mlen,
245 (const char *) &vr_msg[1],
246 d_count,
247 d_chain,
248 c_count,
249 dels));
250 if (GNUNET_NO == ntohl (vr_msg->del_found))
251 {
252 proc (proc_cls, 0, NULL, 0,
253 NULL);
254 }
255 else
256 {
257 proc (proc_cls, d_count, d_chain, c_count, dels);
258 }
259}
260
261
262static int
263check_intermediate (void *cls, const struct
264 DelegationChainIntermediateMessage *vr_msg)
265{
266 // TODO
267 return GNUNET_OK;
268}
269
270
271static void
272handle_intermediate (void *cls, const struct
273 DelegationChainIntermediateMessage *vr_msg)
274{
275 struct GNUNET_ABD_Handle *handle = cls;
276 uint32_t r_id = ntohl (vr_msg->id);
277 uint32_t size = ntohl (vr_msg->size);
278 bool is_bw = ntohs (vr_msg->is_bw);
279 struct GNUNET_ABD_Request *vr;
280 GNUNET_ABD_IntermediateResultProcessor proc;
281 void *proc_cls;
282 struct GNUNET_ABD_Delegation *dd;
283
284
285 LOG (GNUNET_ERROR_TYPE_DEBUG,
286 "Received intermediate reply from ABD service\n");
287
288 for (vr = handle->request_head; NULL != vr; vr = vr->next)
289 if (vr->r_id == r_id)
290 break;
291 if (NULL == vr)
292 return;
293
294 proc = vr->int_proc;
295 proc_cls = vr->proc2_cls;
296
297 dd = GNUNET_new (struct GNUNET_ABD_Delegation);
298 GNUNET_assert (
299 GNUNET_OK ==
300 GNUNET_ABD_delegation_chain_deserialize (size,
301 (const char *) &vr_msg[1],
302 1,
303 dd,
304 0,
305 NULL));
306 proc (proc_cls, dd, is_bw);
307}
308
309
310/**
311 * Reconnect to ABD service.
312 *
313 * @param handle the handle to the ABD service
314 */
315static void
316reconnect (struct GNUNET_ABD_Handle *handle)
317{
318 struct GNUNET_MQ_MessageHandler handlers[] =
319 {GNUNET_MQ_hd_var_size (result,
320 GNUNET_MESSAGE_TYPE_ABD_VERIFY_RESULT,
321 struct DelegationChainResultMessage,
322 handle),
323 GNUNET_MQ_hd_var_size (result,
324 GNUNET_MESSAGE_TYPE_ABD_COLLECT_RESULT,
325 struct DelegationChainResultMessage,
326 handle),
327 GNUNET_MQ_hd_var_size (intermediate,
328 GNUNET_MESSAGE_TYPE_ABD_INTERMEDIATE_RESULT,
329 struct DelegationChainIntermediateMessage,
330 handle),
331 GNUNET_MQ_handler_end ()};
332 struct GNUNET_ABD_Request *vr;
333
334 GNUNET_assert (NULL == handle->mq);
335 LOG (GNUNET_ERROR_TYPE_DEBUG, "Trying to connect to ABD\n");
336 handle->mq = GNUNET_CLIENT_connect (handle->cfg,
337 "abd",
338 handlers,
339 &mq_error_handler,
340 handle);
341 if (NULL == handle->mq)
342 return;
343 for (vr = handle->request_head; NULL != vr; vr = vr->next)
344 GNUNET_MQ_send_copy (handle->mq, vr->env);
345}
346
347
348/**
349 * Initialize the connection with the ABD service.
350 *
351 * @param cfg configuration to use
352 * @return handle to the ABD service, or NULL on error
353 */
354struct GNUNET_ABD_Handle *
355GNUNET_ABD_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
356{
357 struct GNUNET_ABD_Handle *handle;
358
359 handle = GNUNET_new (struct GNUNET_ABD_Handle);
360 handle->cfg = cfg;
361 reconnect (handle);
362 if (NULL == handle->mq)
363 {
364 GNUNET_free (handle);
365 return NULL;
366 }
367 return handle;
368}
369
370
371/**
372 * Shutdown connection with the ABD service.
373 *
374 * @param handle handle of the ABD connection to stop
375 */
376void
377GNUNET_ABD_disconnect (struct GNUNET_ABD_Handle *handle)
378{
379 if (NULL != handle->mq)
380 {
381 GNUNET_MQ_destroy (handle->mq);
382 handle->mq = NULL;
383 }
384 if (NULL != handle->reconnect_task)
385 {
386 GNUNET_SCHEDULER_cancel (handle->reconnect_task);
387 handle->reconnect_task = NULL;
388 }
389 GNUNET_assert (NULL == handle->request_head);
390 GNUNET_free (handle);
391}
392
393
394/**
395 * Cancel pending verify request
396 *
397 * @param lr the verify request to cancel
398 */
399void
400GNUNET_ABD_request_cancel (struct GNUNET_ABD_Request *lr)
401{
402 struct GNUNET_ABD_Handle *handle = lr->abd_handle;
403
404 GNUNET_CONTAINER_DLL_remove (handle->request_head, handle->request_tail, lr);
405 GNUNET_MQ_discard (lr->env);
406 GNUNET_free (lr);
407}
408
409
410/**
411 * Performs attribute collection.
412 * Collects all abds of subject to fulfill the
413 * attribute, if possible
414 *
415 * @param handle handle to the Credential service
416 * @param issuer_key the issuer public key
417 * @param issuer_attribute the issuer attribute
418 * @param subject_key the subject public key
419 * @param proc function to call on result
420 * @param proc_cls closure for processor
421 * @return handle to the queued request
422 */
423struct GNUNET_ABD_Request *
424GNUNET_ABD_collect (
425 struct GNUNET_ABD_Handle *handle,
426 const struct GNUNET_CRYPTO_EcdsaPublicKey *issuer_key,
427 const char *issuer_attribute,
428 const struct GNUNET_CRYPTO_EcdsaPrivateKey *subject_key,
429 enum GNUNET_ABD_AlgoDirectionFlags direction,
430 GNUNET_ABD_CredentialResultProcessor proc,
431 void *proc_cls,
432 GNUNET_ABD_IntermediateResultProcessor proc2,
433 void *proc2_cls)
434{
435 /* IPC to shorten abd names, return shorten_handle */
436 struct CollectMessage *c_msg;
437 struct GNUNET_ABD_Request *vr;
438 size_t nlen;
439
440 if (NULL == issuer_attribute)
441 {
442 GNUNET_break (0);
443 return NULL;
444 }
445
446 // DEBUG LOG
447 LOG (GNUNET_ERROR_TYPE_DEBUG,
448 "Trying to collect `%s' in ABD\n",
449 issuer_attribute);
450 nlen = strlen (issuer_attribute) + 1;
451 if (nlen >= GNUNET_MAX_MESSAGE_SIZE - sizeof (*vr))
452 {
453 GNUNET_break (0);
454 return NULL;
455 }
456 vr = GNUNET_new (struct GNUNET_ABD_Request);
457 vr->abd_handle = handle;
458 vr->verify_proc = proc;
459 vr->proc_cls = proc_cls;
460 vr->int_proc = proc2;
461 vr->proc2_cls = proc2_cls;
462 vr->r_id = handle->r_id_gen++;
463 vr->env =
464 GNUNET_MQ_msg_extra (c_msg, nlen, GNUNET_MESSAGE_TYPE_ABD_COLLECT);
465 c_msg->id = htonl (vr->r_id);
466 c_msg->subject_key = *subject_key;
467 c_msg->issuer_key = *issuer_key;
468 c_msg->issuer_attribute_len = htons (strlen (issuer_attribute));
469 c_msg->resolution_algo = htons (direction);
470
471 GNUNET_memcpy (&c_msg[1], issuer_attribute, strlen (issuer_attribute));
472 GNUNET_CONTAINER_DLL_insert (handle->request_head, handle->request_tail, vr);
473 if (NULL != handle->mq)
474 GNUNET_MQ_send_copy (handle->mq, vr->env);
475 return vr;
476}
477
478
479/**
480 * Performs attribute verification.
481 * Checks if there is a delegation chain from
482 * attribute ``issuer_attribute'' issued by the issuer
483 * with public key ``issuer_key'' maps to the attribute
484 * ``subject_attribute'' claimed by the subject with key
485 * ``subject_key''
486 *
487 * @param handle handle to the Credential service
488 * @param issuer_key the issuer public key
489 * @param issuer_attribute the issuer attribute
490 * @param subject_key the subject public key
491 * @param delegate_count number of delegates provided
492 * @param delegates subject delegates
493 * @param proc function to call on result
494 * @param proc_cls closure for processor
495 * @return handle to the queued request
496 */
497struct GNUNET_ABD_Request *
498GNUNET_ABD_verify (
499 struct GNUNET_ABD_Handle *handle,
500 const struct GNUNET_CRYPTO_EcdsaPublicKey *issuer_key,
501 const char *issuer_attribute,
502 const struct GNUNET_CRYPTO_EcdsaPublicKey *subject_key,
503 uint32_t delegate_count,
504 const struct GNUNET_ABD_Delegate *delegates,
505 enum GNUNET_ABD_AlgoDirectionFlags direction,
506 GNUNET_ABD_CredentialResultProcessor proc,
507 void *proc_cls,
508 GNUNET_ABD_IntermediateResultProcessor proc2,
509 void *proc2_cls)
510{
511 /* IPC to shorten abd names, return shorten_handle */
512 struct VerifyMessage *v_msg;
513 struct GNUNET_ABD_Request *vr;
514 size_t nlen;
515 size_t clen;
516
517 if ((NULL == issuer_attribute) || (NULL == delegates))
518 {
519 GNUNET_break (0);
520 return NULL;
521 }
522
523 clen = GNUNET_ABD_delegates_get_size (delegate_count, delegates);
524
525 // DEBUG LOG
526 LOG (GNUNET_ERROR_TYPE_DEBUG,
527 "Trying to verify `%s' in ABD\n",
528 issuer_attribute);
529 nlen = strlen (issuer_attribute) + 1 + clen;
530 if (nlen >= GNUNET_MAX_MESSAGE_SIZE - sizeof (*vr))
531 {
532 GNUNET_break (0);
533 return NULL;
534 }
535 vr = GNUNET_new (struct GNUNET_ABD_Request);
536 vr->abd_handle = handle;
537 vr->verify_proc = proc;
538 vr->proc_cls = proc_cls;
539 vr->int_proc = proc2;
540 vr->proc2_cls = proc2_cls;
541 vr->r_id = handle->r_id_gen++;
542 vr->env =
543 GNUNET_MQ_msg_extra (v_msg, nlen, GNUNET_MESSAGE_TYPE_ABD_VERIFY);
544 v_msg->id = htonl (vr->r_id);
545 v_msg->subject_key = *subject_key;
546 v_msg->d_count = htonl (delegate_count);
547 v_msg->issuer_key = *issuer_key;
548 v_msg->issuer_attribute_len = htons (strlen (issuer_attribute));
549 v_msg->resolution_algo = htons (direction);
550
551 GNUNET_memcpy (&v_msg[1], issuer_attribute, strlen (issuer_attribute));
552 GNUNET_ABD_delegates_serialize (delegate_count,
553 delegates,
554 clen,
555 ((char *) &v_msg[1])
556 + strlen (issuer_attribute) + 1);
557 GNUNET_CONTAINER_DLL_insert (handle->request_head, handle->request_tail, vr);
558 if (NULL != handle->mq)
559 GNUNET_MQ_send_copy (handle->mq, vr->env);
560 return vr;
561}
562
563
564/* end of abd_api.c */
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-24 22:47:46 +0000