diff options
author | Christian Grothoff <christian@grothoff.org> | 2011-08-15 21:46:35 +0000 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2011-08-15 21:46:35 +0000 |
commit | 502af2167f7c218366666ca4944bd7cc54b5b19a (patch) | |
tree | a91fec5cc9769d260640bd91c6633cb9cf395524 /src/fs/gnunet-search.c | |
parent | 03af5a603b7cc53432249d5854cd412aa90dde0d (diff) | |
download | gnunet-502af2167f7c218366666ca4944bd7cc54b5b19a.tar.gz gnunet-502af2167f7c218366666ca4944bd7cc54b5b19a.zip |
indentation
Diffstat (limited to 'src/fs/gnunet-search.c')
-rw-r--r-- | src/fs/gnunet-search.c | 269 |
1 files changed, 119 insertions, 150 deletions
diff --git a/src/fs/gnunet-search.c b/src/fs/gnunet-search.c index c4c8b2a46..8a3e2ed6a 100644 --- a/src/fs/gnunet-search.c +++ b/src/fs/gnunet-search.c | |||
@@ -68,32 +68,28 @@ static int local_only; | |||
68 | * @param data actual meta-data found | 68 | * @param data actual meta-data found |
69 | * @param data_size number of bytes in data | 69 | * @param data_size number of bytes in data |
70 | * @return 0 to continue extracting, 1 to abort | 70 | * @return 0 to continue extracting, 1 to abort |
71 | */ | 71 | */ |
72 | static int | 72 | static int |
73 | item_printer (void *cls, | 73 | item_printer (void *cls, |
74 | const char *plugin_name, | 74 | const char *plugin_name, |
75 | enum EXTRACTOR_MetaType type, | 75 | enum EXTRACTOR_MetaType type, |
76 | enum EXTRACTOR_MetaFormat format, | 76 | enum EXTRACTOR_MetaFormat format, |
77 | const char *data_mime_type, | 77 | const char *data_mime_type, const char *data, size_t data_size) |
78 | const char *data, | ||
79 | size_t data_size) | ||
80 | { | 78 | { |
81 | if ( (format != EXTRACTOR_METAFORMAT_UTF8) && | 79 | if ((format != EXTRACTOR_METAFORMAT_UTF8) && |
82 | (format != EXTRACTOR_METAFORMAT_C_STRING) ) | 80 | (format != EXTRACTOR_METAFORMAT_C_STRING)) |
83 | return 0; | 81 | return 0; |
84 | if (type == EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME) | 82 | if (type == EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME) |
85 | return 0; | 83 | return 0; |
86 | printf ("\t%20s: %s\n", | 84 | printf ("\t%20s: %s\n", |
87 | dgettext (LIBEXTRACTOR_GETTEXT_DOMAIN, | 85 | dgettext (LIBEXTRACTOR_GETTEXT_DOMAIN, |
88 | EXTRACTOR_metatype_to_string (type)), | 86 | EXTRACTOR_metatype_to_string (type)), data); |
89 | data); | ||
90 | return 0; | 87 | return 0; |
91 | } | 88 | } |
92 | 89 | ||
93 | 90 | ||
94 | static void | 91 | static void |
95 | clean_task (void *cls, | 92 | clean_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
96 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
97 | { | 93 | { |
98 | size_t dsize; | 94 | size_t dsize; |
99 | void *ddata; | 95 | void *ddata; |
@@ -102,25 +98,23 @@ clean_task (void *cls, | |||
102 | ctx = NULL; | 98 | ctx = NULL; |
103 | if (output_filename == NULL) | 99 | if (output_filename == NULL) |
104 | return; | 100 | return; |
105 | if (GNUNET_OK != | 101 | if (GNUNET_OK != GNUNET_FS_directory_builder_finish (db, &dsize, &ddata)) |
106 | GNUNET_FS_directory_builder_finish (db, | 102 | { |
107 | &dsize, | 103 | GNUNET_break (0); |
108 | &ddata)) | 104 | GNUNET_free (output_filename); |
109 | { | 105 | return; |
110 | GNUNET_break (0); | 106 | } |
111 | GNUNET_free (output_filename); | 107 | if (dsize != |
112 | return; | ||
113 | } | ||
114 | if (dsize != | ||
115 | GNUNET_DISK_fn_write (output_filename, | 108 | GNUNET_DISK_fn_write (output_filename, |
116 | ddata, | 109 | ddata, |
117 | dsize, | 110 | dsize, |
118 | GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE)) | 111 | GNUNET_DISK_PERM_USER_READ | |
119 | { | 112 | GNUNET_DISK_PERM_USER_WRITE)) |
120 | fprintf (stderr, | 113 | { |
121 | _("Failed to write directory with search results to `%s'\n"), | 114 | fprintf (stderr, |
122 | output_filename); | 115 | _("Failed to write directory with search results to `%s'\n"), |
123 | } | 116 | output_filename); |
117 | } | ||
124 | GNUNET_free_non_null (ddata); | 118 | GNUNET_free_non_null (ddata); |
125 | GNUNET_free (output_filename); | 119 | GNUNET_free (output_filename); |
126 | } | 120 | } |
@@ -140,8 +134,7 @@ clean_task (void *cls, | |||
140 | * field in the GNUNET_FS_ProgressInfo struct. | 134 | * field in the GNUNET_FS_ProgressInfo struct. |
141 | */ | 135 | */ |
142 | static void * | 136 | static void * |
143 | progress_cb (void *cls, | 137 | progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info) |
144 | const struct GNUNET_FS_ProgressInfo *info) | ||
145 | { | 138 | { |
146 | static unsigned int cnt; | 139 | static unsigned int cnt; |
147 | char *uri; | 140 | char *uri; |
@@ -149,78 +142,72 @@ progress_cb (void *cls, | |||
149 | char *filename; | 142 | char *filename; |
150 | 143 | ||
151 | switch (info->status) | 144 | switch (info->status) |
145 | { | ||
146 | case GNUNET_FS_STATUS_SEARCH_START: | ||
147 | break; | ||
148 | case GNUNET_FS_STATUS_SEARCH_RESULT: | ||
149 | if (db != NULL) | ||
150 | GNUNET_FS_directory_builder_add (db, | ||
151 | info->value.search.specifics.result.uri, | ||
152 | info->value.search.specifics.result.meta, | ||
153 | NULL); | ||
154 | uri = GNUNET_FS_uri_to_string (info->value.search.specifics.result.uri); | ||
155 | printf ("#%u:\n", cnt++); | ||
156 | filename = | ||
157 | GNUNET_CONTAINER_meta_data_get_by_type (info->value.search. | ||
158 | specifics.result.meta, | ||
159 | EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME); | ||
160 | if (filename != NULL) | ||
152 | { | 161 | { |
153 | case GNUNET_FS_STATUS_SEARCH_START: | 162 | while (NULL != (dotdot = strstr (filename, ".."))) |
154 | break; | 163 | dotdot[0] = dotdot[1] = '_'; |
155 | case GNUNET_FS_STATUS_SEARCH_RESULT: | 164 | printf ("gnunet-download -o \"%s\" %s\n", filename, uri); |
156 | if (db != NULL) | ||
157 | GNUNET_FS_directory_builder_add (db, | ||
158 | info->value.search.specifics.result.uri, | ||
159 | info->value.search.specifics.result.meta, | ||
160 | NULL); | ||
161 | uri = GNUNET_FS_uri_to_string (info->value.search.specifics.result.uri); | ||
162 | printf ("#%u:\n", cnt++); | ||
163 | filename = | ||
164 | GNUNET_CONTAINER_meta_data_get_by_type (info->value.search.specifics.result.meta, | ||
165 | EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME); | ||
166 | if (filename != NULL) | ||
167 | { | ||
168 | while (NULL != (dotdot = strstr (filename, ".."))) | ||
169 | dotdot[0] = dotdot[1] = '_'; | ||
170 | printf ("gnunet-download -o \"%s\" %s\n", | ||
171 | filename, | ||
172 | uri); | ||
173 | } | ||
174 | else | ||
175 | printf ("gnunet-download %s\n", uri); | ||
176 | if (verbose) | ||
177 | GNUNET_CONTAINER_meta_data_iterate (info->value.search.specifics.result.meta, | ||
178 | &item_printer, | ||
179 | NULL); | ||
180 | printf ("\n"); | ||
181 | fflush(stdout); | ||
182 | GNUNET_free_non_null (filename); | ||
183 | GNUNET_free (uri); | ||
184 | results++; | ||
185 | if ( (results_limit > 0) && | ||
186 | (results >= results_limit) ) | ||
187 | GNUNET_SCHEDULER_shutdown (); | ||
188 | break; | ||
189 | case GNUNET_FS_STATUS_SEARCH_UPDATE: | ||
190 | break; | ||
191 | case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED: | ||
192 | /* ignore */ | ||
193 | break; | ||
194 | case GNUNET_FS_STATUS_SEARCH_ERROR: | ||
195 | fprintf (stderr, | ||
196 | _("Error searching: %s.\n"), | ||
197 | info->value.search.specifics.error.message); | ||
198 | GNUNET_SCHEDULER_shutdown (); | ||
199 | break; | ||
200 | case GNUNET_FS_STATUS_SEARCH_STOPPED: | ||
201 | GNUNET_SCHEDULER_add_continuation (&clean_task, | ||
202 | NULL, | ||
203 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | ||
204 | break; | ||
205 | default: | ||
206 | fprintf (stderr, | ||
207 | _("Unexpected status: %d\n"), | ||
208 | info->status); | ||
209 | break; | ||
210 | } | 165 | } |
166 | else | ||
167 | printf ("gnunet-download %s\n", uri); | ||
168 | if (verbose) | ||
169 | GNUNET_CONTAINER_meta_data_iterate (info->value.search.specifics. | ||
170 | result.meta, &item_printer, NULL); | ||
171 | printf ("\n"); | ||
172 | fflush (stdout); | ||
173 | GNUNET_free_non_null (filename); | ||
174 | GNUNET_free (uri); | ||
175 | results++; | ||
176 | if ((results_limit > 0) && (results >= results_limit)) | ||
177 | GNUNET_SCHEDULER_shutdown (); | ||
178 | break; | ||
179 | case GNUNET_FS_STATUS_SEARCH_UPDATE: | ||
180 | break; | ||
181 | case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED: | ||
182 | /* ignore */ | ||
183 | break; | ||
184 | case GNUNET_FS_STATUS_SEARCH_ERROR: | ||
185 | fprintf (stderr, | ||
186 | _("Error searching: %s.\n"), | ||
187 | info->value.search.specifics.error.message); | ||
188 | GNUNET_SCHEDULER_shutdown (); | ||
189 | break; | ||
190 | case GNUNET_FS_STATUS_SEARCH_STOPPED: | ||
191 | GNUNET_SCHEDULER_add_continuation (&clean_task, | ||
192 | NULL, | ||
193 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | ||
194 | break; | ||
195 | default: | ||
196 | fprintf (stderr, _("Unexpected status: %d\n"), info->status); | ||
197 | break; | ||
198 | } | ||
211 | return NULL; | 199 | return NULL; |
212 | } | 200 | } |
213 | 201 | ||
214 | 202 | ||
215 | static void | 203 | static void |
216 | shutdown_task (void *cls, | 204 | shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
217 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
218 | { | 205 | { |
219 | if (sc != NULL) | 206 | if (sc != NULL) |
220 | { | 207 | { |
221 | GNUNET_FS_search_stop (sc); | 208 | GNUNET_FS_search_stop (sc); |
222 | sc = NULL; | 209 | sc = NULL; |
223 | } | 210 | } |
224 | } | 211 | } |
225 | 212 | ||
226 | 213 | ||
@@ -235,8 +222,7 @@ shutdown_task (void *cls, | |||
235 | static void | 222 | static void |
236 | run (void *cls, | 223 | run (void *cls, |
237 | char *const *args, | 224 | char *const *args, |
238 | const char *cfgfile, | 225 | const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c) |
239 | const struct GNUNET_CONFIGURATION_Handle *c) | ||
240 | { | 226 | { |
241 | struct GNUNET_FS_Uri *uri; | 227 | struct GNUNET_FS_Uri *uri; |
242 | unsigned int argc; | 228 | unsigned int argc; |
@@ -246,63 +232,49 @@ run (void *cls, | |||
246 | argc = 0; | 232 | argc = 0; |
247 | while (NULL != args[argc]) | 233 | while (NULL != args[argc]) |
248 | argc++; | 234 | argc++; |
249 | uri = GNUNET_FS_uri_ksk_create_from_args (argc, | 235 | uri = GNUNET_FS_uri_ksk_create_from_args (argc, (const char **) args); |
250 | (const char **) args); | ||
251 | if (NULL == uri) | 236 | if (NULL == uri) |
252 | { | 237 | { |
253 | fprintf (stderr, | 238 | fprintf (stderr, _("Could not create keyword URI from arguments.\n")); |
254 | _("Could not create keyword URI from arguments.\n")); | 239 | ret = 1; |
255 | ret = 1; | 240 | return; |
256 | return; | 241 | } |
257 | } | ||
258 | cfg = c; | 242 | cfg = c; |
259 | ctx = GNUNET_FS_start (cfg, | 243 | ctx = GNUNET_FS_start (cfg, |
260 | "gnunet-search", | 244 | "gnunet-search", |
261 | &progress_cb, | 245 | &progress_cb, |
262 | NULL, | 246 | NULL, GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END); |
263 | GNUNET_FS_FLAGS_NONE, | ||
264 | GNUNET_FS_OPTIONS_END); | ||
265 | if (NULL == ctx) | 247 | if (NULL == ctx) |
266 | { | 248 | { |
267 | fprintf (stderr, | 249 | fprintf (stderr, _("Could not initialize `%s' subsystem.\n"), "FS"); |
268 | _("Could not initialize `%s' subsystem.\n"), | 250 | GNUNET_FS_uri_destroy (uri); |
269 | "FS"); | 251 | ret = 1; |
270 | GNUNET_FS_uri_destroy (uri); | 252 | return; |
271 | ret = 1; | 253 | } |
272 | return; | ||
273 | } | ||
274 | if (output_filename != NULL) | 254 | if (output_filename != NULL) |
275 | db = GNUNET_FS_directory_builder_create (NULL); | 255 | db = GNUNET_FS_directory_builder_create (NULL); |
276 | options = GNUNET_FS_SEARCH_OPTION_NONE; | 256 | options = GNUNET_FS_SEARCH_OPTION_NONE; |
277 | if (local_only) | 257 | if (local_only) |
278 | options |= GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY; | 258 | options |= GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY; |
279 | sc = GNUNET_FS_search_start (ctx, | 259 | sc = GNUNET_FS_search_start (ctx, uri, anonymity, options, NULL); |
280 | uri, | ||
281 | anonymity, | ||
282 | options, | ||
283 | NULL); | ||
284 | GNUNET_FS_uri_destroy (uri); | 260 | GNUNET_FS_uri_destroy (uri); |
285 | if (NULL == sc) | 261 | if (NULL == sc) |
286 | { | 262 | { |
287 | fprintf (stderr, | 263 | fprintf (stderr, _("Could not start searching.\n")); |
288 | _("Could not start searching.\n")); | 264 | GNUNET_FS_stop (ctx); |
289 | GNUNET_FS_stop (ctx); | 265 | ret = 1; |
290 | ret = 1; | 266 | return; |
291 | return; | 267 | } |
292 | } | ||
293 | if (timeout != 0) | 268 | if (timeout != 0) |
294 | { | 269 | { |
295 | delay.rel_value = timeout; | 270 | delay.rel_value = timeout; |
296 | GNUNET_SCHEDULER_add_delayed (delay, | 271 | GNUNET_SCHEDULER_add_delayed (delay, &shutdown_task, NULL); |
297 | &shutdown_task, | 272 | } |
298 | NULL); | ||
299 | } | ||
300 | else | 273 | else |
301 | { | 274 | { |
302 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, | 275 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, |
303 | &shutdown_task, | 276 | &shutdown_task, NULL); |
304 | NULL); | 277 | } |
305 | } | ||
306 | } | 278 | } |
307 | 279 | ||
308 | 280 | ||
@@ -324,12 +296,10 @@ main (int argc, char *const *argv) | |||
324 | gettext_noop ("only search the local peer (no P2P network search)"), | 296 | gettext_noop ("only search the local peer (no P2P network search)"), |
325 | 0, &GNUNET_GETOPT_set_one, &local_only}, | 297 | 0, &GNUNET_GETOPT_set_one, &local_only}, |
326 | {'o', "output", "PREFIX", | 298 | {'o', "output", "PREFIX", |
327 | gettext_noop | 299 | gettext_noop ("write search results to file starting with PREFIX"), |
328 | ("write search results to file starting with PREFIX"), | 300 | 1, &GNUNET_GETOPT_set_string, &output_filename}, |
329 | 1, &GNUNET_GETOPT_set_string, &output_filename}, | ||
330 | {'t', "timeout", "VALUE", | 301 | {'t', "timeout", "VALUE", |
331 | gettext_noop | 302 | gettext_noop ("automatically terminate search after VALUE ms"), |
332 | ("automatically terminate search after VALUE ms"), | ||
333 | 1, &GNUNET_GETOPT_set_ulong, &timeout}, | 303 | 1, &GNUNET_GETOPT_set_ulong, &timeout}, |
334 | {'V', "verbose", NULL, | 304 | {'V', "verbose", NULL, |
335 | gettext_noop ("be verbose (print progress information)"), | 305 | gettext_noop ("be verbose (print progress information)"), |
@@ -339,7 +309,7 @@ main (int argc, char *const *argv) | |||
339 | ("automatically terminate search after VALUE results are found"), | 309 | ("automatically terminate search after VALUE results are found"), |
340 | 1, &GNUNET_GETOPT_set_ulong, &results_limit}, | 310 | 1, &GNUNET_GETOPT_set_ulong, &results_limit}, |
341 | GNUNET_GETOPT_OPTION_END | 311 | GNUNET_GETOPT_OPTION_END |
342 | }; | 312 | }; |
343 | return (GNUNET_OK == | 313 | return (GNUNET_OK == |
344 | GNUNET_PROGRAM_run (argc, | 314 | GNUNET_PROGRAM_run (argc, |
345 | argv, | 315 | argv, |
@@ -350,4 +320,3 @@ main (int argc, char *const *argv) | |||
350 | } | 320 | } |
351 | 321 | ||
352 | /* end of gnunet-search.c */ | 322 | /* end of gnunet-search.c */ |
353 | |||