diff options
Diffstat (limited to 'src/fs/fs_publish_ksk.c')
-rw-r--r-- | src/fs/fs_publish_ksk.c | 179 |
1 files changed, 37 insertions, 142 deletions
diff --git a/src/fs/fs_publish_ksk.c b/src/fs/fs_publish_ksk.c index 10512af5f..7cbc880a2 100644 --- a/src/fs/fs_publish_ksk.c +++ b/src/fs/fs_publish_ksk.c | |||
@@ -33,7 +33,7 @@ | |||
33 | #include "gnunet_fs_service.h" | 33 | #include "gnunet_fs_service.h" |
34 | #include "fs_api.h" | 34 | #include "fs_api.h" |
35 | #include "fs_tree.h" | 35 | #include "fs_tree.h" |
36 | 36 | #include "fs_publish_ublock.h" | |
37 | 37 | ||
38 | /** | 38 | /** |
39 | * Context for the KSK publication. | 39 | * Context for the KSK publication. |
@@ -47,33 +47,29 @@ struct GNUNET_FS_PublishKskContext | |||
47 | struct GNUNET_FS_Uri *ksk_uri; | 47 | struct GNUNET_FS_Uri *ksk_uri; |
48 | 48 | ||
49 | /** | 49 | /** |
50 | * Global FS context. | 50 | * URI to publish. |
51 | */ | 51 | */ |
52 | struct GNUNET_FS_Handle *h; | 52 | struct GNUNET_FS_Uri *uri; |
53 | 53 | ||
54 | /** | 54 | /** |
55 | * The master block that we are sending | 55 | * Metadata to use. |
56 | * (in plaintext), has "mdsize+slen" more | ||
57 | * bytes than the struct would suggest. | ||
58 | */ | 56 | */ |
59 | struct UBlock *ub; | 57 | struct GNUNET_CONTAINER_MetaData *meta; |
60 | 58 | ||
61 | /** | 59 | /** |
62 | * Buffer of the same size as "kb" for | 60 | * Global FS context. |
63 | * the encrypted version. | ||
64 | */ | 61 | */ |
65 | struct UBlock *cpy; | 62 | struct GNUNET_FS_Handle *h; |
66 | 63 | ||
67 | /** | 64 | /** |
68 | * Handle to the datastore, NULL if we are just | 65 | * UBlock publishing operation that is active. |
69 | * simulating. | ||
70 | */ | 66 | */ |
71 | struct GNUNET_DATASTORE_Handle *dsh; | 67 | struct GNUNET_FS_PublishUblockContext *uc; |
72 | 68 | ||
73 | /** | 69 | /** |
74 | * Handle to datastore PUT request. | 70 | * Handle to the datastore, NULL if we are just simulating. |
75 | */ | 71 | */ |
76 | struct GNUNET_DATASTORE_QueueEntry *qre; | 72 | struct GNUNET_DATASTORE_Handle *dsh; |
77 | 73 | ||
78 | /** | 74 | /** |
79 | * Current task. | 75 | * Current task. |
@@ -96,14 +92,9 @@ struct GNUNET_FS_PublishKskContext | |||
96 | struct GNUNET_FS_BlockOptions bo; | 92 | struct GNUNET_FS_BlockOptions bo; |
97 | 93 | ||
98 | /** | 94 | /** |
99 | * Size of the serialized metadata. | 95 | * Options to use. |
100 | */ | 96 | */ |
101 | ssize_t mdsize; | 97 | enum GNUNET_FS_PublishOptions options; |
102 | |||
103 | /** | ||
104 | * Size of the (CHK) URI as a string. | ||
105 | */ | ||
106 | size_t slen; | ||
107 | 98 | ||
108 | /** | 99 | /** |
109 | * Keyword that we are currently processing. | 100 | * Keyword that we are currently processing. |
@@ -122,7 +113,8 @@ struct GNUNET_FS_PublishKskContext | |||
122 | * @param tc unused | 113 | * @param tc unused |
123 | */ | 114 | */ |
124 | static void | 115 | static void |
125 | publish_ksk_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); | 116 | publish_ksk_cont (void *cls, |
117 | const struct GNUNET_SCHEDULER_TaskContext *tc); | ||
126 | 118 | ||
127 | 119 | ||
128 | /** | 120 | /** |
@@ -130,19 +122,16 @@ publish_ksk_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); | |||
130 | * the result from the PUT request. | 122 | * the result from the PUT request. |
131 | * | 123 | * |
132 | * @param cls closure of type "struct GNUNET_FS_PublishKskContext*" | 124 | * @param cls closure of type "struct GNUNET_FS_PublishKskContext*" |
133 | * @param success GNUNET_OK on success | ||
134 | * @param min_expiration minimum expiration time required for content to be stored | ||
135 | * @param msg error message (or NULL) | 125 | * @param msg error message (or NULL) |
136 | */ | 126 | */ |
137 | static void | 127 | static void |
138 | kb_put_cont (void *cls, int success, | 128 | kb_put_cont (void *cls, |
139 | struct GNUNET_TIME_Absolute min_expiration, | ||
140 | const char *msg) | 129 | const char *msg) |
141 | { | 130 | { |
142 | struct GNUNET_FS_PublishKskContext *pkc = cls; | 131 | struct GNUNET_FS_PublishKskContext *pkc = cls; |
143 | 132 | ||
144 | pkc->qre = NULL; | 133 | pkc->uc = NULL; |
145 | if (GNUNET_OK != success) | 134 | if (NULL != msg) |
146 | { | 135 | { |
147 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 136 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
148 | "KBlock PUT operation failed: %s\n", msg); | 137 | "KBlock PUT operation failed: %s\n", msg); |
@@ -166,15 +155,6 @@ publish_ksk_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
166 | { | 155 | { |
167 | struct GNUNET_FS_PublishKskContext *pkc = cls; | 156 | struct GNUNET_FS_PublishKskContext *pkc = cls; |
168 | const char *keyword; | 157 | const char *keyword; |
169 | struct GNUNET_HashCode key; | ||
170 | struct GNUNET_HashCode seed; | ||
171 | struct GNUNET_HashCode signing_key; | ||
172 | struct GNUNET_HashCode query; | ||
173 | struct GNUNET_CRYPTO_AesSessionKey skey; | ||
174 | struct GNUNET_CRYPTO_AesInitializationVector iv; | ||
175 | struct GNUNET_FS_PseudonymHandle *ph; | ||
176 | struct GNUNET_FS_PseudonymIdentifier pseudonym; | ||
177 | struct UBlock *ub_dst; | ||
178 | 158 | ||
179 | pkc->ksk_task = GNUNET_SCHEDULER_NO_TASK; | 159 | pkc->ksk_task = GNUNET_SCHEDULER_NO_TASK; |
180 | if ( (pkc->i == pkc->ksk_uri->data.ksk.keywordCount) || | 160 | if ( (pkc->i == pkc->ksk_uri->data.ksk.keywordCount) || |
@@ -186,61 +166,15 @@ publish_ksk_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
186 | return; | 166 | return; |
187 | } | 167 | } |
188 | keyword = pkc->ksk_uri->data.ksk.keywords[pkc->i++]; | 168 | keyword = pkc->ksk_uri->data.ksk.keywords[pkc->i++]; |
189 | pkc->sks_task = GNUNET_FS_publish_sks (pkc->h, | 169 | pkc->uc = GNUNET_FS_publish_ublock_ (pkc->h, |
190 | anonymous, | 170 | pkc->dsh, |
191 | keyword, NULL, | 171 | keyword, NULL, |
192 | pkc->meta, | 172 | GNUNET_CRYPTO_ecc_key_get_anonymous (), |
193 | pkc->uri, | 173 | pkc->meta, |
194 | &pkc->bo, | 174 | pkc->uri, |
195 | pkc->options, | 175 | &pkc->bo, |
196 | &publish_ksk_cont, pkc); | 176 | pkc->options, |
197 | 177 | &kb_put_cont, pkc); | |
198 | |||
199 | /* derive signing seed from plaintext */ | ||
200 | GNUNET_CRYPTO_hash (&pkc->ub[1], | ||
201 | 1 + pkc->slen + pkc->mdsize, | ||
202 | &seed); | ||
203 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publishing under keyword `%s'\n", | ||
204 | &keyword[1]); | ||
205 | /* first character of keyword indicates if it is | ||
206 | * mandatory or not -- ignore for hashing */ | ||
207 | GNUNET_CRYPTO_hash (&keyword[1], strlen (&keyword[1]), &key); | ||
208 | |||
209 | GNUNET_CRYPTO_hash_to_aes_key (&key, &skey, &iv); | ||
210 | ub_dst = pkc->cpy; | ||
211 | GNUNET_CRYPTO_aes_encrypt (&pkc->ub[1], | ||
212 | 1 + pkc->slen + pkc->mdsize, | ||
213 | &skey, &iv, | ||
214 | &ub_dst[1]); | ||
215 | ph = GNUNET_FS_pseudonym_get_anonymous_pseudonym_handle (); | ||
216 | GNUNET_CRYPTO_hash (&key, sizeof (key), &signing_key); | ||
217 | ub_dst->purpose.size = htonl (1 + pkc->slen + pkc->mdsize + | ||
218 | sizeof (struct UBlock) | ||
219 | - sizeof (struct GNUNET_FS_PseudonymSignature)); | ||
220 | ub_dst->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_FS_UBLOCK); | ||
221 | |||
222 | GNUNET_FS_pseudonym_get_identifier (ph, &pseudonym); | ||
223 | GNUNET_FS_pseudonym_derive_verification_key (&pseudonym, | ||
224 | &signing_key, | ||
225 | &ub_dst->verification_key); | ||
226 | GNUNET_FS_pseudonym_sign (ph, | ||
227 | &ub_dst->purpose, | ||
228 | &seed, | ||
229 | &signing_key, | ||
230 | &ub_dst->signature); | ||
231 | |||
232 | GNUNET_CRYPTO_hash (&ub_dst->verification_key, | ||
233 | sizeof (ub_dst->verification_key), | ||
234 | &query); | ||
235 | GNUNET_FS_pseudonym_destroy (ph); | ||
236 | pkc->qre = | ||
237 | GNUNET_DATASTORE_put (pkc->dsh, 0, &query, | ||
238 | 1 + pkc->slen + pkc->mdsize + sizeof (struct UBlock), | ||
239 | ub_dst, GNUNET_BLOCK_TYPE_FS_UBLOCK, | ||
240 | pkc->bo.content_priority, pkc->bo.anonymity_level, | ||
241 | pkc->bo.replication_level, pkc->bo.expiration_time, | ||
242 | -2, 1, GNUNET_CONSTANTS_SERVICE_TIMEOUT, | ||
243 | &kb_put_cont, pkc); | ||
244 | } | 178 | } |
245 | 179 | ||
246 | 180 | ||
@@ -267,17 +201,15 @@ GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h, | |||
267 | GNUNET_FS_PublishContinuation cont, void *cont_cls) | 201 | GNUNET_FS_PublishContinuation cont, void *cont_cls) |
268 | { | 202 | { |
269 | struct GNUNET_FS_PublishKskContext *pkc; | 203 | struct GNUNET_FS_PublishKskContext *pkc; |
270 | char *uris; | ||
271 | size_t size; | ||
272 | char *kbe; | ||
273 | char *sptr; | ||
274 | 204 | ||
275 | GNUNET_assert (NULL != uri); | 205 | GNUNET_assert (NULL != uri); |
276 | pkc = GNUNET_malloc (sizeof (struct GNUNET_FS_PublishKskContext)); | 206 | pkc = GNUNET_new (struct GNUNET_FS_PublishKskContext); |
277 | pkc->h = h; | 207 | pkc->h = h; |
278 | pkc->bo = *bo; | 208 | pkc->bo = *bo; |
209 | pkc->options = options; | ||
279 | pkc->cont = cont; | 210 | pkc->cont = cont; |
280 | pkc->cont_cls = cont_cls; | 211 | pkc->cont_cls = cont_cls; |
212 | pkc->meta = GNUNET_CONTAINER_meta_data_duplicate (meta); | ||
281 | if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY)) | 213 | if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY)) |
282 | { | 214 | { |
283 | pkc->dsh = GNUNET_DATASTORE_connect (h->cfg); | 215 | pkc->dsh = GNUNET_DATASTORE_connect (h->cfg); |
@@ -288,44 +220,7 @@ GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h, | |||
288 | return NULL; | 220 | return NULL; |
289 | } | 221 | } |
290 | } | 222 | } |
291 | if (meta == NULL) | 223 | pkc->uri = GNUNET_FS_uri_dup (uri); |
292 | pkc->mdsize = 0; | ||
293 | else | ||
294 | pkc->mdsize = GNUNET_CONTAINER_meta_data_get_serialized_size (meta); | ||
295 | GNUNET_assert (pkc->mdsize >= 0); | ||
296 | uris = GNUNET_FS_uri_to_string (uri); | ||
297 | pkc->slen = strlen (uris) + 1; | ||
298 | size = pkc->mdsize + sizeof (struct UBlock) + pkc->slen + 1; | ||
299 | if (size > MAX_UBLOCK_SIZE) | ||
300 | { | ||
301 | size = MAX_UBLOCK_SIZE; | ||
302 | pkc->mdsize = size - sizeof (struct UBlock) - pkc->slen + 1; | ||
303 | } | ||
304 | pkc->ub = GNUNET_malloc (size); | ||
305 | kbe = (char *) &pkc->ub[1]; | ||
306 | kbe++; /* leave one '\0' for the update identifier */ | ||
307 | memcpy (kbe, uris, pkc->slen); | ||
308 | GNUNET_free (uris); | ||
309 | sptr = &kbe[pkc->slen]; | ||
310 | if (meta != NULL) | ||
311 | pkc->mdsize = | ||
312 | GNUNET_CONTAINER_meta_data_serialize (meta, &sptr, pkc->mdsize, | ||
313 | GNUNET_CONTAINER_META_DATA_SERIALIZE_PART); | ||
314 | if (-1 == pkc->mdsize) | ||
315 | { | ||
316 | GNUNET_break (0); | ||
317 | GNUNET_free (pkc->ub); | ||
318 | if (NULL != pkc->dsh) | ||
319 | { | ||
320 | GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO); | ||
321 | pkc->dsh = NULL; | ||
322 | } | ||
323 | GNUNET_free (pkc); | ||
324 | cont (cont_cls, NULL, _("Internal error.")); | ||
325 | return NULL; | ||
326 | } | ||
327 | size = sizeof (struct UBlock) + pkc->slen + pkc->mdsize + 1; | ||
328 | pkc->cpy = GNUNET_malloc (size); | ||
329 | pkc->ksk_uri = GNUNET_FS_uri_dup (ksk_uri); | 224 | pkc->ksk_uri = GNUNET_FS_uri_dup (ksk_uri); |
330 | pkc->ksk_task = GNUNET_SCHEDULER_add_now (&publish_ksk_cont, pkc); | 225 | pkc->ksk_task = GNUNET_SCHEDULER_add_now (&publish_ksk_cont, pkc); |
331 | return pkc; | 226 | return pkc; |
@@ -345,19 +240,19 @@ GNUNET_FS_publish_ksk_cancel (struct GNUNET_FS_PublishKskContext *pkc) | |||
345 | GNUNET_SCHEDULER_cancel (pkc->ksk_task); | 240 | GNUNET_SCHEDULER_cancel (pkc->ksk_task); |
346 | pkc->ksk_task = GNUNET_SCHEDULER_NO_TASK; | 241 | pkc->ksk_task = GNUNET_SCHEDULER_NO_TASK; |
347 | } | 242 | } |
348 | if (NULL != pkc->qre) | 243 | if (NULL != pkc->uc) |
349 | { | 244 | { |
350 | GNUNET_DATASTORE_cancel (pkc->qre); | 245 | GNUNET_FS_publish_ublock_cancel_ (pkc->uc); |
351 | pkc->qre = NULL; | 246 | pkc->uc = NULL; |
352 | } | 247 | } |
353 | if (NULL != pkc->dsh) | 248 | if (NULL != pkc->dsh) |
354 | { | 249 | { |
355 | GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO); | 250 | GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO); |
356 | pkc->dsh = NULL; | 251 | pkc->dsh = NULL; |
357 | } | 252 | } |
358 | GNUNET_free (pkc->cpy); | 253 | GNUNET_CONTAINER_meta_data_destroy (pkc->meta); |
359 | GNUNET_free (pkc->ub); | ||
360 | GNUNET_FS_uri_destroy (pkc->ksk_uri); | 254 | GNUNET_FS_uri_destroy (pkc->ksk_uri); |
255 | GNUNET_FS_uri_destroy (pkc->uri); | ||
361 | GNUNET_free (pkc); | 256 | GNUNET_free (pkc); |
362 | } | 257 | } |
363 | 258 | ||