aboutsummaryrefslogtreecommitdiff
path: root/src/block/plugin_block_fs.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/block/plugin_block_fs.c')
-rw-r--r--src/block/plugin_block_fs.c408
1 files changed, 196 insertions, 212 deletions
diff --git a/src/block/plugin_block_fs.c b/src/block/plugin_block_fs.c
index caf009ddf..db8e59991 100644
--- a/src/block/plugin_block_fs.c
+++ b/src/block/plugin_block_fs.c
@@ -57,14 +57,13 @@
57 */ 57 */
58static enum GNUNET_BLOCK_EvaluationResult 58static enum GNUNET_BLOCK_EvaluationResult
59block_plugin_fs_evaluate (void *cls, 59block_plugin_fs_evaluate (void *cls,
60 enum GNUNET_BLOCK_Type type, 60 enum GNUNET_BLOCK_Type type,
61 const GNUNET_HashCode *query, 61 const GNUNET_HashCode * query,
62 struct GNUNET_CONTAINER_BloomFilter **bf, 62 struct GNUNET_CONTAINER_BloomFilter **bf,
63 int32_t bf_mutator, 63 int32_t bf_mutator,
64 const void *xquery, 64 const void *xquery,
65 size_t xquery_size, 65 size_t xquery_size,
66 const void *reply_block, 66 const void *reply_block, size_t reply_block_size)
67 size_t reply_block_size)
68{ 67{
69 const struct SBlock *sb; 68 const struct SBlock *sb;
70 GNUNET_HashCode chash; 69 GNUNET_HashCode chash;
@@ -73,92 +72,81 @@ block_plugin_fs_evaluate (void *cls,
73 GNUNET_HashCode sh; 72 GNUNET_HashCode sh;
74 73
75 switch (type) 74 switch (type)
75 {
76 case GNUNET_BLOCK_TYPE_FS_DBLOCK:
77 case GNUNET_BLOCK_TYPE_FS_IBLOCK:
78 if (xquery_size != 0)
76 { 79 {
77 case GNUNET_BLOCK_TYPE_FS_DBLOCK: 80 GNUNET_break_op (0);
78 case GNUNET_BLOCK_TYPE_FS_IBLOCK: 81 return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
79 if (xquery_size != 0)
80 {
81 GNUNET_break_op (0);
82 return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
83 }
84 if (reply_block == NULL)
85 return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
86 return GNUNET_BLOCK_EVALUATION_OK_LAST;
87 case GNUNET_BLOCK_TYPE_FS_KBLOCK:
88 case GNUNET_BLOCK_TYPE_FS_NBLOCK:
89 if (xquery_size != 0)
90 {
91 GNUNET_break_op (0);
92 return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
93 }
94 if (reply_block == NULL)
95 return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
96 GNUNET_CRYPTO_hash (reply_block,
97 reply_block_size,
98 &chash);
99 GNUNET_BLOCK_mingle_hash (&chash, bf_mutator, &mhash);
100 if (NULL != *bf)
101 {
102 if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf,
103 &mhash))
104 return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
105 }
106 else
107 {
108 *bf = GNUNET_CONTAINER_bloomfilter_init (NULL,
109 8,
110 BLOOMFILTER_K);
111 }
112 GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash);
113 return GNUNET_BLOCK_EVALUATION_OK_MORE;
114 case GNUNET_BLOCK_TYPE_FS_SBLOCK:
115 if (xquery_size != sizeof (GNUNET_HashCode))
116 {
117 GNUNET_break_op (0);
118 return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
119 }
120 if (reply_block == NULL)
121 return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
122 nsid = xquery;
123 if (reply_block_size < sizeof (struct SBlock))
124 {
125 GNUNET_break_op (0);
126 return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
127 }
128 sb = reply_block;
129 GNUNET_CRYPTO_hash (&sb->subspace,
130 sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
131 &sh);
132 if (0 != memcmp (nsid,
133 &sh,
134 sizeof (GNUNET_HashCode)))
135 {
136 GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
137 "block-fs",
138 _("Reply mismatched in terms of namespace. Discarded.\n"));
139 return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
140 }
141 GNUNET_CRYPTO_hash (reply_block,
142 reply_block_size,
143 &chash);
144 GNUNET_BLOCK_mingle_hash (&chash, bf_mutator, &mhash);
145 if (NULL != *bf)
146 {
147 if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf,
148 &mhash))
149 return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
150 }
151 else
152 {
153 *bf = GNUNET_CONTAINER_bloomfilter_init (NULL,
154 8,
155 BLOOMFILTER_K);
156 }
157 GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash);
158 return GNUNET_BLOCK_EVALUATION_OK_MORE;
159 default:
160 return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
161 } 82 }
83 if (reply_block == NULL)
84 return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
85 return GNUNET_BLOCK_EVALUATION_OK_LAST;
86 case GNUNET_BLOCK_TYPE_FS_KBLOCK:
87 case GNUNET_BLOCK_TYPE_FS_NBLOCK:
88 if (xquery_size != 0)
89 {
90 GNUNET_break_op (0);
91 return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
92 }
93 if (reply_block == NULL)
94 return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
95 GNUNET_CRYPTO_hash (reply_block, reply_block_size, &chash);
96 GNUNET_BLOCK_mingle_hash (&chash, bf_mutator, &mhash);
97 if (NULL != *bf)
98 {
99 if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf, &mhash))
100 return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
101 }
102 else
103 {
104 *bf = GNUNET_CONTAINER_bloomfilter_init (NULL, 8, BLOOMFILTER_K);
105 }
106 GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash);
107 return GNUNET_BLOCK_EVALUATION_OK_MORE;
108 case GNUNET_BLOCK_TYPE_FS_SBLOCK:
109 if (xquery_size != sizeof (GNUNET_HashCode))
110 {
111 GNUNET_break_op (0);
112 return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
113 }
114 if (reply_block == NULL)
115 return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
116 nsid = xquery;
117 if (reply_block_size < sizeof (struct SBlock))
118 {
119 GNUNET_break_op (0);
120 return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
121 }
122 sb = reply_block;
123 GNUNET_CRYPTO_hash (&sb->subspace,
124 sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
125 &sh);
126 if (0 != memcmp (nsid, &sh, sizeof (GNUNET_HashCode)))
127 {
128 GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
129 "block-fs",
130 _
131 ("Reply mismatched in terms of namespace. Discarded.\n"));
132 return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
133 }
134 GNUNET_CRYPTO_hash (reply_block, reply_block_size, &chash);
135 GNUNET_BLOCK_mingle_hash (&chash, bf_mutator, &mhash);
136 if (NULL != *bf)
137 {
138 if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf, &mhash))
139 return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
140 }
141 else
142 {
143 *bf = GNUNET_CONTAINER_bloomfilter_init (NULL, 8, BLOOMFILTER_K);
144 }
145 GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash);
146 return GNUNET_BLOCK_EVALUATION_OK_MORE;
147 default:
148 return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
149 }
162} 150}
163 151
164 152
@@ -175,126 +163,122 @@ block_plugin_fs_evaluate (void *cls,
175 */ 163 */
176static int 164static int
177block_plugin_fs_get_key (void *cls, 165block_plugin_fs_get_key (void *cls,
178 enum GNUNET_BLOCK_Type type, 166 enum GNUNET_BLOCK_Type type,
179 const void *block, 167 const void *block,
180 size_t block_size, 168 size_t block_size, GNUNET_HashCode * key)
181 GNUNET_HashCode *key)
182{ 169{
183 const struct KBlock *kb; 170 const struct KBlock *kb;
184 const struct SBlock *sb; 171 const struct SBlock *sb;
185 const struct NBlock *nb; 172 const struct NBlock *nb;
186 173
187 switch (type) 174 switch (type)
175 {
176 case GNUNET_BLOCK_TYPE_FS_DBLOCK:
177 case GNUNET_BLOCK_TYPE_FS_IBLOCK:
178 GNUNET_CRYPTO_hash (block, block_size, key);
179 return GNUNET_OK;
180 case GNUNET_BLOCK_TYPE_FS_KBLOCK:
181 if (block_size < sizeof (struct KBlock))
182 {
183 GNUNET_break_op (0);
184 return GNUNET_NO;
185 }
186 kb = block;
187 if (block_size - sizeof (struct KBlock) !=
188 ntohl (kb->purpose.size)
189 - sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose)
190 - sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded))
191 {
192 GNUNET_break_op (0);
193 return GNUNET_NO;
194 }
195 if (GNUNET_OK !=
196 GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_KBLOCK,
197 &kb->purpose, &kb->signature, &kb->keyspace))
198 {
199 GNUNET_break_op (0);
200 return GNUNET_NO;
201 }
202 if (key != NULL)
203 GNUNET_CRYPTO_hash (&kb->keyspace,
204 sizeof (struct
205 GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
206 key);
207 return GNUNET_OK;
208 case GNUNET_BLOCK_TYPE_FS_SBLOCK:
209 if (block_size < sizeof (struct SBlock))
210 {
211 GNUNET_break_op (0);
212 return GNUNET_NO;
213 }
214 sb = block;
215 if (block_size !=
216 ntohl (sb->purpose.size) + sizeof (struct GNUNET_CRYPTO_RsaSignature))
188 { 217 {
189 case GNUNET_BLOCK_TYPE_FS_DBLOCK: 218 GNUNET_break_op (0);
190 case GNUNET_BLOCK_TYPE_FS_IBLOCK: 219 return GNUNET_NO;
191 GNUNET_CRYPTO_hash (block, block_size, key);
192 return GNUNET_OK;
193 case GNUNET_BLOCK_TYPE_FS_KBLOCK:
194 if (block_size < sizeof (struct KBlock))
195 {
196 GNUNET_break_op (0);
197 return GNUNET_NO;
198 }
199 kb = block;
200 if (block_size - sizeof (struct KBlock) !=
201 ntohl (kb->purpose.size)
202 - sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose)
203 - sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) )
204 {
205 GNUNET_break_op (0);
206 return GNUNET_NO;
207 }
208 if (GNUNET_OK !=
209 GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_KBLOCK,
210 &kb->purpose,
211 &kb->signature,
212 &kb->keyspace))
213 {
214 GNUNET_break_op (0);
215 return GNUNET_NO;
216 }
217 if (key != NULL)
218 GNUNET_CRYPTO_hash (&kb->keyspace,
219 sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
220 key);
221 return GNUNET_OK;
222 case GNUNET_BLOCK_TYPE_FS_SBLOCK:
223 if (block_size < sizeof (struct SBlock))
224 {
225 GNUNET_break_op (0);
226 return GNUNET_NO;
227 }
228 sb = block;
229 if (block_size !=
230 ntohl (sb->purpose.size) + sizeof (struct GNUNET_CRYPTO_RsaSignature))
231 {
232 GNUNET_break_op (0);
233 return GNUNET_NO;
234 }
235 if (GNUNET_OK !=
236 GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_SBLOCK,
237 &sb->purpose,
238 &sb->signature,
239 &sb->subspace))
240 {
241 GNUNET_break_op (0);
242 return GNUNET_NO;
243 }
244 if (key != NULL)
245 *key = sb->identifier;
246 return GNUNET_OK;
247 case GNUNET_BLOCK_TYPE_FS_NBLOCK:
248 if (block_size < sizeof (struct NBlock))
249 {
250 GNUNET_break_op (0);
251 return GNUNET_NO;
252 }
253 nb = block;
254 if (block_size - sizeof (struct NBlock) !=
255 ntohl (nb->ns_purpose.size)
256 - sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose)
257 - sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) )
258 {
259 GNUNET_break_op (0);
260 return GNUNET_NO;
261 }
262 if (block_size !=
263 ntohl (nb->ksk_purpose.size) + sizeof (struct GNUNET_CRYPTO_RsaSignature))
264 {
265 GNUNET_break_op (0);
266 return GNUNET_NO;
267 }
268 if (GNUNET_OK !=
269 GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_NBLOCK_KSIG,
270 &nb->ksk_purpose,
271 &nb->ksk_signature,
272 &nb->keyspace))
273 {
274 GNUNET_break_op (0);
275 return GNUNET_NO;
276 }
277 if (GNUNET_OK !=
278 GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_NBLOCK,
279 &nb->ns_purpose,
280 &nb->ns_signature,
281 &nb->subspace))
282 {
283 GNUNET_break_op (0);
284 return GNUNET_NO;
285 }
286 /* FIXME: we used to xor ID with NSID,
287 why not here? */
288 if (key != NULL)
289 GNUNET_CRYPTO_hash (&nb->keyspace,
290 sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
291 key);
292 return GNUNET_OK;
293 default:
294 return GNUNET_SYSERR;
295 } 220 }
221 if (GNUNET_OK !=
222 GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_SBLOCK,
223 &sb->purpose, &sb->signature, &sb->subspace))
224 {
225 GNUNET_break_op (0);
226 return GNUNET_NO;
227 }
228 if (key != NULL)
229 *key = sb->identifier;
230 return GNUNET_OK;
231 case GNUNET_BLOCK_TYPE_FS_NBLOCK:
232 if (block_size < sizeof (struct NBlock))
233 {
234 GNUNET_break_op (0);
235 return GNUNET_NO;
236 }
237 nb = block;
238 if (block_size - sizeof (struct NBlock) !=
239 ntohl (nb->ns_purpose.size)
240 - sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose)
241 - sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded))
242 {
243 GNUNET_break_op (0);
244 return GNUNET_NO;
245 }
246 if (block_size !=
247 ntohl (nb->ksk_purpose.size) +
248 sizeof (struct GNUNET_CRYPTO_RsaSignature))
249 {
250 GNUNET_break_op (0);
251 return GNUNET_NO;
252 }
253 if (GNUNET_OK !=
254 GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_NBLOCK_KSIG,
255 &nb->ksk_purpose,
256 &nb->ksk_signature, &nb->keyspace))
257 {
258 GNUNET_break_op (0);
259 return GNUNET_NO;
260 }
261 if (GNUNET_OK !=
262 GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_NBLOCK,
263 &nb->ns_purpose,
264 &nb->ns_signature, &nb->subspace))
265 {
266 GNUNET_break_op (0);
267 return GNUNET_NO;
268 }
269 /* FIXME: we used to xor ID with NSID,
270 * why not here? */
271 if (key != NULL)
272 GNUNET_CRYPTO_hash (&nb->keyspace,
273 sizeof (struct
274 GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
275 key);
276 return GNUNET_OK;
277 default:
278 return GNUNET_SYSERR;
279 }
296} 280}
297 281
298 282
299/** 283/**
300 * Entry point for the plugin. 284 * Entry point for the plugin.
@@ -302,15 +286,15 @@ block_plugin_fs_get_key (void *cls,
302void * 286void *
303libgnunet_plugin_block_fs_init (void *cls) 287libgnunet_plugin_block_fs_init (void *cls)
304{ 288{
305 static enum GNUNET_BLOCK_Type types[] = 289 static enum GNUNET_BLOCK_Type types[] =
306 { 290 {
307 GNUNET_BLOCK_TYPE_FS_DBLOCK, 291 GNUNET_BLOCK_TYPE_FS_DBLOCK,
308 GNUNET_BLOCK_TYPE_FS_IBLOCK, 292 GNUNET_BLOCK_TYPE_FS_IBLOCK,
309 GNUNET_BLOCK_TYPE_FS_KBLOCK, 293 GNUNET_BLOCK_TYPE_FS_KBLOCK,
310 GNUNET_BLOCK_TYPE_FS_SBLOCK, 294 GNUNET_BLOCK_TYPE_FS_SBLOCK,
311 GNUNET_BLOCK_TYPE_FS_NBLOCK, 295 GNUNET_BLOCK_TYPE_FS_NBLOCK,
312 GNUNET_BLOCK_TYPE_ANY /* end of list */ 296 GNUNET_BLOCK_TYPE_ANY /* end of list */
313 }; 297 };
314 struct GNUNET_BLOCK_PluginFunctions *api; 298 struct GNUNET_BLOCK_PluginFunctions *api;
315 299
316 api = GNUNET_malloc (sizeof (struct GNUNET_BLOCK_PluginFunctions)); 300 api = GNUNET_malloc (sizeof (struct GNUNET_BLOCK_PluginFunctions));
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-23 18:25:15 +0000