diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/fs/fs_publish.c | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/fs/fs_publish.c')
-rw-r--r-- | src/fs/fs_publish.c | 1652 |
1 files changed, 834 insertions, 818 deletions
diff --git a/src/fs/fs_publish.c b/src/fs/fs_publish.c index b599bb06e..8bb57b1e2 100644 --- a/src/fs/fs_publish.c +++ b/src/fs/fs_publish.c | |||
@@ -44,10 +44,10 @@ | |||
44 | * @return value returned from callback | 44 | * @return value returned from callback |
45 | */ | 45 | */ |
46 | void * | 46 | void * |
47 | GNUNET_FS_publish_make_status_(struct GNUNET_FS_ProgressInfo *pi, | 47 | GNUNET_FS_publish_make_status_ (struct GNUNET_FS_ProgressInfo *pi, |
48 | struct GNUNET_FS_PublishContext *pc, | 48 | struct GNUNET_FS_PublishContext *pc, |
49 | const struct GNUNET_FS_FileInformation *p, | 49 | const struct GNUNET_FS_FileInformation *p, |
50 | uint64_t offset) | 50 | uint64_t offset) |
51 | { | 51 | { |
52 | pi->value.publish.pc = pc; | 52 | pi->value.publish.pc = pc; |
53 | pi->value.publish.fi = p; | 53 | pi->value.publish.fi = p; |
@@ -55,16 +55,17 @@ GNUNET_FS_publish_make_status_(struct GNUNET_FS_ProgressInfo *pi, | |||
55 | pi->value.publish.pctx = (NULL == p->dir) ? NULL : p->dir->client_info; | 55 | pi->value.publish.pctx = (NULL == p->dir) ? NULL : p->dir->client_info; |
56 | pi->value.publish.filename = p->filename; | 56 | pi->value.publish.filename = p->filename; |
57 | pi->value.publish.size = | 57 | pi->value.publish.size = |
58 | (GNUNET_YES == p->is_directory) ? p->data.dir.dir_size : p->data.file.file_size; | 58 | (GNUNET_YES == p->is_directory) ? p->data.dir.dir_size : |
59 | p->data.file.file_size; | ||
59 | pi->value.publish.eta = | 60 | pi->value.publish.eta = |
60 | GNUNET_TIME_calculate_eta(p->start_time, offset, | 61 | GNUNET_TIME_calculate_eta (p->start_time, offset, |
61 | pi->value.publish.size); | 62 | pi->value.publish.size); |
62 | pi->value.publish.completed = offset; | 63 | pi->value.publish.completed = offset; |
63 | pi->value.publish.duration = | 64 | pi->value.publish.duration = |
64 | GNUNET_TIME_absolute_get_duration(p->start_time); | 65 | GNUNET_TIME_absolute_get_duration (p->start_time); |
65 | pi->value.publish.anonymity = p->bo.anonymity_level; | 66 | pi->value.publish.anonymity = p->bo.anonymity_level; |
66 | pi->fsh = pc->h; | 67 | pi->fsh = pc->h; |
67 | return pc->h->upcb(pc->h->upcb_cls, pi); | 68 | return pc->h->upcb (pc->h->upcb_cls, pi); |
68 | } | 69 | } |
69 | 70 | ||
70 | 71 | ||
@@ -74,31 +75,31 @@ GNUNET_FS_publish_make_status_(struct GNUNET_FS_ProgressInfo *pi, | |||
74 | * @param pc struct to clean up | 75 | * @param pc struct to clean up |
75 | */ | 76 | */ |
76 | static void | 77 | static void |
77 | publish_cleanup(struct GNUNET_FS_PublishContext *pc) | 78 | publish_cleanup (struct GNUNET_FS_PublishContext *pc) |
78 | { | 79 | { |
79 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 80 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
80 | "Cleaning up publish context (done!)\n"); | 81 | "Cleaning up publish context (done!)\n"); |
81 | if (NULL != pc->fhc) | 82 | if (NULL != pc->fhc) |
82 | { | 83 | { |
83 | GNUNET_CRYPTO_hash_file_cancel(pc->fhc); | 84 | GNUNET_CRYPTO_hash_file_cancel (pc->fhc); |
84 | pc->fhc = NULL; | 85 | pc->fhc = NULL; |
85 | } | 86 | } |
86 | GNUNET_FS_file_information_destroy(pc->fi, NULL, NULL); | 87 | GNUNET_FS_file_information_destroy (pc->fi, NULL, NULL); |
87 | GNUNET_free_non_null(pc->nid); | 88 | GNUNET_free_non_null (pc->nid); |
88 | GNUNET_free_non_null(pc->nuid); | 89 | GNUNET_free_non_null (pc->nuid); |
89 | GNUNET_free_non_null(pc->serialization); | 90 | GNUNET_free_non_null (pc->serialization); |
90 | if (NULL != pc->dsh) | 91 | if (NULL != pc->dsh) |
91 | { | 92 | { |
92 | GNUNET_DATASTORE_disconnect(pc->dsh, GNUNET_NO); | 93 | GNUNET_DATASTORE_disconnect (pc->dsh, GNUNET_NO); |
93 | pc->dsh = NULL; | 94 | pc->dsh = NULL; |
94 | } | 95 | } |
95 | if (NULL != pc->mq) | 96 | if (NULL != pc->mq) |
96 | { | 97 | { |
97 | GNUNET_MQ_destroy(pc->mq); | 98 | GNUNET_MQ_destroy (pc->mq); |
98 | pc->mq = NULL; | 99 | pc->mq = NULL; |
99 | } | 100 | } |
100 | GNUNET_assert(NULL == pc->upload_task); | 101 | GNUNET_assert (NULL == pc->upload_task); |
101 | GNUNET_free(pc); | 102 | GNUNET_free (pc); |
102 | } | 103 | } |
103 | 104 | ||
104 | 105 | ||
@@ -112,42 +113,42 @@ publish_cleanup(struct GNUNET_FS_PublishContext *pc) | |||
112 | * @param msg error message (or NULL) | 113 | * @param msg error message (or NULL) |
113 | */ | 114 | */ |
114 | static void | 115 | static void |
115 | ds_put_cont(void *cls, | 116 | ds_put_cont (void *cls, |
116 | int success, | 117 | int success, |
117 | struct GNUNET_TIME_Absolute min_expiration, | 118 | struct GNUNET_TIME_Absolute min_expiration, |
118 | const char *msg) | 119 | const char *msg) |
119 | { | 120 | { |
120 | struct GNUNET_FS_PublishContext *pc = cls; | 121 | struct GNUNET_FS_PublishContext *pc = cls; |
121 | struct GNUNET_FS_ProgressInfo pi; | 122 | struct GNUNET_FS_ProgressInfo pi; |
122 | 123 | ||
123 | pc->qre = NULL; | 124 | pc->qre = NULL; |
124 | if (GNUNET_SYSERR == success) | 125 | if (GNUNET_SYSERR == success) |
126 | { | ||
127 | GNUNET_asprintf (&pc->fi_pos->emsg, | ||
128 | _ ("Publishing failed: %s"), | ||
129 | msg); | ||
130 | pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR; | ||
131 | pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL; | ||
132 | pi.value.publish.specifics.error.message = pc->fi_pos->emsg; | ||
133 | pc->fi_pos->client_info = | ||
134 | GNUNET_FS_publish_make_status_ (&pi, pc, pc->fi_pos, 0); | ||
135 | if ((GNUNET_YES != pc->fi_pos->is_directory) && | ||
136 | (NULL != pc->fi_pos->filename) && | ||
137 | (GNUNET_YES == pc->any_done) && | ||
138 | (GNUNET_YES == pc->fi_pos->data.file.do_index)) | ||
125 | { | 139 | { |
126 | GNUNET_asprintf(&pc->fi_pos->emsg, | 140 | /* run unindex to clean up */ |
127 | _("Publishing failed: %s"), | 141 | GNUNET_FS_unindex_start (pc->h, |
128 | msg); | 142 | pc->fi_pos->filename, |
129 | pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR; | 143 | NULL); |
130 | pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL; | ||
131 | pi.value.publish.specifics.error.message = pc->fi_pos->emsg; | ||
132 | pc->fi_pos->client_info = | ||
133 | GNUNET_FS_publish_make_status_(&pi, pc, pc->fi_pos, 0); | ||
134 | if ((GNUNET_YES != pc->fi_pos->is_directory) && | ||
135 | (NULL != pc->fi_pos->filename) && | ||
136 | (GNUNET_YES == pc->any_done) && | ||
137 | (GNUNET_YES == pc->fi_pos->data.file.do_index)) | ||
138 | { | ||
139 | /* run unindex to clean up */ | ||
140 | GNUNET_FS_unindex_start(pc->h, | ||
141 | pc->fi_pos->filename, | ||
142 | NULL); | ||
143 | } | ||
144 | return; | ||
145 | } | 144 | } |
145 | return; | ||
146 | } | ||
146 | pc->any_done = GNUNET_YES; | 147 | pc->any_done = GNUNET_YES; |
147 | GNUNET_assert(NULL == pc->upload_task); | 148 | GNUNET_assert (NULL == pc->upload_task); |
148 | pc->upload_task = | 149 | pc->upload_task = |
149 | GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_BACKGROUND, | 150 | GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, |
150 | &GNUNET_FS_publish_main_, pc); | 151 | &GNUNET_FS_publish_main_, pc); |
151 | } | 152 | } |
152 | 153 | ||
153 | 154 | ||
@@ -160,8 +161,8 @@ ds_put_cont(void *cls, | |||
160 | * @param pc context of the publication | 161 | * @param pc context of the publication |
161 | */ | 162 | */ |
162 | static void | 163 | static void |
163 | signal_publish_completion(struct GNUNET_FS_FileInformation *p, | 164 | signal_publish_completion (struct GNUNET_FS_FileInformation *p, |
164 | struct GNUNET_FS_PublishContext *pc) | 165 | struct GNUNET_FS_PublishContext *pc) |
165 | { | 166 | { |
166 | struct GNUNET_FS_ProgressInfo pi; | 167 | struct GNUNET_FS_ProgressInfo pi; |
167 | 168 | ||
@@ -170,8 +171,8 @@ signal_publish_completion(struct GNUNET_FS_FileInformation *p, | |||
170 | pi.value.publish.specifics.completed.chk_uri = p->chk_uri; | 171 | pi.value.publish.specifics.completed.chk_uri = p->chk_uri; |
171 | pi.value.publish.specifics.completed.sks_uri = p->sks_uri; | 172 | pi.value.publish.specifics.completed.sks_uri = p->sks_uri; |
172 | p->client_info = | 173 | p->client_info = |
173 | GNUNET_FS_publish_make_status_(&pi, pc, p, | 174 | GNUNET_FS_publish_make_status_ (&pi, pc, p, |
174 | p->data.file.file_size); | 175 | p->data.file.file_size); |
175 | } | 176 | } |
176 | 177 | ||
177 | 178 | ||
@@ -185,27 +186,27 @@ signal_publish_completion(struct GNUNET_FS_FileInformation *p, | |||
185 | * @param emsg error message | 186 | * @param emsg error message |
186 | */ | 187 | */ |
187 | static void | 188 | static void |
188 | signal_publish_error(struct GNUNET_FS_FileInformation *p, | 189 | signal_publish_error (struct GNUNET_FS_FileInformation *p, |
189 | struct GNUNET_FS_PublishContext *pc, | 190 | struct GNUNET_FS_PublishContext *pc, |
190 | const char *emsg) | 191 | const char *emsg) |
191 | { | 192 | { |
192 | struct GNUNET_FS_ProgressInfo pi; | 193 | struct GNUNET_FS_ProgressInfo pi; |
193 | 194 | ||
194 | p->emsg = GNUNET_strdup(emsg); | 195 | p->emsg = GNUNET_strdup (emsg); |
195 | pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR; | 196 | pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR; |
196 | pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL; | 197 | pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL; |
197 | pi.value.publish.specifics.error.message = emsg; | 198 | pi.value.publish.specifics.error.message = emsg; |
198 | p->client_info = GNUNET_FS_publish_make_status_(&pi, pc, p, 0); | 199 | p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, 0); |
199 | if ((p->is_directory != GNUNET_YES) && | 200 | if ((p->is_directory != GNUNET_YES) && |
200 | (NULL != p->filename) && | 201 | (NULL != p->filename) && |
201 | (GNUNET_YES == pc->any_done) && | 202 | (GNUNET_YES == pc->any_done) && |
202 | (p->data.file.do_index == GNUNET_YES)) | 203 | (p->data.file.do_index == GNUNET_YES)) |
203 | { | 204 | { |
204 | /* run unindex to clean up */ | 205 | /* run unindex to clean up */ |
205 | GNUNET_FS_unindex_start(pc->h, | 206 | GNUNET_FS_unindex_start (pc->h, |
206 | p->filename, | 207 | p->filename, |
207 | NULL); | 208 | NULL); |
208 | } | 209 | } |
209 | } | 210 | } |
210 | 211 | ||
211 | 212 | ||
@@ -218,18 +219,18 @@ signal_publish_error(struct GNUNET_FS_FileInformation *p, | |||
218 | * @param msg error message (typically NULL, not used) | 219 | * @param msg error message (typically NULL, not used) |
219 | */ | 220 | */ |
220 | static void | 221 | static void |
221 | finish_release_reserve(void *cls, int success, | 222 | finish_release_reserve (void *cls, int success, |
222 | struct GNUNET_TIME_Absolute min_expiration, | 223 | struct GNUNET_TIME_Absolute min_expiration, |
223 | const char *msg) | 224 | const char *msg) |
224 | { | 225 | { |
225 | struct GNUNET_FS_PublishContext *pc = cls; | 226 | struct GNUNET_FS_PublishContext *pc = cls; |
226 | 227 | ||
227 | pc->qre = NULL; | 228 | pc->qre = NULL; |
228 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 229 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
229 | "Releasing reserve done!\n"); | 230 | "Releasing reserve done!\n"); |
230 | signal_publish_completion(pc->fi, pc); | 231 | signal_publish_completion (pc->fi, pc); |
231 | pc->all_done = GNUNET_YES; | 232 | pc->all_done = GNUNET_YES; |
232 | GNUNET_FS_publish_sync_(pc); | 233 | GNUNET_FS_publish_sync_ (pc); |
233 | } | 234 | } |
234 | 235 | ||
235 | 236 | ||
@@ -242,35 +243,35 @@ finish_release_reserve(void *cls, int success, | |||
242 | * @param emsg NULL on success, otherwise error message | 243 | * @param emsg NULL on success, otherwise error message |
243 | */ | 244 | */ |
244 | static void | 245 | static void |
245 | publish_sblocks_cont(void *cls, | 246 | publish_sblocks_cont (void *cls, |
246 | const struct GNUNET_FS_Uri *uri, | 247 | const struct GNUNET_FS_Uri *uri, |
247 | const char *emsg) | 248 | const char *emsg) |
248 | { | 249 | { |
249 | struct GNUNET_FS_PublishContext *pc = cls; | 250 | struct GNUNET_FS_PublishContext *pc = cls; |
250 | 251 | ||
251 | pc->sks_pc = NULL; | 252 | pc->sks_pc = NULL; |
252 | if (NULL != emsg) | 253 | if (NULL != emsg) |
253 | { | 254 | { |
254 | signal_publish_error(pc->fi, pc, emsg); | 255 | signal_publish_error (pc->fi, pc, emsg); |
255 | GNUNET_FS_publish_sync_(pc); | 256 | GNUNET_FS_publish_sync_ (pc); |
256 | return; | 257 | return; |
257 | } | 258 | } |
258 | if (NULL != uri) | 259 | if (NULL != uri) |
259 | { | 260 | { |
260 | /* sks publication, remember namespace URI */ | 261 | /* sks publication, remember namespace URI */ |
261 | pc->fi->sks_uri = GNUNET_FS_uri_dup(uri); | 262 | pc->fi->sks_uri = GNUNET_FS_uri_dup (uri); |
262 | } | 263 | } |
263 | GNUNET_assert(pc->qre == NULL); | 264 | GNUNET_assert (pc->qre == NULL); |
264 | if ((pc->dsh != NULL) && (pc->rid != 0)) | 265 | if ((pc->dsh != NULL) && (pc->rid != 0)) |
265 | { | 266 | { |
266 | pc->qre = | 267 | pc->qre = |
267 | GNUNET_DATASTORE_release_reserve(pc->dsh, pc->rid, UINT_MAX, UINT_MAX, | 268 | GNUNET_DATASTORE_release_reserve (pc->dsh, pc->rid, UINT_MAX, UINT_MAX, |
268 | &finish_release_reserve, pc); | 269 | &finish_release_reserve, pc); |
269 | } | 270 | } |
270 | else | 271 | else |
271 | { | 272 | { |
272 | finish_release_reserve(pc, GNUNET_OK, GNUNET_TIME_UNIT_ZERO_ABS, NULL); | 273 | finish_release_reserve (pc, GNUNET_OK, GNUNET_TIME_UNIT_ZERO_ABS, NULL); |
273 | } | 274 | } |
274 | } | 275 | } |
275 | 276 | ||
276 | 277 | ||
@@ -281,20 +282,20 @@ publish_sblocks_cont(void *cls, | |||
281 | * @param pc overall upload data | 282 | * @param pc overall upload data |
282 | */ | 283 | */ |
283 | static void | 284 | static void |
284 | publish_sblock(struct GNUNET_FS_PublishContext *pc) | 285 | publish_sblock (struct GNUNET_FS_PublishContext *pc) |
285 | { | 286 | { |
286 | if (NULL != pc->ns) | 287 | if (NULL != pc->ns) |
287 | pc->sks_pc = GNUNET_FS_publish_sks(pc->h, | 288 | pc->sks_pc = GNUNET_FS_publish_sks (pc->h, |
288 | pc->ns, | 289 | pc->ns, |
289 | pc->nid, | 290 | pc->nid, |
290 | pc->nuid, | 291 | pc->nuid, |
291 | pc->fi->meta, | 292 | pc->fi->meta, |
292 | pc->fi->chk_uri, | 293 | pc->fi->chk_uri, |
293 | &pc->fi->bo, | 294 | &pc->fi->bo, |
294 | pc->options, | 295 | pc->options, |
295 | &publish_sblocks_cont, pc); | 296 | &publish_sblocks_cont, pc); |
296 | else | 297 | else |
297 | publish_sblocks_cont(pc, NULL, NULL); | 298 | publish_sblocks_cont (pc, NULL, NULL); |
298 | } | 299 | } |
299 | 300 | ||
300 | 301 | ||
@@ -308,44 +309,44 @@ publish_sblock(struct GNUNET_FS_PublishContext *pc) | |||
308 | * @param emsg NULL on success, otherwise error message | 309 | * @param emsg NULL on success, otherwise error message |
309 | */ | 310 | */ |
310 | static void | 311 | static void |
311 | publish_kblocks_cont(void *cls, | 312 | publish_kblocks_cont (void *cls, |
312 | const struct GNUNET_FS_Uri *uri, | 313 | const struct GNUNET_FS_Uri *uri, |
313 | const char *emsg) | 314 | const char *emsg) |
314 | { | 315 | { |
315 | struct GNUNET_FS_PublishContext *pc = cls; | 316 | struct GNUNET_FS_PublishContext *pc = cls; |
316 | struct GNUNET_FS_FileInformation *p = pc->fi_pos; | 317 | struct GNUNET_FS_FileInformation *p = pc->fi_pos; |
317 | 318 | ||
318 | pc->ksk_pc = NULL; | 319 | pc->ksk_pc = NULL; |
319 | if (NULL != emsg) | 320 | if (NULL != emsg) |
320 | { | 321 | { |
321 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 322 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
322 | "Error uploading KSK blocks: %s\n", | 323 | "Error uploading KSK blocks: %s\n", |
323 | emsg); | 324 | emsg); |
324 | signal_publish_error(p, pc, emsg); | 325 | signal_publish_error (p, pc, emsg); |
325 | GNUNET_FS_file_information_sync_(p); | 326 | GNUNET_FS_file_information_sync_ (p); |
326 | GNUNET_FS_publish_sync_(pc); | 327 | GNUNET_FS_publish_sync_ (pc); |
327 | GNUNET_assert(NULL == pc->upload_task); | 328 | GNUNET_assert (NULL == pc->upload_task); |
328 | pc->upload_task = | 329 | pc->upload_task = |
329 | GNUNET_SCHEDULER_add_with_priority | 330 | GNUNET_SCHEDULER_add_with_priority |
330 | (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, | 331 | (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, |
331 | &GNUNET_FS_publish_main_, | 332 | &GNUNET_FS_publish_main_, |
332 | pc); | 333 | pc); |
333 | return; | 334 | return; |
334 | } | 335 | } |
335 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 336 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
336 | "KSK blocks published, moving on to next file\n"); | 337 | "KSK blocks published, moving on to next file\n"); |
337 | if (NULL != p->dir) | 338 | if (NULL != p->dir) |
338 | signal_publish_completion(p, pc); | 339 | signal_publish_completion (p, pc); |
339 | /* move on to next file */ | 340 | /* move on to next file */ |
340 | if (NULL != p->next) | 341 | if (NULL != p->next) |
341 | pc->fi_pos = p->next; | 342 | pc->fi_pos = p->next; |
342 | else | 343 | else |
343 | pc->fi_pos = p->dir; | 344 | pc->fi_pos = p->dir; |
344 | GNUNET_FS_publish_sync_(pc); | 345 | GNUNET_FS_publish_sync_ (pc); |
345 | GNUNET_assert(NULL == pc->upload_task); | 346 | GNUNET_assert (NULL == pc->upload_task); |
346 | pc->upload_task = | 347 | pc->upload_task = |
347 | GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_BACKGROUND, | 348 | GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, |
348 | &GNUNET_FS_publish_main_, pc); | 349 | &GNUNET_FS_publish_main_, pc); |
349 | } | 350 | } |
350 | 351 | ||
351 | 352 | ||
@@ -363,11 +364,11 @@ publish_kblocks_cont(void *cls, | |||
363 | * @return number of bytes copied to buf, 0 on error | 364 | * @return number of bytes copied to buf, 0 on error |
364 | */ | 365 | */ |
365 | static size_t | 366 | static size_t |
366 | block_reader(void *cls, | 367 | block_reader (void *cls, |
367 | uint64_t offset, | 368 | uint64_t offset, |
368 | size_t max, | 369 | size_t max, |
369 | void *buf, | 370 | void *buf, |
370 | char **emsg) | 371 | char **emsg) |
371 | { | 372 | { |
372 | struct GNUNET_FS_PublishContext *pc = cls; | 373 | struct GNUNET_FS_PublishContext *pc = cls; |
373 | struct GNUNET_FS_FileInformation *p; | 374 | struct GNUNET_FS_FileInformation *p; |
@@ -376,31 +377,31 @@ block_reader(void *cls, | |||
376 | 377 | ||
377 | p = pc->fi_pos; | 378 | p = pc->fi_pos; |
378 | if (GNUNET_YES == p->is_directory) | 379 | if (GNUNET_YES == p->is_directory) |
379 | { | 380 | { |
380 | pt_size = GNUNET_MIN(max, p->data.dir.dir_size - offset); | 381 | pt_size = GNUNET_MIN (max, p->data.dir.dir_size - offset); |
381 | dd = p->data.dir.dir_data; | 382 | dd = p->data.dir.dir_data; |
382 | GNUNET_memcpy(buf, &dd[offset], pt_size); | 383 | GNUNET_memcpy (buf, &dd[offset], pt_size); |
383 | } | 384 | } |
384 | else | 385 | else |
385 | { | 386 | { |
386 | if (UINT64_MAX == offset) | 387 | if (UINT64_MAX == offset) |
387 | { | 388 | { |
388 | if (&GNUNET_FS_data_reader_file_ == p->data.file.reader) | 389 | if (&GNUNET_FS_data_reader_file_ == p->data.file.reader) |
389 | { | 390 | { |
390 | /* force closing the file to avoid keeping too many files open */ | 391 | /* force closing the file to avoid keeping too many files open */ |
391 | p->data.file.reader(p->data.file.reader_cls, offset, 0, NULL, NULL); | 392 | p->data.file.reader (p->data.file.reader_cls, offset, 0, NULL, NULL); |
392 | } | 393 | } |
393 | return 0; | 394 | return 0; |
394 | } | 395 | } |
395 | pt_size = GNUNET_MIN(max, p->data.file.file_size - offset); | 396 | pt_size = GNUNET_MIN (max, p->data.file.file_size - offset); |
396 | if (0 == pt_size) | 397 | if (0 == pt_size) |
397 | return 0; /* calling reader with pt_size==0 | 398 | return 0; /* calling reader with pt_size==0 |
398 | * might free buf, so don't! */ | 399 | * might free buf, so don't! */ |
399 | if (pt_size != | 400 | if (pt_size != |
400 | p->data.file.reader(p->data.file.reader_cls, offset, pt_size, buf, | 401 | p->data.file.reader (p->data.file.reader_cls, offset, pt_size, buf, |
401 | emsg)) | 402 | emsg)) |
402 | return 0; | 403 | return 0; |
403 | } | 404 | } |
404 | return pt_size; | 405 | return pt_size; |
405 | } | 406 | } |
406 | 407 | ||
@@ -413,7 +414,7 @@ block_reader(void *cls, | |||
413 | * @param cls our publishing context | 414 | * @param cls our publishing context |
414 | */ | 415 | */ |
415 | static void | 416 | static void |
416 | encode_cont(void *cls) | 417 | encode_cont (void *cls) |
417 | { | 418 | { |
418 | struct GNUNET_FS_PublishContext *pc = cls; | 419 | struct GNUNET_FS_PublishContext *pc = cls; |
419 | struct GNUNET_FS_FileInformation *p; | 420 | struct GNUNET_FS_FileInformation *p; |
@@ -421,44 +422,44 @@ encode_cont(void *cls) | |||
421 | char *emsg; | 422 | char *emsg; |
422 | uint64_t flen; | 423 | uint64_t flen; |
423 | 424 | ||
424 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 425 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
425 | "Finished with tree encoder\n"); | 426 | "Finished with tree encoder\n"); |
426 | p = pc->fi_pos; | 427 | p = pc->fi_pos; |
427 | p->chk_uri = GNUNET_FS_tree_encoder_get_uri(p->te); | 428 | p->chk_uri = GNUNET_FS_tree_encoder_get_uri (p->te); |
428 | GNUNET_FS_file_information_sync_(p); | 429 | GNUNET_FS_file_information_sync_ (p); |
429 | GNUNET_FS_tree_encoder_finish(p->te, &emsg); | 430 | GNUNET_FS_tree_encoder_finish (p->te, &emsg); |
430 | p->te = NULL; | 431 | p->te = NULL; |
431 | if (NULL != emsg) | 432 | if (NULL != emsg) |
432 | { | 433 | { |
433 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 434 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
434 | "Error during tree walk: %s\n", | 435 | "Error during tree walk: %s\n", |
435 | emsg); | 436 | emsg); |
436 | GNUNET_asprintf(&p->emsg, | 437 | GNUNET_asprintf (&p->emsg, |
437 | _("Publishing failed: %s"), | 438 | _ ("Publishing failed: %s"), |
438 | emsg); | 439 | emsg); |
439 | GNUNET_free(emsg); | 440 | GNUNET_free (emsg); |
440 | pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR; | 441 | pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR; |
441 | pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL; | 442 | pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL; |
442 | pi.value.publish.specifics.error.message = p->emsg; | 443 | pi.value.publish.specifics.error.message = p->emsg; |
443 | p->client_info = GNUNET_FS_publish_make_status_(&pi, pc, p, 0); | 444 | p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, 0); |
444 | } | 445 | } |
445 | else | 446 | else |
446 | { | 447 | { |
447 | /* final progress event */ | 448 | /* final progress event */ |
448 | GNUNET_assert(NULL != p->chk_uri); | 449 | GNUNET_assert (NULL != p->chk_uri); |
449 | flen = GNUNET_FS_uri_chk_get_file_size(p->chk_uri); | 450 | flen = GNUNET_FS_uri_chk_get_file_size (p->chk_uri); |
450 | pi.status = GNUNET_FS_STATUS_PUBLISH_PROGRESS; | 451 | pi.status = GNUNET_FS_STATUS_PUBLISH_PROGRESS; |
451 | pi.value.publish.specifics.progress.data = NULL; | 452 | pi.value.publish.specifics.progress.data = NULL; |
452 | pi.value.publish.specifics.progress.offset = flen; | 453 | pi.value.publish.specifics.progress.offset = flen; |
453 | pi.value.publish.specifics.progress.data_len = 0; | 454 | pi.value.publish.specifics.progress.data_len = 0; |
454 | pi.value.publish.specifics.progress.depth = GNUNET_FS_compute_depth(flen); | 455 | pi.value.publish.specifics.progress.depth = GNUNET_FS_compute_depth (flen); |
455 | p->client_info = GNUNET_FS_publish_make_status_(&pi, pc, p, flen); | 456 | p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, flen); |
456 | } | 457 | } |
457 | /* continue with main */ /* continue with main */ | 458 | /* continue with main */ /* continue with main */ |
458 | GNUNET_assert(NULL == pc->upload_task); | 459 | GNUNET_assert (NULL == pc->upload_task); |
459 | pc->upload_task = | 460 | pc->upload_task = |
460 | GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_BACKGROUND, | 461 | GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, |
461 | &GNUNET_FS_publish_main_, pc); | 462 | &GNUNET_FS_publish_main_, pc); |
462 | } | 463 | } |
463 | 464 | ||
464 | 465 | ||
@@ -477,13 +478,13 @@ encode_cont(void *cls) | |||
477 | * @param block_size size of @a block (in bytes) | 478 | * @param block_size size of @a block (in bytes) |
478 | */ | 479 | */ |
479 | static void | 480 | static void |
480 | block_proc(void *cls, | 481 | block_proc (void *cls, |
481 | const struct ContentHashKey *chk, | 482 | const struct ContentHashKey *chk, |
482 | uint64_t offset, | 483 | uint64_t offset, |
483 | unsigned int depth, | 484 | unsigned int depth, |
484 | enum GNUNET_BLOCK_Type type, | 485 | enum GNUNET_BLOCK_Type type, |
485 | const void *block, | 486 | const void *block, |
486 | uint16_t block_size) | 487 | uint16_t block_size) |
487 | { | 488 | { |
488 | struct GNUNET_FS_PublishContext *pc = cls; | 489 | struct GNUNET_FS_PublishContext *pc = cls; |
489 | struct GNUNET_FS_FileInformation *p; | 490 | struct GNUNET_FS_FileInformation *p; |
@@ -491,62 +492,63 @@ block_proc(void *cls, | |||
491 | 492 | ||
492 | p = pc->fi_pos; | 493 | p = pc->fi_pos; |
493 | if (NULL == pc->dsh) | 494 | if (NULL == pc->dsh) |
494 | { | 495 | { |
495 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 496 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
496 | "Waiting for datastore connection\n"); | 497 | "Waiting for datastore connection\n"); |
497 | GNUNET_assert(NULL == pc->upload_task); | 498 | GNUNET_assert (NULL == pc->upload_task); |
498 | pc->upload_task = | 499 | pc->upload_task = |
499 | GNUNET_SCHEDULER_add_with_priority | 500 | GNUNET_SCHEDULER_add_with_priority |
500 | (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, &GNUNET_FS_publish_main_, pc); | 501 | (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, &GNUNET_FS_publish_main_, pc); |
501 | return; | 502 | return; |
502 | } | 503 | } |
503 | 504 | ||
504 | if ((GNUNET_YES != p->is_directory) && | 505 | if ((GNUNET_YES != p->is_directory) && |
505 | (GNUNET_YES == p->data.file.do_index) && | 506 | (GNUNET_YES == p->data.file.do_index) && |
506 | (GNUNET_BLOCK_TYPE_FS_DBLOCK == type)) | 507 | (GNUNET_BLOCK_TYPE_FS_DBLOCK == type)) |
507 | { | 508 | { |
508 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 509 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
509 | "Indexing block `%s' for offset %llu with index size %u\n", | 510 | "Indexing block `%s' for offset %llu with index size %u\n", |
510 | GNUNET_h2s(&chk->query), | 511 | GNUNET_h2s (&chk->query), |
511 | (unsigned long long)offset, | 512 | (unsigned long long) offset, |
512 | (unsigned int)sizeof(struct OnDemandBlock)); | 513 | (unsigned int) sizeof(struct OnDemandBlock)); |
513 | odb.offset = GNUNET_htonll(offset); | 514 | odb.offset = GNUNET_htonll (offset); |
514 | odb.file_id = p->data.file.file_id; | 515 | odb.file_id = p->data.file.file_id; |
515 | GNUNET_assert(pc->qre == NULL); | 516 | GNUNET_assert (pc->qre == NULL); |
516 | pc->qre = | 517 | pc->qre = |
517 | GNUNET_DATASTORE_put(pc->dsh, | 518 | GNUNET_DATASTORE_put (pc->dsh, |
518 | (p->is_directory == GNUNET_YES) ? 0 : pc->rid, | 519 | (p->is_directory == GNUNET_YES) ? 0 : pc->rid, |
519 | &chk->query, | 520 | &chk->query, |
520 | sizeof(struct OnDemandBlock), | 521 | sizeof(struct OnDemandBlock), |
521 | &odb, | 522 | &odb, |
522 | GNUNET_BLOCK_TYPE_FS_ONDEMAND, | 523 | GNUNET_BLOCK_TYPE_FS_ONDEMAND, |
523 | p->bo.content_priority, | 524 | p->bo.content_priority, |
524 | p->bo.anonymity_level, | 525 | p->bo.anonymity_level, |
525 | p->bo.replication_level, | 526 | p->bo.replication_level, |
526 | p->bo.expiration_time, | 527 | p->bo.expiration_time, |
527 | -2, 1, | 528 | -2, 1, |
528 | &ds_put_cont, pc); | 529 | &ds_put_cont, pc); |
529 | return; | 530 | return; |
530 | } | 531 | } |
531 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 532 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
532 | "Publishing block `%s' for offset %llu with size %u\n", | 533 | "Publishing block `%s' for offset %llu with size %u\n", |
533 | GNUNET_h2s(&chk->query), | 534 | GNUNET_h2s (&chk->query), |
534 | (unsigned long long)offset, | 535 | (unsigned long long) offset, |
535 | (unsigned int)block_size); | 536 | (unsigned int) block_size); |
536 | GNUNET_assert(pc->qre == NULL); | 537 | GNUNET_assert (pc->qre == NULL); |
537 | pc->qre = | 538 | pc->qre = |
538 | GNUNET_DATASTORE_put(pc->dsh, (p->is_directory == GNUNET_YES) ? 0 : pc->rid, | 539 | GNUNET_DATASTORE_put (pc->dsh, (p->is_directory == GNUNET_YES) ? 0 : |
539 | &chk->query, | 540 | pc->rid, |
540 | block_size, | 541 | &chk->query, |
541 | block, | 542 | block_size, |
542 | type, | 543 | block, |
543 | p->bo.content_priority, | 544 | type, |
544 | p->bo.anonymity_level, | 545 | p->bo.content_priority, |
545 | p->bo.replication_level, | 546 | p->bo.anonymity_level, |
546 | p->bo.expiration_time, | 547 | p->bo.replication_level, |
547 | -2, 1, | 548 | p->bo.expiration_time, |
548 | &ds_put_cont, | 549 | -2, 1, |
549 | pc); | 550 | &ds_put_cont, |
551 | pc); | ||
550 | } | 552 | } |
551 | 553 | ||
552 | 554 | ||
@@ -561,10 +563,10 @@ block_proc(void *cls, | |||
561 | * @param depth depth of the block in the tree, 0 for DBLOCK | 563 | * @param depth depth of the block in the tree, 0 for DBLOCK |
562 | */ | 564 | */ |
563 | static void | 565 | static void |
564 | progress_proc(void *cls, uint64_t offset, | 566 | progress_proc (void *cls, uint64_t offset, |
565 | const void *pt_block, | 567 | const void *pt_block, |
566 | size_t pt_size, | 568 | size_t pt_size, |
567 | unsigned int depth) | 569 | unsigned int depth) |
568 | { | 570 | { |
569 | struct GNUNET_FS_PublishContext *pc = cls; | 571 | struct GNUNET_FS_PublishContext *pc = cls; |
570 | struct GNUNET_FS_FileInformation *p; | 572 | struct GNUNET_FS_FileInformation *p; |
@@ -577,23 +579,28 @@ progress_proc(void *cls, uint64_t offset, | |||
577 | pi.value.publish.specifics.progress.offset = offset; | 579 | pi.value.publish.specifics.progress.offset = offset; |
578 | pi.value.publish.specifics.progress.data_len = pt_size; | 580 | pi.value.publish.specifics.progress.data_len = pt_size; |
579 | pi.value.publish.specifics.progress.depth = depth; | 581 | pi.value.publish.specifics.progress.depth = depth; |
580 | p->client_info = GNUNET_FS_publish_make_status_(&pi, pc, p, offset); | 582 | p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, offset); |
581 | if ((0 != depth) || | 583 | if ((0 != depth) || |
582 | (GNUNET_YES == p->is_directory)) | 584 | (GNUNET_YES == p->is_directory)) |
583 | return; | 585 | return; |
584 | while (NULL != (par = p->dir)) | 586 | while (NULL != (par = p->dir)) |
585 | { | 587 | { |
586 | p = par; | 588 | p = par; |
587 | GNUNET_assert(GNUNET_YES == par->is_directory); | 589 | GNUNET_assert (GNUNET_YES == par->is_directory); |
588 | p->data.dir.contents_completed += pt_size; | 590 | p->data.dir.contents_completed += pt_size; |
589 | pi.status = GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY; | 591 | pi.status = GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY; |
590 | pi.value.publish.specifics.progress_directory.completed = p->data.dir.contents_completed; | 592 | pi.value.publish.specifics.progress_directory.completed = |
591 | pi.value.publish.specifics.progress_directory.total = p->data.dir.contents_size; | 593 | p->data.dir.contents_completed; |
592 | pi.value.publish.specifics.progress_directory.eta = GNUNET_TIME_calculate_eta(p->start_time, | 594 | pi.value.publish.specifics.progress_directory.total = |
593 | p->data.dir.contents_completed, | 595 | p->data.dir.contents_size; |
594 | p->data.dir.contents_size); | 596 | pi.value.publish.specifics.progress_directory.eta = |
595 | p->client_info = GNUNET_FS_publish_make_status_(&pi, pc, p, 0); | 597 | GNUNET_TIME_calculate_eta (p->start_time, |
596 | } | 598 | p |
599 | ->data.dir.contents_completed, | ||
600 | p | ||
601 | ->data.dir.contents_size); | ||
602 | p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, 0); | ||
603 | } | ||
597 | } | 604 | } |
598 | 605 | ||
599 | 606 | ||
@@ -605,7 +612,7 @@ progress_proc(void *cls, uint64_t offset, | |||
605 | * @param pc overall upload data | 612 | * @param pc overall upload data |
606 | */ | 613 | */ |
607 | static void | 614 | static void |
608 | publish_content(struct GNUNET_FS_PublishContext *pc) | 615 | publish_content (struct GNUNET_FS_PublishContext *pc) |
609 | { | 616 | { |
610 | struct GNUNET_FS_FileInformation *p; | 617 | struct GNUNET_FS_FileInformation *p; |
611 | char *emsg; | 618 | char *emsg; |
@@ -615,64 +622,66 @@ publish_content(struct GNUNET_FS_PublishContext *pc) | |||
615 | uint64_t size; | 622 | uint64_t size; |
616 | 623 | ||
617 | p = pc->fi_pos; | 624 | p = pc->fi_pos; |
618 | GNUNET_assert(NULL != p); | 625 | GNUNET_assert (NULL != p); |
619 | if (NULL == p->te) | 626 | if (NULL == p->te) |
620 | { | 627 | { |
621 | if (GNUNET_YES == p->is_directory) | 628 | if (GNUNET_YES == p->is_directory) |
629 | { | ||
630 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating directory\n"); | ||
631 | db = GNUNET_FS_directory_builder_create (p->meta); | ||
632 | dirpos = p->data.dir.entries; | ||
633 | while (NULL != dirpos) | ||
634 | { | ||
635 | if (GNUNET_YES == dirpos->is_directory) | ||
636 | { | ||
637 | raw_data = dirpos->data.dir.dir_data; | ||
638 | dirpos->data.dir.dir_data = NULL; | ||
639 | } | ||
640 | else | ||
622 | { | 641 | { |
623 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Creating directory\n"); | 642 | raw_data = NULL; |
624 | db = GNUNET_FS_directory_builder_create(p->meta); | 643 | if ((dirpos->data.file.file_size < MAX_INLINE_SIZE) && |
625 | dirpos = p->data.dir.entries; | 644 | (dirpos->data.file.file_size > 0)) |
626 | while (NULL != dirpos) | 645 | { |
646 | raw_data = GNUNET_malloc (dirpos->data.file.file_size); | ||
647 | emsg = NULL; | ||
648 | if (dirpos->data.file.file_size != | ||
649 | dirpos->data.file.reader (dirpos->data.file.reader_cls, 0, | ||
650 | dirpos->data.file.file_size, raw_data, | ||
651 | &emsg)) | ||
627 | { | 652 | { |
628 | if (GNUNET_YES == dirpos->is_directory) | 653 | GNUNET_free_non_null (emsg); |
629 | { | 654 | GNUNET_free (raw_data); |
630 | raw_data = dirpos->data.dir.dir_data; | 655 | raw_data = NULL; |
631 | dirpos->data.dir.dir_data = NULL; | ||
632 | } | ||
633 | else | ||
634 | { | ||
635 | raw_data = NULL; | ||
636 | if ((dirpos->data.file.file_size < MAX_INLINE_SIZE) && | ||
637 | (dirpos->data.file.file_size > 0)) | ||
638 | { | ||
639 | raw_data = GNUNET_malloc(dirpos->data.file.file_size); | ||
640 | emsg = NULL; | ||
641 | if (dirpos->data.file.file_size != | ||
642 | dirpos->data.file.reader(dirpos->data.file.reader_cls, 0, | ||
643 | dirpos->data.file.file_size, raw_data, | ||
644 | &emsg)) | ||
645 | { | ||
646 | GNUNET_free_non_null(emsg); | ||
647 | GNUNET_free(raw_data); | ||
648 | raw_data = NULL; | ||
649 | } | ||
650 | dirpos->data.file.reader(dirpos->data.file.reader_cls, UINT64_MAX, 0, 0, NULL); | ||
651 | } | ||
652 | } | ||
653 | GNUNET_FS_directory_builder_add(db, dirpos->chk_uri, dirpos->meta, | ||
654 | raw_data); | ||
655 | GNUNET_free_non_null(raw_data); | ||
656 | dirpos = dirpos->next; | ||
657 | } | 656 | } |
658 | GNUNET_free_non_null(p->data.dir.dir_data); | 657 | dirpos->data.file.reader (dirpos->data.file.reader_cls, UINT64_MAX, |
659 | p->data.dir.dir_data = NULL; | 658 | 0, 0, NULL); |
660 | p->data.dir.dir_size = 0; | 659 | } |
661 | GNUNET_FS_directory_builder_finish(db, &p->data.dir.dir_size, | ||
662 | &p->data.dir.dir_data); | ||
663 | GNUNET_FS_file_information_sync_(p); | ||
664 | } | 660 | } |
665 | size = (GNUNET_YES == p->is_directory) ? p->data.dir.dir_size : p->data.file.file_size; | 661 | GNUNET_FS_directory_builder_add (db, dirpos->chk_uri, dirpos->meta, |
666 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 662 | raw_data); |
667 | "Creating tree encoder\n"); | 663 | GNUNET_free_non_null (raw_data); |
668 | p->te = | 664 | dirpos = dirpos->next; |
669 | GNUNET_FS_tree_encoder_create(pc->h, size, pc, &block_reader, | 665 | } |
670 | &block_proc, &progress_proc, | 666 | GNUNET_free_non_null (p->data.dir.dir_data); |
671 | &encode_cont); | 667 | p->data.dir.dir_data = NULL; |
672 | } | 668 | p->data.dir.dir_size = 0; |
673 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 669 | GNUNET_FS_directory_builder_finish (db, &p->data.dir.dir_size, |
674 | "Processing next block from tree\n"); | 670 | &p->data.dir.dir_data); |
675 | GNUNET_FS_tree_encoder_next(p->te); | 671 | GNUNET_FS_file_information_sync_ (p); |
672 | } | ||
673 | size = (GNUNET_YES == p->is_directory) ? p->data.dir.dir_size : | ||
674 | p->data.file.file_size; | ||
675 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
676 | "Creating tree encoder\n"); | ||
677 | p->te = | ||
678 | GNUNET_FS_tree_encoder_create (pc->h, size, pc, &block_reader, | ||
679 | &block_proc, &progress_proc, | ||
680 | &encode_cont); | ||
681 | } | ||
682 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
683 | "Processing next block from tree\n"); | ||
684 | GNUNET_FS_tree_encoder_next (p->te); | ||
676 | } | 685 | } |
677 | 686 | ||
678 | 687 | ||
@@ -684,17 +693,17 @@ publish_content(struct GNUNET_FS_PublishContext *pc) | |||
684 | * @param msg the response we got | 693 | * @param msg the response we got |
685 | */ | 694 | */ |
686 | static int | 695 | static int |
687 | check_index_start_failed(void *cls, | 696 | check_index_start_failed (void *cls, |
688 | const struct GNUNET_MessageHeader *msg) | 697 | const struct GNUNET_MessageHeader *msg) |
689 | { | 698 | { |
690 | size_t msize = ntohs(msg->size) - sizeof(*msg); | 699 | size_t msize = ntohs (msg->size) - sizeof(*msg); |
691 | const char *emsg = (const char *)&msg[1]; | 700 | const char *emsg = (const char *) &msg[1]; |
692 | 701 | ||
693 | if (emsg[msize - sizeof(struct GNUNET_MessageHeader) - 1] != '\0') | 702 | if (emsg[msize - sizeof(struct GNUNET_MessageHeader) - 1] != '\0') |
694 | { | 703 | { |
695 | GNUNET_break(0); | 704 | GNUNET_break (0); |
696 | return GNUNET_SYSERR; | 705 | return GNUNET_SYSERR; |
697 | } | 706 | } |
698 | return GNUNET_OK; | 707 | return GNUNET_OK; |
699 | } | 708 | } |
700 | 709 | ||
@@ -707,27 +716,27 @@ check_index_start_failed(void *cls, | |||
707 | * @param msg the response we got | 716 | * @param msg the response we got |
708 | */ | 717 | */ |
709 | static void | 718 | static void |
710 | handle_index_start_failed(void *cls, | 719 | handle_index_start_failed (void *cls, |
711 | const struct GNUNET_MessageHeader *msg) | 720 | const struct GNUNET_MessageHeader *msg) |
712 | { | 721 | { |
713 | struct GNUNET_FS_PublishContext *pc = cls; | 722 | struct GNUNET_FS_PublishContext *pc = cls; |
714 | struct GNUNET_FS_FileInformation *p; | 723 | struct GNUNET_FS_FileInformation *p; |
715 | const char *emsg = (const char *)&msg[1]; | 724 | const char *emsg = (const char *) &msg[1]; |
716 | char *msgtxt; | 725 | char *msgtxt; |
717 | 726 | ||
718 | GNUNET_MQ_destroy(pc->mq); | 727 | GNUNET_MQ_destroy (pc->mq); |
719 | pc->mq = NULL; | 728 | pc->mq = NULL; |
720 | p = pc->fi_pos; | 729 | p = pc->fi_pos; |
721 | GNUNET_asprintf(&msgtxt, | 730 | GNUNET_asprintf (&msgtxt, |
722 | _("Can not index file `%s': %s.\n"), | 731 | _ ("Can not index file `%s': %s.\n"), |
723 | p->filename, | 732 | p->filename, |
724 | gettext(emsg)); | 733 | gettext (emsg)); |
725 | signal_publish_error(p, | 734 | signal_publish_error (p, |
726 | pc, | 735 | pc, |
727 | msgtxt); | 736 | msgtxt); |
728 | GNUNET_free(msgtxt); | 737 | GNUNET_free (msgtxt); |
729 | GNUNET_FS_file_information_sync_(p); | 738 | GNUNET_FS_file_information_sync_ (p); |
730 | GNUNET_FS_publish_sync_(pc); | 739 | GNUNET_FS_publish_sync_ (pc); |
731 | } | 740 | } |
732 | 741 | ||
733 | 742 | ||
@@ -739,18 +748,18 @@ handle_index_start_failed(void *cls, | |||
739 | * @param msg the response we got | 748 | * @param msg the response we got |
740 | */ | 749 | */ |
741 | static void | 750 | static void |
742 | handle_index_start_ok(void *cls, | 751 | handle_index_start_ok (void *cls, |
743 | const struct GNUNET_MessageHeader *msg) | 752 | const struct GNUNET_MessageHeader *msg) |
744 | { | 753 | { |
745 | struct GNUNET_FS_PublishContext *pc = cls; | 754 | struct GNUNET_FS_PublishContext *pc = cls; |
746 | struct GNUNET_FS_FileInformation *p; | 755 | struct GNUNET_FS_FileInformation *p; |
747 | 756 | ||
748 | GNUNET_MQ_destroy(pc->mq); | 757 | GNUNET_MQ_destroy (pc->mq); |
749 | pc->mq = NULL; | 758 | pc->mq = NULL; |
750 | p = pc->fi_pos; | 759 | p = pc->fi_pos; |
751 | p->data.file.index_start_confirmed = GNUNET_YES; | 760 | p->data.file.index_start_confirmed = GNUNET_YES; |
752 | GNUNET_FS_file_information_sync_(p); | 761 | GNUNET_FS_file_information_sync_ (p); |
753 | publish_content(pc); | 762 | publish_content (pc); |
754 | } | 763 | } |
755 | 764 | ||
756 | 765 | ||
@@ -763,25 +772,25 @@ handle_index_start_ok(void *cls, | |||
763 | * @param error error code | 772 | * @param error error code |
764 | */ | 773 | */ |
765 | static void | 774 | static void |
766 | index_mq_error_handler(void *cls, | 775 | index_mq_error_handler (void *cls, |
767 | enum GNUNET_MQ_Error error) | 776 | enum GNUNET_MQ_Error error) |
768 | { | 777 | { |
769 | struct GNUNET_FS_PublishContext *pc = cls; | 778 | struct GNUNET_FS_PublishContext *pc = cls; |
770 | struct GNUNET_FS_FileInformation *p; | 779 | struct GNUNET_FS_FileInformation *p; |
771 | 780 | ||
772 | if (NULL != pc->mq) | 781 | if (NULL != pc->mq) |
773 | { | 782 | { |
774 | GNUNET_MQ_destroy(pc->mq); | 783 | GNUNET_MQ_destroy (pc->mq); |
775 | pc->mq = NULL; | 784 | pc->mq = NULL; |
776 | } | 785 | } |
777 | p = pc->fi_pos; | 786 | p = pc->fi_pos; |
778 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 787 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
779 | _("Can not index file `%s': %s. Will try to insert instead.\n"), | 788 | _ ("Can not index file `%s': %s. Will try to insert instead.\n"), |
780 | p->filename, | 789 | p->filename, |
781 | _("error on index-start request to `fs' service")); | 790 | _ ("error on index-start request to `fs' service")); |
782 | p->data.file.do_index = GNUNET_NO; | 791 | p->data.file.do_index = GNUNET_NO; |
783 | GNUNET_FS_file_information_sync_(p); | 792 | GNUNET_FS_file_information_sync_ (p); |
784 | publish_content(pc); | 793 | publish_content (pc); |
785 | } | 794 | } |
786 | 795 | ||
787 | 796 | ||
@@ -793,20 +802,20 @@ index_mq_error_handler(void *cls, | |||
793 | * @param res resulting hash, NULL on error | 802 | * @param res resulting hash, NULL on error |
794 | */ | 803 | */ |
795 | static void | 804 | static void |
796 | hash_for_index_cb(void *cls, | 805 | hash_for_index_cb (void *cls, |
797 | const struct GNUNET_HashCode *res) | 806 | const struct GNUNET_HashCode *res) |
798 | { | 807 | { |
799 | struct GNUNET_FS_PublishContext *pc = cls; | 808 | struct GNUNET_FS_PublishContext *pc = cls; |
800 | struct GNUNET_MQ_MessageHandler handlers[] = { | 809 | struct GNUNET_MQ_MessageHandler handlers[] = { |
801 | GNUNET_MQ_hd_fixed_size(index_start_ok, | 810 | GNUNET_MQ_hd_fixed_size (index_start_ok, |
802 | GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK, | 811 | GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK, |
803 | struct GNUNET_MessageHeader, | 812 | struct GNUNET_MessageHeader, |
804 | pc), | 813 | pc), |
805 | GNUNET_MQ_hd_var_size(index_start_failed, | 814 | GNUNET_MQ_hd_var_size (index_start_failed, |
806 | GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED, | 815 | GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED, |
807 | struct GNUNET_MessageHeader, | 816 | struct GNUNET_MessageHeader, |
808 | pc), | 817 | pc), |
809 | GNUNET_MQ_handler_end() | 818 | GNUNET_MQ_handler_end () |
810 | }; | 819 | }; |
811 | struct GNUNET_FS_FileInformation *p; | 820 | struct GNUNET_FS_FileInformation *p; |
812 | struct GNUNET_MQ_Envelope *env; | 821 | struct GNUNET_MQ_Envelope *env; |
@@ -819,97 +828,99 @@ hash_for_index_cb(void *cls, | |||
819 | pc->fhc = NULL; | 828 | pc->fhc = NULL; |
820 | p = pc->fi_pos; | 829 | p = pc->fi_pos; |
821 | if (NULL == res) | 830 | if (NULL == res) |
822 | { | 831 | { |
823 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 832 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
824 | _("Can not index file `%s': %s. Will try to insert instead.\n"), | 833 | _ ( |
825 | p->filename, | 834 | "Can not index file `%s': %s. Will try to insert instead.\n"), |
826 | _("failed to compute hash")); | 835 | p->filename, |
827 | p->data.file.do_index = GNUNET_NO; | 836 | _ ("failed to compute hash")); |
828 | GNUNET_FS_file_information_sync_(p); | 837 | p->data.file.do_index = GNUNET_NO; |
829 | publish_content(pc); | 838 | GNUNET_FS_file_information_sync_ (p); |
830 | return; | 839 | publish_content (pc); |
831 | } | 840 | return; |
841 | } | ||
832 | if (GNUNET_YES == p->data.file.index_start_confirmed) | 842 | if (GNUNET_YES == p->data.file.index_start_confirmed) |
833 | { | 843 | { |
834 | publish_content(pc); | 844 | publish_content (pc); |
835 | return; | 845 | return; |
836 | } | 846 | } |
837 | fn = GNUNET_STRINGS_filename_expand(p->filename); | 847 | fn = GNUNET_STRINGS_filename_expand (p->filename); |
838 | GNUNET_assert(fn != NULL); | 848 | GNUNET_assert (fn != NULL); |
839 | slen = strlen(fn) + 1; | 849 | slen = strlen (fn) + 1; |
840 | if (slen >= | 850 | if (slen >= |
841 | GNUNET_MAX_MESSAGE_SIZE - sizeof(struct IndexStartMessage)) | 851 | GNUNET_MAX_MESSAGE_SIZE - sizeof(struct IndexStartMessage)) |
842 | { | 852 | { |
843 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 853 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
844 | _ | 854 | _ |
845 | ("Can not index file `%s': %s. Will try to insert instead.\n"), | 855 | ("Can not index file `%s': %s. Will try to insert instead.\n"), |
846 | fn, _("filename too long")); | 856 | fn, _ ("filename too long")); |
847 | GNUNET_free(fn); | 857 | GNUNET_free (fn); |
848 | p->data.file.do_index = GNUNET_NO; | 858 | p->data.file.do_index = GNUNET_NO; |
849 | GNUNET_FS_file_information_sync_(p); | 859 | GNUNET_FS_file_information_sync_ (p); |
850 | publish_content(pc); | 860 | publish_content (pc); |
851 | return; | 861 | return; |
852 | } | 862 | } |
853 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 863 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
854 | "Hash of indexed file `%s' is `%s'\n", | 864 | "Hash of indexed file `%s' is `%s'\n", |
855 | p->filename, | 865 | p->filename, |
856 | GNUNET_h2s(res)); | 866 | GNUNET_h2s (res)); |
857 | if (0 != (pc->options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY)) | 867 | if (0 != (pc->options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY)) |
858 | { | 868 | { |
859 | p->data.file.file_id = *res; | 869 | p->data.file.file_id = *res; |
860 | p->data.file.have_hash = GNUNET_YES; | 870 | p->data.file.have_hash = GNUNET_YES; |
861 | p->data.file.index_start_confirmed = GNUNET_YES; | 871 | p->data.file.index_start_confirmed = GNUNET_YES; |
862 | GNUNET_FS_file_information_sync_(p); | 872 | GNUNET_FS_file_information_sync_ (p); |
863 | publish_content(pc); | 873 | publish_content (pc); |
864 | GNUNET_free(fn); | 874 | GNUNET_free (fn); |
865 | return; | 875 | return; |
866 | } | 876 | } |
867 | pc->mq = GNUNET_CLIENT_connect(pc->h->cfg, | 877 | pc->mq = GNUNET_CLIENT_connect (pc->h->cfg, |
868 | "fs", | 878 | "fs", |
869 | handlers, | 879 | handlers, |
870 | &index_mq_error_handler, | 880 | &index_mq_error_handler, |
871 | pc); | 881 | pc); |
872 | if (NULL == pc->mq) | 882 | if (NULL == pc->mq) |
873 | { | 883 | { |
874 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 884 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
875 | _("Can not index file `%s': %s. Will try to insert instead.\n"), | 885 | _ ( |
876 | p->filename, | 886 | "Can not index file `%s': %s. Will try to insert instead.\n"), |
877 | _("could not connect to `fs' service")); | 887 | p->filename, |
878 | p->data.file.do_index = GNUNET_NO; | 888 | _ ("could not connect to `fs' service")); |
879 | publish_content(pc); | 889 | p->data.file.do_index = GNUNET_NO; |
880 | GNUNET_free(fn); | 890 | publish_content (pc); |
881 | return; | 891 | GNUNET_free (fn); |
882 | } | 892 | return; |
893 | } | ||
883 | if (p->data.file.have_hash != GNUNET_YES) | 894 | if (p->data.file.have_hash != GNUNET_YES) |
884 | { | 895 | { |
885 | p->data.file.file_id = *res; | 896 | p->data.file.file_id = *res; |
886 | p->data.file.have_hash = GNUNET_YES; | 897 | p->data.file.have_hash = GNUNET_YES; |
887 | GNUNET_FS_file_information_sync_(p); | 898 | GNUNET_FS_file_information_sync_ (p); |
888 | } | 899 | } |
889 | env = GNUNET_MQ_msg_extra(ism, | 900 | env = GNUNET_MQ_msg_extra (ism, |
890 | slen, | 901 | slen, |
891 | GNUNET_MESSAGE_TYPE_FS_INDEX_START); | 902 | GNUNET_MESSAGE_TYPE_FS_INDEX_START); |
892 | if (GNUNET_OK == | 903 | if (GNUNET_OK == |
893 | GNUNET_DISK_file_get_identifiers(p->filename, | 904 | GNUNET_DISK_file_get_identifiers (p->filename, |
894 | &dev, | 905 | &dev, |
895 | &ino)) | 906 | &ino)) |
896 | { | 907 | { |
897 | ism->device = GNUNET_htonll(dev); | 908 | ism->device = GNUNET_htonll (dev); |
898 | ism->inode = GNUNET_htonll(ino); | 909 | ism->inode = GNUNET_htonll (ino); |
899 | } | 910 | } |
900 | else | 911 | else |
901 | { | 912 | { |
902 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 913 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
903 | _("Failed to get file identifiers for `%s'\n"), | 914 | _ ("Failed to get file identifiers for `%s'\n"), |
904 | p->filename); | 915 | p->filename); |
905 | } | 916 | } |
906 | ism->file_id = *res; | 917 | ism->file_id = *res; |
907 | GNUNET_memcpy(&ism[1], | 918 | GNUNET_memcpy (&ism[1], |
908 | fn, | 919 | fn, |
909 | slen); | 920 | slen); |
910 | GNUNET_free(fn); | 921 | GNUNET_free (fn); |
911 | GNUNET_MQ_send(pc->mq, | 922 | GNUNET_MQ_send (pc->mq, |
912 | env); | 923 | env); |
913 | } | 924 | } |
914 | 925 | ||
915 | 926 | ||
@@ -919,27 +930,27 @@ hash_for_index_cb(void *cls, | |||
919 | * @param pc publishing context to do this for | 930 | * @param pc publishing context to do this for |
920 | */ | 931 | */ |
921 | static void | 932 | static void |
922 | publish_kblocks(struct GNUNET_FS_PublishContext *pc) | 933 | publish_kblocks (struct GNUNET_FS_PublishContext *pc) |
923 | { | 934 | { |
924 | struct GNUNET_FS_FileInformation *p; | 935 | struct GNUNET_FS_FileInformation *p; |
925 | 936 | ||
926 | p = pc->fi_pos; | 937 | p = pc->fi_pos; |
927 | /* upload of "p" complete, publish KBlocks! */ | 938 | /* upload of "p" complete, publish KBlocks! */ |
928 | if (NULL != p->keywords) | 939 | if (NULL != p->keywords) |
929 | { | 940 | { |
930 | pc->ksk_pc = GNUNET_FS_publish_ksk(pc->h, | 941 | pc->ksk_pc = GNUNET_FS_publish_ksk (pc->h, |
931 | p->keywords, | 942 | p->keywords, |
932 | p->meta, | 943 | p->meta, |
933 | p->chk_uri, | 944 | p->chk_uri, |
934 | &p->bo, | 945 | &p->bo, |
935 | pc->options, | 946 | pc->options, |
936 | &publish_kblocks_cont, | 947 | &publish_kblocks_cont, |
937 | pc); | 948 | pc); |
938 | } | 949 | } |
939 | else | 950 | else |
940 | { | 951 | { |
941 | publish_kblocks_cont(pc, p->chk_uri, NULL); | 952 | publish_kblocks_cont (pc, p->chk_uri, NULL); |
942 | } | 953 | } |
943 | } | 954 | } |
944 | 955 | ||
945 | 956 | ||
@@ -950,8 +961,8 @@ publish_kblocks(struct GNUNET_FS_PublishContext *pc) | |||
950 | * @param sig the response we got | 961 | * @param sig the response we got |
951 | */ | 962 | */ |
952 | static void | 963 | static void |
953 | handle_signature_response(void *cls, | 964 | handle_signature_response (void *cls, |
954 | const struct ResponseLocSignatureMessage *sig) | 965 | const struct ResponseLocSignatureMessage *sig) |
955 | { | 966 | { |
956 | struct GNUNET_FS_PublishContext *pc = cls; | 967 | struct GNUNET_FS_PublishContext *pc = cls; |
957 | struct GNUNET_FS_FileInformation *p; | 968 | struct GNUNET_FS_FileInformation *p; |
@@ -961,11 +972,11 @@ handle_signature_response(void *cls, | |||
961 | /* p->data.loc.fi kept from CHK before */ | 972 | /* p->data.loc.fi kept from CHK before */ |
962 | p->chk_uri->data.loc.peer = sig->peer; | 973 | p->chk_uri->data.loc.peer = sig->peer; |
963 | p->chk_uri->data.loc.expirationTime | 974 | p->chk_uri->data.loc.expirationTime |
964 | = GNUNET_TIME_absolute_ntoh(sig->expiration_time); | 975 | = GNUNET_TIME_absolute_ntoh (sig->expiration_time); |
965 | p->chk_uri->data.loc.contentSignature = sig->signature; | 976 | p->chk_uri->data.loc.contentSignature = sig->signature; |
966 | GNUNET_FS_file_information_sync_(p); | 977 | GNUNET_FS_file_information_sync_ (p); |
967 | GNUNET_FS_publish_sync_(pc); | 978 | GNUNET_FS_publish_sync_ (pc); |
968 | publish_kblocks(pc); | 979 | publish_kblocks (pc); |
969 | } | 980 | } |
970 | 981 | ||
971 | 982 | ||
@@ -978,19 +989,19 @@ handle_signature_response(void *cls, | |||
978 | * @param error error code | 989 | * @param error error code |
979 | */ | 990 | */ |
980 | static void | 991 | static void |
981 | loc_mq_error_handler(void *cls, | 992 | loc_mq_error_handler (void *cls, |
982 | enum GNUNET_MQ_Error error) | 993 | enum GNUNET_MQ_Error error) |
983 | { | 994 | { |
984 | struct GNUNET_FS_PublishContext *pc = cls; | 995 | struct GNUNET_FS_PublishContext *pc = cls; |
985 | 996 | ||
986 | if (NULL != pc->mq) | 997 | if (NULL != pc->mq) |
987 | { | 998 | { |
988 | GNUNET_MQ_destroy(pc->mq); | 999 | GNUNET_MQ_destroy (pc->mq); |
989 | pc->mq = NULL; | 1000 | pc->mq = NULL; |
990 | } | 1001 | } |
991 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 1002 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
992 | _("Can not create LOC URI. Will continue with CHK instead.\n")); | 1003 | _ ("Can not create LOC URI. Will continue with CHK instead.\n")); |
993 | publish_kblocks(pc); | 1004 | publish_kblocks (pc); |
994 | } | 1005 | } |
995 | 1006 | ||
996 | 1007 | ||
@@ -1002,42 +1013,43 @@ loc_mq_error_handler(void *cls, | |||
1002 | * @param pc the publishing context do to this for | 1013 | * @param pc the publishing context do to this for |
1003 | */ | 1014 | */ |
1004 | static void | 1015 | static void |
1005 | create_loc_uri(struct GNUNET_FS_PublishContext *pc) | 1016 | create_loc_uri (struct GNUNET_FS_PublishContext *pc) |
1006 | { | 1017 | { |
1007 | struct GNUNET_MQ_MessageHandler handlers[] = { | 1018 | struct GNUNET_MQ_MessageHandler handlers[] = { |
1008 | GNUNET_MQ_hd_fixed_size(signature_response, | 1019 | GNUNET_MQ_hd_fixed_size (signature_response, |
1009 | GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE, | 1020 | GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE, |
1010 | struct ResponseLocSignatureMessage, | 1021 | struct ResponseLocSignatureMessage, |
1011 | pc), | 1022 | pc), |
1012 | GNUNET_MQ_handler_end() | 1023 | GNUNET_MQ_handler_end () |
1013 | }; | 1024 | }; |
1014 | struct GNUNET_MQ_Envelope *env; | 1025 | struct GNUNET_MQ_Envelope *env; |
1015 | struct RequestLocSignatureMessage *req; | 1026 | struct RequestLocSignatureMessage *req; |
1016 | struct GNUNET_FS_FileInformation *p; | 1027 | struct GNUNET_FS_FileInformation *p; |
1017 | 1028 | ||
1018 | if (NULL != pc->mq) | 1029 | if (NULL != pc->mq) |
1019 | GNUNET_MQ_destroy(pc->mq); | 1030 | GNUNET_MQ_destroy (pc->mq); |
1020 | pc->mq = GNUNET_CLIENT_connect(pc->h->cfg, | 1031 | pc->mq = GNUNET_CLIENT_connect (pc->h->cfg, |
1021 | "fs", | 1032 | "fs", |
1022 | handlers, | 1033 | handlers, |
1023 | &loc_mq_error_handler, | 1034 | &loc_mq_error_handler, |
1024 | pc); | 1035 | pc); |
1025 | if (NULL == pc->mq) | 1036 | if (NULL == pc->mq) |
1026 | { | 1037 | { |
1027 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 1038 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1028 | _("Can not create LOC URI. Will continue with CHK instead.\n")); | 1039 | _ ( |
1029 | publish_kblocks(pc); | 1040 | "Can not create LOC URI. Will continue with CHK instead.\n")); |
1030 | return; | 1041 | publish_kblocks (pc); |
1031 | } | 1042 | return; |
1043 | } | ||
1032 | p = pc->fi_pos; | 1044 | p = pc->fi_pos; |
1033 | env = GNUNET_MQ_msg(req, | 1045 | env = GNUNET_MQ_msg (req, |
1034 | GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN); | 1046 | GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN); |
1035 | req->purpose = htonl(GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT); | 1047 | req->purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT); |
1036 | req->expiration_time = GNUNET_TIME_absolute_hton(p->bo.expiration_time); | 1048 | req->expiration_time = GNUNET_TIME_absolute_hton (p->bo.expiration_time); |
1037 | req->chk = p->chk_uri->data.chk.chk; | 1049 | req->chk = p->chk_uri->data.chk.chk; |
1038 | req->file_length = GNUNET_htonll(p->chk_uri->data.chk.file_length); | 1050 | req->file_length = GNUNET_htonll (p->chk_uri->data.chk.file_length); |
1039 | GNUNET_MQ_send(pc->mq, | 1051 | GNUNET_MQ_send (pc->mq, |
1040 | env); | 1052 | env); |
1041 | } | 1053 | } |
1042 | 1054 | ||
1043 | 1055 | ||
@@ -1047,7 +1059,7 @@ create_loc_uri(struct GNUNET_FS_PublishContext *pc) | |||
1047 | * @param cls `struct GNUNET_FS_PublishContext *` identifies the upload | 1059 | * @param cls `struct GNUNET_FS_PublishContext *` identifies the upload |
1048 | */ | 1060 | */ |
1049 | void | 1061 | void |
1050 | GNUNET_FS_publish_main_(void *cls) | 1062 | GNUNET_FS_publish_main_ (void *cls) |
1051 | { | 1063 | { |
1052 | struct GNUNET_FS_PublishContext *pc = cls; | 1064 | struct GNUNET_FS_PublishContext *pc = cls; |
1053 | struct GNUNET_FS_ProgressInfo pi; | 1065 | struct GNUNET_FS_ProgressInfo pi; |
@@ -1057,108 +1069,109 @@ GNUNET_FS_publish_main_(void *cls) | |||
1057 | pc->upload_task = NULL; | 1069 | pc->upload_task = NULL; |
1058 | p = pc->fi_pos; | 1070 | p = pc->fi_pos; |
1059 | if (NULL == p) | 1071 | if (NULL == p) |
1060 | { | 1072 | { |
1061 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1073 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1062 | "Publishing complete, now publishing SKS and KSK blocks.\n"); | 1074 | "Publishing complete, now publishing SKS and KSK blocks.\n"); |
1063 | /* upload of entire hierarchy complete, | 1075 | /* upload of entire hierarchy complete, |
1064 | * publish namespace entries */ | 1076 | * publish namespace entries */ |
1065 | GNUNET_FS_publish_sync_(pc); | 1077 | GNUNET_FS_publish_sync_ (pc); |
1066 | publish_sblock(pc); | 1078 | publish_sblock (pc); |
1067 | return; | 1079 | return; |
1068 | } | 1080 | } |
1069 | /* find starting position */ | 1081 | /* find starting position */ |
1070 | while ((GNUNET_YES == p->is_directory) && | 1082 | while ((GNUNET_YES == p->is_directory) && |
1071 | (NULL != p->data.dir.entries) && | 1083 | (NULL != p->data.dir.entries) && |
1072 | (NULL == p->emsg) && | 1084 | (NULL == p->emsg) && |
1073 | (NULL == p->data.dir.entries->chk_uri)) | 1085 | (NULL == p->data.dir.entries->chk_uri)) |
1074 | { | 1086 | { |
1075 | p = p->data.dir.entries; | 1087 | p = p->data.dir.entries; |
1076 | pc->fi_pos = p; | 1088 | pc->fi_pos = p; |
1077 | GNUNET_FS_publish_sync_(pc); | 1089 | GNUNET_FS_publish_sync_ (pc); |
1078 | } | 1090 | } |
1079 | /* abort on error */ | 1091 | /* abort on error */ |
1080 | if (NULL != p->emsg) | 1092 | if (NULL != p->emsg) |
1081 | { | 1093 | { |
1082 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1094 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1083 | "Error uploading: %s\n", | 1095 | "Error uploading: %s\n", |
1084 | p->emsg); | 1096 | p->emsg); |
1085 | /* error with current file, abort all | 1097 | /* error with current file, abort all |
1086 | * related files as well! */ | 1098 | * related files as well! */ |
1087 | while (NULL != p->dir) | 1099 | while (NULL != p->dir) |
1088 | { | 1100 | { |
1089 | fn = GNUNET_CONTAINER_meta_data_get_by_type(p->meta, | 1101 | fn = GNUNET_CONTAINER_meta_data_get_by_type (p->meta, |
1090 | EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME); | 1102 | EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME); |
1091 | p = p->dir; | 1103 | p = p->dir; |
1092 | if (fn != NULL) | 1104 | if (fn != NULL) |
1093 | { | 1105 | { |
1094 | GNUNET_asprintf(&p->emsg, | 1106 | GNUNET_asprintf (&p->emsg, |
1095 | _("Recursive upload failed at `%s': %s"), | 1107 | _ ("Recursive upload failed at `%s': %s"), |
1096 | fn, | 1108 | fn, |
1097 | p->emsg); | 1109 | p->emsg); |
1098 | GNUNET_free(fn); | 1110 | GNUNET_free (fn); |
1099 | } | 1111 | } |
1100 | else | 1112 | else |
1101 | { | 1113 | { |
1102 | GNUNET_asprintf(&p->emsg, | 1114 | GNUNET_asprintf (&p->emsg, |
1103 | _("Recursive upload failed: %s"), | 1115 | _ ("Recursive upload failed: %s"), |
1104 | p->emsg); | 1116 | p->emsg); |
1105 | } | 1117 | } |
1106 | pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR; | 1118 | pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR; |
1107 | pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL; | 1119 | pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL; |
1108 | pi.value.publish.specifics.error.message = p->emsg; | 1120 | pi.value.publish.specifics.error.message = p->emsg; |
1109 | p->client_info = GNUNET_FS_publish_make_status_(&pi, pc, p, 0); | 1121 | p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, 0); |
1110 | } | ||
1111 | pc->all_done = GNUNET_YES; | ||
1112 | GNUNET_FS_publish_sync_(pc); | ||
1113 | return; | ||
1114 | } | 1122 | } |
1123 | pc->all_done = GNUNET_YES; | ||
1124 | GNUNET_FS_publish_sync_ (pc); | ||
1125 | return; | ||
1126 | } | ||
1115 | /* handle completion */ | 1127 | /* handle completion */ |
1116 | if (NULL != p->chk_uri) | 1128 | if (NULL != p->chk_uri) |
1117 | { | 1129 | { |
1118 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1130 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1119 | "File upload complete, now publishing KSK blocks.\n"); | 1131 | "File upload complete, now publishing KSK blocks.\n"); |
1120 | GNUNET_FS_publish_sync_(pc); | 1132 | GNUNET_FS_publish_sync_ (pc); |
1121 | 1133 | ||
1122 | if ((0 == p->bo.anonymity_level) && | 1134 | if ((0 == p->bo.anonymity_level) && |
1123 | (GNUNET_YES != | 1135 | (GNUNET_YES != |
1124 | GNUNET_FS_uri_test_loc(p->chk_uri))) | 1136 | GNUNET_FS_uri_test_loc (p->chk_uri))) |
1125 | { | 1137 | { |
1126 | /* zero anonymity, box CHK URI in LOC URI */ | 1138 | /* zero anonymity, box CHK URI in LOC URI */ |
1127 | create_loc_uri(pc); | 1139 | create_loc_uri (pc); |
1128 | } | 1140 | } |
1129 | else | 1141 | else |
1130 | { | 1142 | { |
1131 | publish_kblocks(pc); | 1143 | publish_kblocks (pc); |
1132 | } | ||
1133 | return; | ||
1134 | } | 1144 | } |
1145 | return; | ||
1146 | } | ||
1135 | if ((GNUNET_YES != p->is_directory) && (p->data.file.do_index)) | 1147 | if ((GNUNET_YES != p->is_directory) && (p->data.file.do_index)) |
1148 | { | ||
1149 | if (NULL == p->filename) | ||
1136 | { | 1150 | { |
1137 | if (NULL == p->filename) | 1151 | p->data.file.do_index = GNUNET_NO; |
1138 | { | 1152 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1139 | p->data.file.do_index = GNUNET_NO; | 1153 | _ ( |
1140 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 1154 | "Can not index file `%s': %s. Will try to insert instead.\n"), |
1141 | _("Can not index file `%s': %s. Will try to insert instead.\n"), | 1155 | "<no-name>", |
1142 | "<no-name>", | 1156 | _ ("needs to be an actual file")); |
1143 | _("needs to be an actual file")); | 1157 | GNUNET_FS_file_information_sync_ (p); |
1144 | GNUNET_FS_file_information_sync_(p); | 1158 | publish_content (pc); |
1145 | publish_content(pc); | ||
1146 | return; | ||
1147 | } | ||
1148 | if (p->data.file.have_hash) | ||
1149 | { | ||
1150 | hash_for_index_cb(pc, &p->data.file.file_id); | ||
1151 | } | ||
1152 | else | ||
1153 | { | ||
1154 | p->start_time = GNUNET_TIME_absolute_get(); | ||
1155 | pc->fhc = | ||
1156 | GNUNET_CRYPTO_hash_file(GNUNET_SCHEDULER_PRIORITY_IDLE, p->filename, | ||
1157 | HASHING_BLOCKSIZE, &hash_for_index_cb, pc); | ||
1158 | } | ||
1159 | return; | 1159 | return; |
1160 | } | 1160 | } |
1161 | publish_content(pc); | 1161 | if (p->data.file.have_hash) |
1162 | { | ||
1163 | hash_for_index_cb (pc, &p->data.file.file_id); | ||
1164 | } | ||
1165 | else | ||
1166 | { | ||
1167 | p->start_time = GNUNET_TIME_absolute_get (); | ||
1168 | pc->fhc = | ||
1169 | GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE, p->filename, | ||
1170 | HASHING_BLOCKSIZE, &hash_for_index_cb, pc); | ||
1171 | } | ||
1172 | return; | ||
1173 | } | ||
1174 | publish_content (pc); | ||
1162 | } | 1175 | } |
1163 | 1176 | ||
1164 | 1177 | ||
@@ -1177,14 +1190,14 @@ GNUNET_FS_publish_main_(void *cls) | |||
1177 | * @return #GNUNET_OK to continue (always) | 1190 | * @return #GNUNET_OK to continue (always) |
1178 | */ | 1191 | */ |
1179 | static int | 1192 | static int |
1180 | fip_signal_start(void *cls, | 1193 | fip_signal_start (void *cls, |
1181 | struct GNUNET_FS_FileInformation *fi, | 1194 | struct GNUNET_FS_FileInformation *fi, |
1182 | uint64_t length, | 1195 | uint64_t length, |
1183 | struct GNUNET_CONTAINER_MetaData *meta, | 1196 | struct GNUNET_CONTAINER_MetaData *meta, |
1184 | struct GNUNET_FS_Uri **uri, | 1197 | struct GNUNET_FS_Uri **uri, |
1185 | struct GNUNET_FS_BlockOptions *bo, | 1198 | struct GNUNET_FS_BlockOptions *bo, |
1186 | int *do_index, | 1199 | int *do_index, |
1187 | void **client_info) | 1200 | void **client_info) |
1188 | { | 1201 | { |
1189 | struct GNUNET_FS_PublishContext *pc = cls; | 1202 | struct GNUNET_FS_PublishContext *pc = cls; |
1190 | struct GNUNET_FS_ProgressInfo pi; | 1203 | struct GNUNET_FS_ProgressInfo pi; |
@@ -1192,52 +1205,52 @@ fip_signal_start(void *cls, | |||
1192 | uint64_t left; | 1205 | uint64_t left; |
1193 | 1206 | ||
1194 | if (GNUNET_YES == pc->skip_next_fi_callback) | 1207 | if (GNUNET_YES == pc->skip_next_fi_callback) |
1195 | { | 1208 | { |
1196 | pc->skip_next_fi_callback = GNUNET_NO; | 1209 | pc->skip_next_fi_callback = GNUNET_NO; |
1197 | return GNUNET_OK; | 1210 | return GNUNET_OK; |
1198 | } | 1211 | } |
1199 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1212 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1200 | "Starting publish operation\n"); | 1213 | "Starting publish operation\n"); |
1201 | if (*do_index) | 1214 | if (*do_index) |
1202 | { | 1215 | { |
1203 | /* space for on-demand blocks */ | 1216 | /* space for on-demand blocks */ |
1204 | pc->reserve_space += | 1217 | pc->reserve_space += |
1205 | ((length + DBLOCK_SIZE - | 1218 | ((length + DBLOCK_SIZE |
1206 | 1) / DBLOCK_SIZE) * sizeof(struct OnDemandBlock); | 1219 | - 1) / DBLOCK_SIZE) * sizeof(struct OnDemandBlock); |
1207 | } | 1220 | } |
1208 | else | 1221 | else |
1209 | { | 1222 | { |
1210 | /* space for DBlocks */ | 1223 | /* space for DBlocks */ |
1211 | pc->reserve_space += length; | 1224 | pc->reserve_space += length; |
1212 | } | 1225 | } |
1213 | /* entries for IBlocks and DBlocks, space for IBlocks */ | 1226 | /* entries for IBlocks and DBlocks, space for IBlocks */ |
1214 | left = length; | 1227 | left = length; |
1215 | while (1) | 1228 | while (1) |
1216 | { | 1229 | { |
1217 | left = (left + DBLOCK_SIZE - 1) / DBLOCK_SIZE; | 1230 | left = (left + DBLOCK_SIZE - 1) / DBLOCK_SIZE; |
1218 | pc->reserve_entries += left; | 1231 | pc->reserve_entries += left; |
1219 | if (left <= 1) | 1232 | if (left <= 1) |
1220 | break; | 1233 | break; |
1221 | left = left * sizeof(struct ContentHashKey); | 1234 | left = left * sizeof(struct ContentHashKey); |
1222 | pc->reserve_space += left; | 1235 | pc->reserve_space += left; |
1223 | } | 1236 | } |
1224 | pc->reserve_entries++; | 1237 | pc->reserve_entries++; |
1225 | /* entries and space for keywords */ | 1238 | /* entries and space for keywords */ |
1226 | if (NULL != *uri) | 1239 | if (NULL != *uri) |
1227 | { | 1240 | { |
1228 | kc = GNUNET_FS_uri_ksk_get_keyword_count(*uri); | 1241 | kc = GNUNET_FS_uri_ksk_get_keyword_count (*uri); |
1229 | pc->reserve_entries += kc; | 1242 | pc->reserve_entries += kc; |
1230 | pc->reserve_space += GNUNET_MAX_MESSAGE_SIZE * kc; | 1243 | pc->reserve_space += GNUNET_MAX_MESSAGE_SIZE * kc; |
1231 | } | 1244 | } |
1232 | pi.status = GNUNET_FS_STATUS_PUBLISH_START; | 1245 | pi.status = GNUNET_FS_STATUS_PUBLISH_START; |
1233 | *client_info = GNUNET_FS_publish_make_status_(&pi, pc, fi, 0); | 1246 | *client_info = GNUNET_FS_publish_make_status_ (&pi, pc, fi, 0); |
1234 | GNUNET_FS_file_information_sync_(fi); | 1247 | GNUNET_FS_file_information_sync_ (fi); |
1235 | if ((fi->is_directory) && (fi->dir != NULL)) | 1248 | if ((fi->is_directory) && (fi->dir != NULL)) |
1236 | { | 1249 | { |
1237 | /* We are a directory, and we are not top-level; process entries in directory */ | 1250 | /* We are a directory, and we are not top-level; process entries in directory */ |
1238 | pc->skip_next_fi_callback = GNUNET_YES; | 1251 | pc->skip_next_fi_callback = GNUNET_YES; |
1239 | GNUNET_FS_file_information_inspect(fi, &fip_signal_start, pc); | 1252 | GNUNET_FS_file_information_inspect (fi, &fip_signal_start, pc); |
1240 | } | 1253 | } |
1241 | return GNUNET_OK; | 1254 | return GNUNET_OK; |
1242 | } | 1255 | } |
1243 | 1256 | ||
@@ -1250,39 +1263,40 @@ fip_signal_start(void *cls, | |||
1250 | * @param pc the publish context of which a file is being suspended | 1263 | * @param pc the publish context of which a file is being suspended |
1251 | */ | 1264 | */ |
1252 | static void | 1265 | static void |
1253 | suspend_operation(struct GNUNET_FS_FileInformation *fi, | 1266 | suspend_operation (struct GNUNET_FS_FileInformation *fi, |
1254 | struct GNUNET_FS_PublishContext *pc) | 1267 | struct GNUNET_FS_PublishContext *pc) |
1255 | { | 1268 | { |
1256 | struct GNUNET_FS_ProgressInfo pi; | 1269 | struct GNUNET_FS_ProgressInfo pi; |
1257 | uint64_t off; | 1270 | uint64_t off; |
1258 | 1271 | ||
1259 | if (NULL != pc->ksk_pc) | 1272 | if (NULL != pc->ksk_pc) |
1260 | { | 1273 | { |
1261 | GNUNET_FS_publish_ksk_cancel(pc->ksk_pc); | 1274 | GNUNET_FS_publish_ksk_cancel (pc->ksk_pc); |
1262 | pc->ksk_pc = NULL; | 1275 | pc->ksk_pc = NULL; |
1263 | } | 1276 | } |
1264 | if (NULL != pc->sks_pc) | 1277 | if (NULL != pc->sks_pc) |
1265 | { | 1278 | { |
1266 | GNUNET_FS_publish_sks_cancel(pc->sks_pc); | 1279 | GNUNET_FS_publish_sks_cancel (pc->sks_pc); |
1267 | pc->sks_pc = NULL; | 1280 | pc->sks_pc = NULL; |
1268 | } | 1281 | } |
1269 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1282 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1270 | "Suspending publish operation\n"); | 1283 | "Suspending publish operation\n"); |
1271 | GNUNET_free_non_null(fi->serialization); | 1284 | GNUNET_free_non_null (fi->serialization); |
1272 | fi->serialization = NULL; | 1285 | fi->serialization = NULL; |
1273 | off = (NULL == fi->chk_uri) ? 0 : (GNUNET_YES == fi->is_directory) ? fi->data.dir.dir_size : fi->data.file.file_size; | 1286 | off = (NULL == fi->chk_uri) ? 0 : (GNUNET_YES == fi->is_directory) ? |
1287 | fi->data.dir.dir_size : fi->data.file.file_size; | ||
1274 | pi.status = GNUNET_FS_STATUS_PUBLISH_SUSPEND; | 1288 | pi.status = GNUNET_FS_STATUS_PUBLISH_SUSPEND; |
1275 | GNUNET_break(NULL == GNUNET_FS_publish_make_status_(&pi, pc, fi, off)); | 1289 | GNUNET_break (NULL == GNUNET_FS_publish_make_status_ (&pi, pc, fi, off)); |
1276 | if (NULL != pc->qre) | 1290 | if (NULL != pc->qre) |
1277 | { | 1291 | { |
1278 | GNUNET_DATASTORE_cancel(pc->qre); | 1292 | GNUNET_DATASTORE_cancel (pc->qre); |
1279 | pc->qre = NULL; | 1293 | pc->qre = NULL; |
1280 | } | 1294 | } |
1281 | if (NULL != pc->dsh) | 1295 | if (NULL != pc->dsh) |
1282 | { | 1296 | { |
1283 | GNUNET_DATASTORE_disconnect(pc->dsh, GNUNET_NO); | 1297 | GNUNET_DATASTORE_disconnect (pc->dsh, GNUNET_NO); |
1284 | pc->dsh = NULL; | 1298 | pc->dsh = NULL; |
1285 | } | 1299 | } |
1286 | pc->rid = 0; | 1300 | pc->rid = 0; |
1287 | } | 1301 | } |
1288 | 1302 | ||
@@ -1302,29 +1316,29 @@ suspend_operation(struct GNUNET_FS_FileInformation *fi, | |||
1302 | * @return #GNUNET_OK to continue (always) | 1316 | * @return #GNUNET_OK to continue (always) |
1303 | */ | 1317 | */ |
1304 | static int | 1318 | static int |
1305 | fip_signal_suspend(void *cls, | 1319 | fip_signal_suspend (void *cls, |
1306 | struct GNUNET_FS_FileInformation *fi, | 1320 | struct GNUNET_FS_FileInformation *fi, |
1307 | uint64_t length, | 1321 | uint64_t length, |
1308 | struct GNUNET_CONTAINER_MetaData *meta, | 1322 | struct GNUNET_CONTAINER_MetaData *meta, |
1309 | struct GNUNET_FS_Uri **uri, | 1323 | struct GNUNET_FS_Uri **uri, |
1310 | struct GNUNET_FS_BlockOptions *bo, | 1324 | struct GNUNET_FS_BlockOptions *bo, |
1311 | int *do_index, | 1325 | int *do_index, |
1312 | void **client_info) | 1326 | void **client_info) |
1313 | { | 1327 | { |
1314 | struct GNUNET_FS_PublishContext *pc = cls; | 1328 | struct GNUNET_FS_PublishContext *pc = cls; |
1315 | 1329 | ||
1316 | if (GNUNET_YES == pc->skip_next_fi_callback) | 1330 | if (GNUNET_YES == pc->skip_next_fi_callback) |
1317 | { | 1331 | { |
1318 | pc->skip_next_fi_callback = GNUNET_NO; | 1332 | pc->skip_next_fi_callback = GNUNET_NO; |
1319 | return GNUNET_OK; | 1333 | return GNUNET_OK; |
1320 | } | 1334 | } |
1321 | if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory(meta)) | 1335 | if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (meta)) |
1322 | { | 1336 | { |
1323 | /* process entries in directory */ | 1337 | /* process entries in directory */ |
1324 | pc->skip_next_fi_callback = GNUNET_YES; | 1338 | pc->skip_next_fi_callback = GNUNET_YES; |
1325 | GNUNET_FS_file_information_inspect(fi, &fip_signal_suspend, pc); | 1339 | GNUNET_FS_file_information_inspect (fi, &fip_signal_suspend, pc); |
1326 | } | 1340 | } |
1327 | suspend_operation(fi, pc); | 1341 | suspend_operation (fi, pc); |
1328 | *client_info = NULL; | 1342 | *client_info = NULL; |
1329 | return GNUNET_OK; | 1343 | return GNUNET_OK; |
1330 | } | 1344 | } |
@@ -1337,21 +1351,21 @@ fip_signal_suspend(void *cls, | |||
1337 | * @param cls the `struct GNUNET_FS_PublishContext` to signal for | 1351 | * @param cls the `struct GNUNET_FS_PublishContext` to signal for |
1338 | */ | 1352 | */ |
1339 | void | 1353 | void |
1340 | GNUNET_FS_publish_signal_suspend_(void *cls) | 1354 | GNUNET_FS_publish_signal_suspend_ (void *cls) |
1341 | { | 1355 | { |
1342 | struct GNUNET_FS_PublishContext *pc = cls; | 1356 | struct GNUNET_FS_PublishContext *pc = cls; |
1343 | 1357 | ||
1344 | if (NULL != pc->upload_task) | 1358 | if (NULL != pc->upload_task) |
1345 | { | 1359 | { |
1346 | GNUNET_SCHEDULER_cancel(pc->upload_task); | 1360 | GNUNET_SCHEDULER_cancel (pc->upload_task); |
1347 | pc->upload_task = NULL; | 1361 | pc->upload_task = NULL; |
1348 | } | 1362 | } |
1349 | pc->skip_next_fi_callback = GNUNET_YES; | 1363 | pc->skip_next_fi_callback = GNUNET_YES; |
1350 | GNUNET_FS_file_information_inspect(pc->fi, &fip_signal_suspend, pc); | 1364 | GNUNET_FS_file_information_inspect (pc->fi, &fip_signal_suspend, pc); |
1351 | suspend_operation(pc->fi, pc); | 1365 | suspend_operation (pc->fi, pc); |
1352 | GNUNET_FS_end_top(pc->h, pc->top); | 1366 | GNUNET_FS_end_top (pc->h, pc->top); |
1353 | pc->top = NULL; | 1367 | pc->top = NULL; |
1354 | publish_cleanup(pc); | 1368 | publish_cleanup (pc); |
1355 | } | 1369 | } |
1356 | 1370 | ||
1357 | 1371 | ||
@@ -1365,30 +1379,30 @@ GNUNET_FS_publish_signal_suspend_(void *cls) | |||
1365 | * @param msg error message on error, otherwise NULL | 1379 | * @param msg error message on error, otherwise NULL |
1366 | */ | 1380 | */ |
1367 | static void | 1381 | static void |
1368 | finish_reserve(void *cls, | 1382 | finish_reserve (void *cls, |
1369 | int success, | 1383 | int success, |
1370 | struct GNUNET_TIME_Absolute min_expiration, | 1384 | struct GNUNET_TIME_Absolute min_expiration, |
1371 | const char *msg) | 1385 | const char *msg) |
1372 | { | 1386 | { |
1373 | struct GNUNET_FS_PublishContext *pc = cls; | 1387 | struct GNUNET_FS_PublishContext *pc = cls; |
1374 | 1388 | ||
1375 | pc->qre = NULL; | 1389 | pc->qre = NULL; |
1376 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1390 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1377 | "Reservation complete (%d)!\n", | 1391 | "Reservation complete (%d)!\n", |
1378 | success); | 1392 | success); |
1379 | if ((msg != NULL) || (success <= 0)) | 1393 | if ((msg != NULL) || (success <= 0)) |
1380 | { | 1394 | { |
1381 | GNUNET_asprintf(&pc->fi->emsg, | 1395 | GNUNET_asprintf (&pc->fi->emsg, |
1382 | _("Datastore failure: %s"), | 1396 | _ ("Datastore failure: %s"), |
1383 | msg); | 1397 | msg); |
1384 | signal_publish_error(pc->fi, pc, pc->fi->emsg); | 1398 | signal_publish_error (pc->fi, pc, pc->fi->emsg); |
1385 | return; | 1399 | return; |
1386 | } | 1400 | } |
1387 | pc->rid = success; | 1401 | pc->rid = success; |
1388 | GNUNET_assert(NULL == pc->upload_task); | 1402 | GNUNET_assert (NULL == pc->upload_task); |
1389 | pc->upload_task = | 1403 | pc->upload_task = |
1390 | GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_BACKGROUND, | 1404 | GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, |
1391 | &GNUNET_FS_publish_main_, pc); | 1405 | &GNUNET_FS_publish_main_, pc); |
1392 | } | 1406 | } |
1393 | 1407 | ||
1394 | 1408 | ||
@@ -1398,7 +1412,7 @@ finish_reserve(void *cls, | |||
1398 | * @param fi file structure to traverse | 1412 | * @param fi file structure to traverse |
1399 | */ | 1413 | */ |
1400 | static uint64_t | 1414 | static uint64_t |
1401 | compute_contents_size(struct GNUNET_FS_FileInformation *fi) | 1415 | compute_contents_size (struct GNUNET_FS_FileInformation *fi) |
1402 | { | 1416 | { |
1403 | struct GNUNET_FS_FileInformation *ent; | 1417 | struct GNUNET_FS_FileInformation *ent; |
1404 | 1418 | ||
@@ -1406,7 +1420,7 @@ compute_contents_size(struct GNUNET_FS_FileInformation *fi) | |||
1406 | return fi->data.file.file_size; | 1420 | return fi->data.file.file_size; |
1407 | fi->data.dir.contents_size = 0; | 1421 | fi->data.dir.contents_size = 0; |
1408 | for (ent = fi->data.dir.entries; NULL != ent; ent = ent->next) | 1422 | for (ent = fi->data.dir.entries; NULL != ent; ent = ent->next) |
1409 | fi->data.dir.contents_size += compute_contents_size(ent); | 1423 | fi->data.dir.contents_size += compute_contents_size (ent); |
1410 | return fi->data.dir.contents_size; | 1424 | return fi->data.dir.contents_size; |
1411 | } | 1425 | } |
1412 | 1426 | ||
@@ -1425,67 +1439,68 @@ compute_contents_size(struct GNUNET_FS_FileInformation *fi) | |||
1425 | * @return context that can be used to control the publish operation | 1439 | * @return context that can be used to control the publish operation |
1426 | */ | 1440 | */ |
1427 | struct GNUNET_FS_PublishContext * | 1441 | struct GNUNET_FS_PublishContext * |
1428 | GNUNET_FS_publish_start(struct GNUNET_FS_Handle *h, | 1442 | GNUNET_FS_publish_start (struct GNUNET_FS_Handle *h, |
1429 | struct GNUNET_FS_FileInformation *fi, | 1443 | struct GNUNET_FS_FileInformation *fi, |
1430 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, | 1444 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, |
1431 | const char *nid, | 1445 | const char *nid, |
1432 | const char *nuid, | 1446 | const char *nuid, |
1433 | enum GNUNET_FS_PublishOptions options) | 1447 | enum GNUNET_FS_PublishOptions options) |
1434 | { | 1448 | { |
1435 | struct GNUNET_FS_PublishContext *ret; | 1449 | struct GNUNET_FS_PublishContext *ret; |
1436 | struct GNUNET_DATASTORE_Handle *dsh; | 1450 | struct GNUNET_DATASTORE_Handle *dsh; |
1437 | 1451 | ||
1438 | GNUNET_assert(NULL != h); | 1452 | GNUNET_assert (NULL != h); |
1439 | compute_contents_size(fi); | 1453 | compute_contents_size (fi); |
1440 | if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY)) | 1454 | if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY)) |
1441 | { | 1455 | { |
1442 | dsh = GNUNET_DATASTORE_connect(h->cfg); | 1456 | dsh = GNUNET_DATASTORE_connect (h->cfg); |
1443 | if (NULL == dsh) | 1457 | if (NULL == dsh) |
1444 | return NULL; | 1458 | return NULL; |
1445 | } | 1459 | } |
1446 | else | 1460 | else |
1447 | { | 1461 | { |
1448 | dsh = NULL; | 1462 | dsh = NULL; |
1449 | } | 1463 | } |
1450 | ret = GNUNET_new(struct GNUNET_FS_PublishContext); | 1464 | ret = GNUNET_new (struct GNUNET_FS_PublishContext); |
1451 | ret->dsh = dsh; | 1465 | ret->dsh = dsh; |
1452 | ret->h = h; | 1466 | ret->h = h; |
1453 | ret->fi = fi; | 1467 | ret->fi = fi; |
1454 | if (NULL != ns) | 1468 | if (NULL != ns) |
1455 | { | 1469 | { |
1456 | ret->ns = GNUNET_new(struct GNUNET_CRYPTO_EcdsaPrivateKey); | 1470 | ret->ns = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPrivateKey); |
1457 | *ret->ns = *ns; | 1471 | *ret->ns = *ns; |
1458 | GNUNET_assert(NULL != nid); | 1472 | GNUNET_assert (NULL != nid); |
1459 | ret->nid = GNUNET_strdup(nid); | 1473 | ret->nid = GNUNET_strdup (nid); |
1460 | if (NULL != nuid) | 1474 | if (NULL != nuid) |
1461 | ret->nuid = GNUNET_strdup(nuid); | 1475 | ret->nuid = GNUNET_strdup (nuid); |
1462 | } | 1476 | } |
1463 | ret->options = options; | 1477 | ret->options = options; |
1464 | /* signal start */ | 1478 | /* signal start */ |
1465 | GNUNET_FS_file_information_inspect(ret->fi, &fip_signal_start, ret); | 1479 | GNUNET_FS_file_information_inspect (ret->fi, &fip_signal_start, ret); |
1466 | ret->fi_pos = ret->fi; | 1480 | ret->fi_pos = ret->fi; |
1467 | ret->top = GNUNET_FS_make_top(h, &GNUNET_FS_publish_signal_suspend_, ret); | 1481 | ret->top = GNUNET_FS_make_top (h, &GNUNET_FS_publish_signal_suspend_, ret); |
1468 | GNUNET_FS_publish_sync_(ret); | 1482 | GNUNET_FS_publish_sync_ (ret); |
1469 | if (NULL != ret->dsh) | 1483 | if (NULL != ret->dsh) |
1470 | { | 1484 | { |
1471 | GNUNET_assert(NULL == ret->qre); | 1485 | GNUNET_assert (NULL == ret->qre); |
1472 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 1486 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1473 | _("Reserving space for %u entries and %llu bytes for publication\n"), | 1487 | _ ( |
1474 | (unsigned int)ret->reserve_entries, | 1488 | "Reserving space for %u entries and %llu bytes for publication\n"), |
1475 | (unsigned long long)ret->reserve_space); | 1489 | (unsigned int) ret->reserve_entries, |
1476 | ret->qre = | 1490 | (unsigned long long) ret->reserve_space); |
1477 | GNUNET_DATASTORE_reserve(ret->dsh, ret->reserve_space, | 1491 | ret->qre = |
1478 | ret->reserve_entries, | 1492 | GNUNET_DATASTORE_reserve (ret->dsh, ret->reserve_space, |
1479 | &finish_reserve, | 1493 | ret->reserve_entries, |
1480 | ret); | 1494 | &finish_reserve, |
1481 | } | 1495 | ret); |
1496 | } | ||
1482 | else | 1497 | else |
1483 | { | 1498 | { |
1484 | GNUNET_assert(NULL == ret->upload_task); | 1499 | GNUNET_assert (NULL == ret->upload_task); |
1485 | ret->upload_task = | 1500 | ret->upload_task = |
1486 | GNUNET_SCHEDULER_add_with_priority | 1501 | GNUNET_SCHEDULER_add_with_priority |
1487 | (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, &GNUNET_FS_publish_main_, ret); | 1502 | (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, &GNUNET_FS_publish_main_, ret); |
1488 | } | 1503 | } |
1489 | return ret; | 1504 | return ret; |
1490 | } | 1505 | } |
1491 | 1506 | ||
@@ -1505,39 +1520,39 @@ GNUNET_FS_publish_start(struct GNUNET_FS_Handle *h, | |||
1505 | * @return #GNUNET_OK to continue (always) | 1520 | * @return #GNUNET_OK to continue (always) |
1506 | */ | 1521 | */ |
1507 | static int | 1522 | static int |
1508 | fip_signal_stop(void *cls, | 1523 | fip_signal_stop (void *cls, |
1509 | struct GNUNET_FS_FileInformation *fi, | 1524 | struct GNUNET_FS_FileInformation *fi, |
1510 | uint64_t length, | 1525 | uint64_t length, |
1511 | struct GNUNET_CONTAINER_MetaData *meta, | 1526 | struct GNUNET_CONTAINER_MetaData *meta, |
1512 | struct GNUNET_FS_Uri **uri, | 1527 | struct GNUNET_FS_Uri **uri, |
1513 | struct GNUNET_FS_BlockOptions *bo, | 1528 | struct GNUNET_FS_BlockOptions *bo, |
1514 | int *do_index, void **client_info) | 1529 | int *do_index, void **client_info) |
1515 | { | 1530 | { |
1516 | struct GNUNET_FS_PublishContext *pc = cls; | 1531 | struct GNUNET_FS_PublishContext *pc = cls; |
1517 | struct GNUNET_FS_ProgressInfo pi; | 1532 | struct GNUNET_FS_ProgressInfo pi; |
1518 | uint64_t off; | 1533 | uint64_t off; |
1519 | 1534 | ||
1520 | if (GNUNET_YES == pc->skip_next_fi_callback) | 1535 | if (GNUNET_YES == pc->skip_next_fi_callback) |
1521 | { | 1536 | { |
1522 | pc->skip_next_fi_callback = GNUNET_NO; | 1537 | pc->skip_next_fi_callback = GNUNET_NO; |
1523 | return GNUNET_OK; | 1538 | return GNUNET_OK; |
1524 | } | 1539 | } |
1525 | if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory(meta)) | 1540 | if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (meta)) |
1526 | { | 1541 | { |
1527 | /* process entries in directory first */ | 1542 | /* process entries in directory first */ |
1528 | pc->skip_next_fi_callback = GNUNET_YES; | 1543 | pc->skip_next_fi_callback = GNUNET_YES; |
1529 | GNUNET_FS_file_information_inspect(fi, &fip_signal_stop, pc); | 1544 | GNUNET_FS_file_information_inspect (fi, &fip_signal_stop, pc); |
1530 | } | 1545 | } |
1531 | if (NULL != fi->serialization) | 1546 | if (NULL != fi->serialization) |
1532 | { | 1547 | { |
1533 | GNUNET_FS_remove_sync_file_(pc->h, GNUNET_FS_SYNC_PATH_FILE_INFO, | 1548 | GNUNET_FS_remove_sync_file_ (pc->h, GNUNET_FS_SYNC_PATH_FILE_INFO, |
1534 | fi->serialization); | 1549 | fi->serialization); |
1535 | GNUNET_free(fi->serialization); | 1550 | GNUNET_free (fi->serialization); |
1536 | fi->serialization = NULL; | 1551 | fi->serialization = NULL; |
1537 | } | 1552 | } |
1538 | off = (fi->chk_uri == NULL) ? 0 : length; | 1553 | off = (fi->chk_uri == NULL) ? 0 : length; |
1539 | pi.status = GNUNET_FS_STATUS_PUBLISH_STOPPED; | 1554 | pi.status = GNUNET_FS_STATUS_PUBLISH_STOPPED; |
1540 | GNUNET_break(NULL == GNUNET_FS_publish_make_status_(&pi, pc, fi, off)); | 1555 | GNUNET_break (NULL == GNUNET_FS_publish_make_status_ (&pi, pc, fi, off)); |
1541 | *client_info = NULL; | 1556 | *client_info = NULL; |
1542 | return GNUNET_OK; | 1557 | return GNUNET_OK; |
1543 | } | 1558 | } |
@@ -1552,56 +1567,57 @@ fip_signal_stop(void *cls, | |||
1552 | * @param pc context for the upload to stop | 1567 | * @param pc context for the upload to stop |
1553 | */ | 1568 | */ |
1554 | void | 1569 | void |
1555 | GNUNET_FS_publish_stop(struct GNUNET_FS_PublishContext *pc) | 1570 | GNUNET_FS_publish_stop (struct GNUNET_FS_PublishContext *pc) |
1556 | { | 1571 | { |
1557 | struct GNUNET_FS_ProgressInfo pi; | 1572 | struct GNUNET_FS_ProgressInfo pi; |
1558 | uint64_t off; | 1573 | uint64_t off; |
1559 | 1574 | ||
1560 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1575 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1561 | "Publish stop called\n"); | 1576 | "Publish stop called\n"); |
1562 | GNUNET_FS_end_top(pc->h, pc->top); | 1577 | GNUNET_FS_end_top (pc->h, pc->top); |
1563 | if (NULL != pc->ksk_pc) | 1578 | if (NULL != pc->ksk_pc) |
1564 | { | 1579 | { |
1565 | GNUNET_FS_publish_ksk_cancel(pc->ksk_pc); | 1580 | GNUNET_FS_publish_ksk_cancel (pc->ksk_pc); |
1566 | pc->ksk_pc = NULL; | 1581 | pc->ksk_pc = NULL; |
1567 | } | 1582 | } |
1568 | if (NULL != pc->sks_pc) | 1583 | if (NULL != pc->sks_pc) |
1569 | { | 1584 | { |
1570 | GNUNET_FS_publish_sks_cancel(pc->sks_pc); | 1585 | GNUNET_FS_publish_sks_cancel (pc->sks_pc); |
1571 | pc->sks_pc = NULL; | 1586 | pc->sks_pc = NULL; |
1572 | } | 1587 | } |
1573 | if (NULL != pc->upload_task) | 1588 | if (NULL != pc->upload_task) |
1574 | { | 1589 | { |
1575 | GNUNET_SCHEDULER_cancel(pc->upload_task); | 1590 | GNUNET_SCHEDULER_cancel (pc->upload_task); |
1576 | pc->upload_task = NULL; | 1591 | pc->upload_task = NULL; |
1577 | } | 1592 | } |
1578 | pc->skip_next_fi_callback = GNUNET_YES; | 1593 | pc->skip_next_fi_callback = GNUNET_YES; |
1579 | GNUNET_FS_file_information_inspect(pc->fi, &fip_signal_stop, pc); | 1594 | GNUNET_FS_file_information_inspect (pc->fi, &fip_signal_stop, pc); |
1580 | 1595 | ||
1581 | if (NULL != pc->fi->serialization) | 1596 | if (NULL != pc->fi->serialization) |
1582 | { | 1597 | { |
1583 | GNUNET_FS_remove_sync_file_(pc->h, GNUNET_FS_SYNC_PATH_FILE_INFO, | 1598 | GNUNET_FS_remove_sync_file_ (pc->h, GNUNET_FS_SYNC_PATH_FILE_INFO, |
1584 | pc->fi->serialization); | 1599 | pc->fi->serialization); |
1585 | GNUNET_free(pc->fi->serialization); | 1600 | GNUNET_free (pc->fi->serialization); |
1586 | pc->fi->serialization = NULL; | 1601 | pc->fi->serialization = NULL; |
1587 | } | 1602 | } |
1588 | off = (NULL == pc->fi->chk_uri) ? 0 : GNUNET_ntohll(pc->fi->chk_uri->data.chk.file_length); | 1603 | off = (NULL == pc->fi->chk_uri) ? 0 : GNUNET_ntohll ( |
1604 | pc->fi->chk_uri->data.chk.file_length); | ||
1589 | 1605 | ||
1590 | if (NULL != pc->serialization) | 1606 | if (NULL != pc->serialization) |
1591 | { | 1607 | { |
1592 | GNUNET_FS_remove_sync_file_(pc->h, GNUNET_FS_SYNC_PATH_MASTER_PUBLISH, | 1608 | GNUNET_FS_remove_sync_file_ (pc->h, GNUNET_FS_SYNC_PATH_MASTER_PUBLISH, |
1593 | pc->serialization); | 1609 | pc->serialization); |
1594 | GNUNET_free(pc->serialization); | 1610 | GNUNET_free (pc->serialization); |
1595 | pc->serialization = NULL; | 1611 | pc->serialization = NULL; |
1596 | } | 1612 | } |
1597 | if (NULL != pc->qre) | 1613 | if (NULL != pc->qre) |
1598 | { | 1614 | { |
1599 | GNUNET_DATASTORE_cancel(pc->qre); | 1615 | GNUNET_DATASTORE_cancel (pc->qre); |
1600 | pc->qre = NULL; | 1616 | pc->qre = NULL; |
1601 | } | 1617 | } |
1602 | pi.status = GNUNET_FS_STATUS_PUBLISH_STOPPED; | 1618 | pi.status = GNUNET_FS_STATUS_PUBLISH_STOPPED; |
1603 | GNUNET_break(NULL == GNUNET_FS_publish_make_status_(&pi, pc, pc->fi, off)); | 1619 | GNUNET_break (NULL == GNUNET_FS_publish_make_status_ (&pi, pc, pc->fi, off)); |
1604 | publish_cleanup(pc); | 1620 | publish_cleanup (pc); |
1605 | } | 1621 | } |
1606 | 1622 | ||
1607 | 1623 | ||