use NULL value in load_path_suffix to NOT load any files
[oweals/gnunet.git] / src / block / plugin_block_test.c
1 /*
2      This file is part of GNUnet
3      Copyright (C) 2010 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 block/plugin_block_test.c
23  * @brief block plugin to test the DHT as a simple key-value store;
24  *        this plugin simply accepts any (new) response for any key
25  * @author Christian Grothoff
26  */
27
28 #include "platform.h"
29 #include "gnunet_block_plugin.h"
30 #include "gnunet_block_group_lib.h"
31
32 /**
33  * Number of bits we set per entry in the bloomfilter.
34  * Do not change!
35  */
36 #define BLOOMFILTER_K 16
37
38 /**
39  * How big is the BF we use for DHT blocks?
40  */
41 #define TEST_BF_SIZE 8
42
43
44 /**
45  * Create a new block group.
46  *
47  * @param ctx block context in which the block group is created
48  * @param type type of the block for which we are creating the group
49  * @param nonce random value used to seed the group creation
50  * @param raw_data optional serialized prior state of the group, NULL if unavailable/fresh
51  * @param raw_data_size number of bytes in @a raw_data, 0 if unavailable/fresh
52  * @param va variable arguments specific to @a type
53  * @return block group handle, NULL if block groups are not supported
54  *         by this @a type of block (this is not an error)
55  */
56 static struct GNUNET_BLOCK_Group *
57 block_plugin_test_create_group (void *cls,
58                                 enum GNUNET_BLOCK_Type type,
59                                 uint32_t nonce,
60                                 const void *raw_data,
61                                 size_t raw_data_size,
62                                 va_list va)
63 {
64   unsigned int bf_size;
65   const char *guard;
66
67   guard = va_arg (va, const char *);
68   if (0 == strcmp (guard,
69                    "seen-set-size"))
70     bf_size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size (va_arg (va, unsigned
71                                                                    int),
72                                                            BLOOMFILTER_K);
73   else if (0 == strcmp (guard,
74                         "filter-size"))
75     bf_size = va_arg (va, unsigned int);
76   else
77   {
78     GNUNET_break (0);
79     bf_size = TEST_BF_SIZE;
80   }
81   GNUNET_break (NULL == va_arg (va, const char *));
82   return GNUNET_BLOCK_GROUP_bf_create (cls,
83                                        bf_size,
84                                        BLOOMFILTER_K,
85                                        type,
86                                        nonce,
87                                        raw_data,
88                                        raw_data_size);
89 }
90
91
92 /**
93  * Function called to validate a reply or a request.  For
94  * request evaluation, simply pass "NULL" for the reply_block.
95  *
96  * @param cls closure
97  * @param ctx block context
98  * @param type block type
99  * @param group group to check against
100  * @param eo control flags
101  * @param query original query (hash)
102  * @param xquery extrended query data (can be NULL, depending on type)
103  * @param xquery_size number of bytes in @a xquery
104  * @param reply_block response to validate
105  * @param reply_block_size number of bytes in @a reply_block
106  * @return characterization of result
107  */
108 static enum GNUNET_BLOCK_EvaluationResult
109 block_plugin_test_evaluate (void *cls,
110                             struct GNUNET_BLOCK_Context *ctx,
111                             enum GNUNET_BLOCK_Type type,
112                             struct GNUNET_BLOCK_Group *group,
113                             enum GNUNET_BLOCK_EvaluationOptions eo,
114                             const struct GNUNET_HashCode *query,
115                             const void *xquery,
116                             size_t xquery_size,
117                             const void *reply_block,
118                             size_t reply_block_size)
119 {
120   struct GNUNET_HashCode chash;
121
122   if (GNUNET_BLOCK_TYPE_TEST != type)
123   {
124     GNUNET_break (0);
125     return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
126   }
127   if (0 != xquery_size)
128   {
129     GNUNET_break_op (0);
130     return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
131   }
132   if (NULL == reply_block)
133     return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
134   GNUNET_CRYPTO_hash (reply_block,
135                       reply_block_size,
136                       &chash);
137   if (GNUNET_YES ==
138       GNUNET_BLOCK_GROUP_bf_test_and_set (group,
139                                           &chash))
140     return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
141   return GNUNET_BLOCK_EVALUATION_OK_MORE;
142 }
143
144
145 /**
146  * Function called to obtain the key for a block.
147  *
148  * @param cls closure
149  * @param type block type
150  * @param block block to get the key for
151  * @param block_size number of bytes in @a block
152  * @param key set to the key (query) for the given block
153  * @return #GNUNET_OK on success, #GNUNET_SYSERR if type not supported
154  *         (or if extracting a key from a block of this type does not work)
155  */
156 static int
157 block_plugin_test_get_key (void *cls,
158                            enum GNUNET_BLOCK_Type type,
159                            const void *block,
160                            size_t block_size,
161                            struct GNUNET_HashCode *key)
162 {
163   /* always fails since there is no fixed relationship between
164    * keys and values for test values */
165   return GNUNET_SYSERR;
166 }
167
168
169 /**
170  * Entry point for the plugin.
171  *
172  * @param cls NULL
173  * @return the exported block API
174  */
175 void *
176 libgnunet_plugin_block_test_init (void *cls)
177 {
178   static enum GNUNET_BLOCK_Type types[] = {
179     GNUNET_BLOCK_TYPE_TEST,
180     GNUNET_BLOCK_TYPE_ANY       /* end of list */
181   };
182   struct GNUNET_BLOCK_PluginFunctions *api;
183
184   api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions);
185   api->evaluate = &block_plugin_test_evaluate;
186   api->get_key = &block_plugin_test_get_key;
187   api->create_group = &block_plugin_test_create_group;
188   api->types = types;
189   return api;
190 }
191
192
193 /**
194  * Exit point from the plugin.
195  *
196  * @param cls the return value from #libgnunet_plugin_block_test_init
197  * @return NULL
198  */
199 void *
200 libgnunet_plugin_block_test_done (void *cls)
201 {
202   struct GNUNET_BLOCK_PluginFunctions *api = cls;
203
204   GNUNET_free (api);
205   return NULL;
206 }
207
208
209 /* end of plugin_block_test.c */