diff options
Diffstat (limited to 'src/scalarproduct/gnunet-scalarproduct.c')
-rw-r--r-- | src/scalarproduct/gnunet-scalarproduct.c | 402 |
1 files changed, 0 insertions, 402 deletions
diff --git a/src/scalarproduct/gnunet-scalarproduct.c b/src/scalarproduct/gnunet-scalarproduct.c deleted file mode 100644 index 14495de05..000000000 --- a/src/scalarproduct/gnunet-scalarproduct.c +++ /dev/null | |||
@@ -1,402 +0,0 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet. | ||
3 | Copyright (C) 2013, 2014 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 | /** | ||
22 | * @file scalarproduct/gnunet-scalarproduct.c | ||
23 | * @brief scalarproduct client | ||
24 | * @author Christian M. Fuchs | ||
25 | */ | ||
26 | #define GCRYPT_NO_DEPRECATED | ||
27 | #include <gcrypt.h> | ||
28 | #include <inttypes.h> | ||
29 | |||
30 | #include "platform.h" | ||
31 | #include "gnunet_util_lib.h" | ||
32 | #include "gnunet_scalarproduct_service.h" | ||
33 | #include "gnunet_protocols.h" | ||
34 | #include "scalarproduct.h" | ||
35 | |||
36 | #define LOG(kind, ...) GNUNET_log_from (kind, "gnunet-scalarproduct", \ | ||
37 | __VA_ARGS__) | ||
38 | |||
39 | |||
40 | /** | ||
41 | * the session key identifying this computation | ||
42 | */ | ||
43 | static struct GNUNET_HashCode session_key; | ||
44 | |||
45 | /** | ||
46 | * PeerID we want to compute a scalar product with | ||
47 | */ | ||
48 | static struct GNUNET_PeerIdentity peer_id; | ||
49 | |||
50 | /** | ||
51 | * Option -p: destination peer identity for checking message-ids with | ||
52 | */ | ||
53 | static char *input_peer_id; | ||
54 | |||
55 | /** | ||
56 | * Option -p: destination peer identity for checking message-ids with | ||
57 | */ | ||
58 | static char *input_session_key; | ||
59 | |||
60 | /** | ||
61 | * Option -e: vector to calculate a scalarproduct with | ||
62 | */ | ||
63 | static char *input_elements; | ||
64 | |||
65 | /** | ||
66 | * Global return value | ||
67 | */ | ||
68 | static int ret = -1; | ||
69 | |||
70 | /** | ||
71 | * our Scalarproduct Computation handle | ||
72 | */ | ||
73 | static struct GNUNET_SCALARPRODUCT_ComputationHandle *computation; | ||
74 | |||
75 | |||
76 | /** | ||
77 | * Callback called if we are initiating a new computation session | ||
78 | * | ||
79 | * @param cls unused | ||
80 | * @param status if our job was successfully processed | ||
81 | */ | ||
82 | static void | ||
83 | responder_callback (void *cls, | ||
84 | enum GNUNET_SCALARPRODUCT_ResponseStatus status) | ||
85 | { | ||
86 | switch (status) | ||
87 | { | ||
88 | case GNUNET_SCALARPRODUCT_STATUS_SUCCESS: | ||
89 | ret = 0; | ||
90 | LOG (GNUNET_ERROR_TYPE_INFO, | ||
91 | "Session %s concluded.\n", | ||
92 | GNUNET_h2s (&session_key)); | ||
93 | break; | ||
94 | |||
95 | case GNUNET_SCALARPRODUCT_STATUS_INVALID_RESPONSE: | ||
96 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
97 | "Session %s failed: invalid response\n", | ||
98 | GNUNET_h2s (&session_key)); | ||
99 | break; | ||
100 | |||
101 | case GNUNET_SCALARPRODUCT_STATUS_FAILURE: | ||
102 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
103 | "Session %s failed: service failure\n", | ||
104 | GNUNET_h2s (&session_key)); | ||
105 | break; | ||
106 | |||
107 | case GNUNET_SCALARPRODUCT_STATUS_DISCONNECTED: | ||
108 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
109 | "Session %s failed: service disconnect!\n", | ||
110 | GNUNET_h2s (&session_key)); | ||
111 | break; | ||
112 | |||
113 | default: | ||
114 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
115 | "Session %s failed: return code %d\n", | ||
116 | GNUNET_h2s (&session_key), | ||
117 | status); | ||
118 | } | ||
119 | computation = NULL; | ||
120 | GNUNET_SCHEDULER_shutdown (); | ||
121 | } | ||
122 | |||
123 | |||
124 | /** | ||
125 | * Callback called if we are initiating a new computation session | ||
126 | * | ||
127 | * @param cls unused | ||
128 | * @param status if our job was successfully processed | ||
129 | * @param result the result in gnu/gcry MPI format | ||
130 | */ | ||
131 | static void | ||
132 | requester_callback (void *cls, | ||
133 | enum GNUNET_SCALARPRODUCT_ResponseStatus status, | ||
134 | gcry_mpi_t result) | ||
135 | { | ||
136 | unsigned char *buf; | ||
137 | gcry_error_t rc; | ||
138 | |||
139 | switch (status) | ||
140 | { | ||
141 | case GNUNET_SCALARPRODUCT_STATUS_SUCCESS: | ||
142 | if (0 == (rc = gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buf, NULL, result))) | ||
143 | { | ||
144 | ret = 0; | ||
145 | fprintf (stdout, | ||
146 | "%s\n", | ||
147 | buf); | ||
148 | fflush (stdout); | ||
149 | } | ||
150 | else | ||
151 | LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, | ||
152 | "gcry_mpi_aprint", | ||
153 | rc); | ||
154 | break; | ||
155 | |||
156 | case GNUNET_SCALARPRODUCT_STATUS_INVALID_RESPONSE: | ||
157 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
158 | "Session %s with peer %s failed: invalid response received\n", | ||
159 | GNUNET_h2s (&session_key), | ||
160 | GNUNET_i2s (&peer_id)); | ||
161 | break; | ||
162 | |||
163 | case GNUNET_SCALARPRODUCT_STATUS_FAILURE: | ||
164 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
165 | "Session %s with peer %s failed: API failure\n", | ||
166 | GNUNET_h2s (&session_key), | ||
167 | GNUNET_i2s (&peer_id)); | ||
168 | break; | ||
169 | |||
170 | case GNUNET_SCALARPRODUCT_STATUS_DISCONNECTED: | ||
171 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
172 | "Session %s with peer %s was disconnected from service.\n", | ||
173 | GNUNET_h2s (&session_key), | ||
174 | GNUNET_i2s (&peer_id)); | ||
175 | break; | ||
176 | |||
177 | default: | ||
178 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
179 | "Session %s with peer %s failed: return code %d\n", | ||
180 | GNUNET_h2s (&session_key), | ||
181 | GNUNET_i2s (&peer_id), | ||
182 | status); | ||
183 | } | ||
184 | computation = NULL; | ||
185 | GNUNET_SCHEDULER_shutdown (); | ||
186 | } | ||
187 | |||
188 | |||
189 | /** | ||
190 | * Task run during shutdown. | ||
191 | * | ||
192 | * @param cls unused | ||
193 | * @param tc unused | ||
194 | */ | ||
195 | static void | ||
196 | shutdown_task (void *cls) | ||
197 | { | ||
198 | if (NULL != computation) | ||
199 | { | ||
200 | GNUNET_SCALARPRODUCT_cancel (computation); | ||
201 | ret = 1; /* aborted */ | ||
202 | } | ||
203 | } | ||
204 | |||
205 | |||
206 | /** | ||
207 | * Main function that will be run by the scheduler. | ||
208 | * | ||
209 | * @param cls closure | ||
210 | * @param args remaining command-line arguments | ||
211 | * @param cfgfile name of the configuration file used (for saving, can be NULL!) | ||
212 | * @param cfg configuration | ||
213 | */ | ||
214 | static void | ||
215 | run (void *cls, | ||
216 | char *const *args, | ||
217 | const char *cfgfile, | ||
218 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
219 | { | ||
220 | char *begin = input_elements; | ||
221 | char *end; | ||
222 | unsigned int i; | ||
223 | struct GNUNET_SCALARPRODUCT_Element *elements; | ||
224 | uint32_t element_count = 0; | ||
225 | |||
226 | if (NULL == input_elements) | ||
227 | { | ||
228 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
229 | _ ("You must specify at least one message ID to check!\n")); | ||
230 | return; | ||
231 | } | ||
232 | if ((NULL == input_session_key) || | ||
233 | (0 == strlen (input_session_key))) | ||
234 | { | ||
235 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
236 | _ ( | ||
237 | "This program needs a session identifier for comparing vectors.\n")); | ||
238 | return; | ||
239 | } | ||
240 | GNUNET_CRYPTO_hash (input_session_key, | ||
241 | strlen (input_session_key), | ||
242 | &session_key); | ||
243 | if ((NULL != input_peer_id) && | ||
244 | (GNUNET_OK != | ||
245 | GNUNET_CRYPTO_eddsa_public_key_from_string (input_peer_id, | ||
246 | strlen (input_peer_id), | ||
247 | &peer_id.public_key))) | ||
248 | { | ||
249 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
250 | _ ("Tried to set initiator mode, as peer ID was given. " | ||
251 | "However, `%s' is not a valid peer identifier.\n"), | ||
252 | input_peer_id); | ||
253 | return; | ||
254 | } | ||
255 | if (('\'' == *begin) && | ||
256 | ('\'' == begin[strlen (begin) - 1])) | ||
257 | { | ||
258 | begin[strlen (begin) - 1] = '\0'; | ||
259 | if (strlen (begin) > 0) | ||
260 | begin++; | ||
261 | } | ||
262 | for (end = begin; 0 != *end; end++) | ||
263 | if (*end == ';') | ||
264 | element_count++; | ||
265 | if (0 == element_count) | ||
266 | { | ||
267 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
268 | _ ("Need elements to compute the scalarproduct, got none.\n")); | ||
269 | return; | ||
270 | } | ||
271 | |||
272 | elements = GNUNET_malloc (sizeof(struct GNUNET_SCALARPRODUCT_Element) | ||
273 | * element_count); | ||
274 | |||
275 | for (i = 0; i < element_count; i++) | ||
276 | { | ||
277 | struct GNUNET_SCALARPRODUCT_Element element; | ||
278 | char*separator = NULL; | ||
279 | |||
280 | /* get the length of the current key,value; tuple */ | ||
281 | for (end = begin; *end != ';'; end++) | ||
282 | if (*end == ',') | ||
283 | separator = end; | ||
284 | |||
285 | /* final element */ | ||
286 | if ((NULL == separator) || | ||
287 | (begin == separator) || | ||
288 | (separator == end - 1)) | ||
289 | { | ||
290 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
291 | _ ("Malformed input, could not parse `%s'\n"), | ||
292 | begin); | ||
293 | GNUNET_free (elements); | ||
294 | return; | ||
295 | } | ||
296 | *separator = 0; | ||
297 | /* read the element's key */ | ||
298 | GNUNET_CRYPTO_hash (begin, | ||
299 | strlen (begin), | ||
300 | &element.key); | ||
301 | |||
302 | /* read the element's value */ | ||
303 | if (1 != | ||
304 | sscanf (separator + 1, | ||
305 | "%" SCNd64 ";", | ||
306 | &element.value)) | ||
307 | { | ||
308 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
309 | _ ("Could not convert `%s' to int64_t.\n"), | ||
310 | begin); | ||
311 | GNUNET_free (elements); | ||
312 | return; | ||
313 | } | ||
314 | element.value = GNUNET_htonll (element.value); | ||
315 | elements[i] = element; | ||
316 | begin = end + 1; | ||
317 | } | ||
318 | |||
319 | if (((NULL != input_peer_id) && | ||
320 | (NULL == (computation | ||
321 | = GNUNET_SCALARPRODUCT_start_computation (cfg, | ||
322 | &session_key, | ||
323 | &peer_id, | ||
324 | elements, | ||
325 | element_count, | ||
326 | &requester_callback, | ||
327 | NULL)))) || | ||
328 | ((NULL == input_peer_id) && | ||
329 | (NULL == (computation | ||
330 | = GNUNET_SCALARPRODUCT_accept_computation (cfg, | ||
331 | &session_key, | ||
332 | elements, | ||
333 | element_count, | ||
334 | & | ||
335 | responder_callback, | ||
336 | NULL))))) | ||
337 | { | ||
338 | fprintf (stderr, | ||
339 | _ ("Failed to initiate computation, were all keys unique?\n")); | ||
340 | GNUNET_free (elements); | ||
341 | return; | ||
342 | } | ||
343 | GNUNET_free (elements); | ||
344 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, | ||
345 | NULL); | ||
346 | ret = 0; | ||
347 | } | ||
348 | |||
349 | |||
350 | /** | ||
351 | * The main function to the scalarproduct client. | ||
352 | * | ||
353 | * @param argc number of arguments from the command line | ||
354 | * @param argv command line arguments | ||
355 | * @return 0 ok, 1 on error | ||
356 | */ | ||
357 | int | ||
358 | main (int argc, char *const *argv) | ||
359 | { | ||
360 | struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
361 | GNUNET_GETOPT_option_string ('e', | ||
362 | "elements", | ||
363 | "\"key1,val1;key2,val2;...,keyn,valn;\"", | ||
364 | gettext_noop ( | ||
365 | "A comma separated list of elements to compare as vector with our remote peer."), | ||
366 | &input_elements), | ||
367 | |||
368 | GNUNET_GETOPT_option_string ('e', | ||
369 | "elements", | ||
370 | "\"key1,val1;key2,val2;...,keyn,valn;\"", | ||
371 | gettext_noop ( | ||
372 | "A comma separated list of elements to compare as vector with our remote peer."), | ||
373 | &input_elements), | ||
374 | |||
375 | GNUNET_GETOPT_option_string ('p', | ||
376 | "peer", | ||
377 | "PEERID", | ||
378 | gettext_noop ( | ||
379 | "[Optional] peer to calculate our scalarproduct with. If this parameter is not given, the service will wait for a remote peer to compute the request."), | ||
380 | &input_peer_id), | ||
381 | |||
382 | GNUNET_GETOPT_option_string ('k', | ||
383 | "key", | ||
384 | "TRANSACTION_ID", | ||
385 | gettext_noop ( | ||
386 | "Transaction ID shared with peer."), | ||
387 | &input_session_key), | ||
388 | |||
389 | GNUNET_GETOPT_OPTION_END | ||
390 | }; | ||
391 | |||
392 | return (GNUNET_OK == | ||
393 | GNUNET_PROGRAM_run (argc, | ||
394 | argv, | ||
395 | "gnunet-scalarproduct", | ||
396 | gettext_noop ( | ||
397 | "Calculate the Vectorproduct with a GNUnet peer."), | ||
398 | options, &run, NULL)) ? ret : 1; | ||
399 | } | ||
400 | |||
401 | |||
402 | /* end of gnunet-scalarproduct.c */ | ||