aboutsummaryrefslogtreecommitdiff
path: root/src/fs/test_fs_search.c
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2019-10-05 15:09:28 +0200
committerChristian Grothoff <christian@grothoff.org>2019-10-05 15:09:28 +0200
commitc4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch)
treecac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/fs/test_fs_search.c
parentfbb71d527c7d6babf269a8fefce1db291b9f7068 (diff)
downloadgnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz
gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/fs/test_fs_search.c')
-rw-r--r--src/fs/test_fs_search.c266
1 files changed, 133 insertions, 133 deletions
diff --git a/src/fs/test_fs_search.c b/src/fs/test_fs_search.c
index 7906a4163..16f8ecbda 100644
--- a/src/fs/test_fs_search.c
+++ b/src/fs/test_fs_search.c
@@ -36,12 +36,12 @@
36/** 36/**
37 * How long until we give up on transmitting the message? 37 * How long until we give up on transmitting the message?
38 */ 38 */
39#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60) 39#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
40 40
41/** 41/**
42 * How long should our test-content live? 42 * How long should our test-content live?
43 */ 43 */
44#define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15) 44#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
45 45
46 46
47static struct GNUNET_TIME_Absolute start; 47static struct GNUNET_TIME_Absolute start;
@@ -52,60 +52,60 @@ static struct GNUNET_FS_SearchContext *search;
52 52
53static struct GNUNET_FS_PublishContext *publish; 53static struct GNUNET_FS_PublishContext *publish;
54 54
55static struct GNUNET_SCHEDULER_Task * timeout_task; 55static struct GNUNET_SCHEDULER_Task *timeout_task;
56 56
57static int err; 57static int err;
58 58
59 59
60static void 60static void
61abort_publish_task(void *cls) 61abort_publish_task (void *cls)
62{ 62{
63 if (NULL != publish) 63 if (NULL != publish)
64 { 64 {
65 GNUNET_FS_publish_stop(publish); 65 GNUNET_FS_publish_stop (publish);
66 publish = NULL; 66 publish = NULL;
67 } 67 }
68 if (NULL != timeout_task) 68 if (NULL != timeout_task)
69 { 69 {
70 GNUNET_SCHEDULER_cancel(timeout_task); 70 GNUNET_SCHEDULER_cancel (timeout_task);
71 timeout_task = NULL; 71 timeout_task = NULL;
72 } 72 }
73} 73}
74 74
75 75
76static void 76static void
77abort_error(void *cls) 77abort_error (void *cls)
78{ 78{
79 fprintf(stderr, 79 fprintf (stderr,
80 "Timeout\n"); 80 "Timeout\n");
81 timeout_task = NULL; 81 timeout_task = NULL;
82 if (NULL != search) 82 if (NULL != search)
83 { 83 {
84 GNUNET_FS_search_stop(search); 84 GNUNET_FS_search_stop (search);
85 search = NULL; 85 search = NULL;
86 } 86 }
87 if (NULL != publish) 87 if (NULL != publish)
88 { 88 {
89 GNUNET_FS_publish_stop(publish); 89 GNUNET_FS_publish_stop (publish);
90 publish = NULL; 90 publish = NULL;
91 } 91 }
92 err = 1; 92 err = 1;
93} 93}
94 94
95 95
96static void 96static void
97abort_search_task(void *cls) 97abort_search_task (void *cls)
98{ 98{
99 if (NULL != search) 99 if (NULL != search)
100 { 100 {
101 GNUNET_FS_search_stop(search); 101 GNUNET_FS_search_stop (search);
102 search = NULL; 102 search = NULL;
103 } 103 }
104} 104}
105 105
106 106
107static void * 107static void *
108progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event) 108progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
109{ 109{
110 const char *keywords[] = { 110 const char *keywords[] = {
111 "down_foo" 111 "down_foo"
@@ -113,91 +113,91 @@ progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
113 struct GNUNET_FS_Uri *kuri; 113 struct GNUNET_FS_Uri *kuri;
114 114
115 switch (event->status) 115 switch (event->status)
116 { 116 {
117 case GNUNET_FS_STATUS_PUBLISH_PROGRESS: 117 case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
118 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 118 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
119 "Publish is progressing (%llu/%llu at level %u off %llu)...\n", 119 "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
120 (unsigned long long)event->value.publish.completed, 120 (unsigned long long) event->value.publish.completed,
121 (unsigned long long)event->value.publish.size, 121 (unsigned long long) event->value.publish.size,
122 event->value.publish.specifics.progress.depth, 122 event->value.publish.specifics.progress.depth,
123 (unsigned long long)event->value.publish.specifics. 123 (unsigned long long) event->value.publish.specifics.
124 progress.offset); 124 progress.offset);
125 break; 125 break;
126 126
127 case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY: 127 case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
128 break; 128 break;
129 129
130 case GNUNET_FS_STATUS_PUBLISH_COMPLETED: 130 case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
131 kuri = GNUNET_FS_uri_ksk_create_from_args(1, keywords); 131 kuri = GNUNET_FS_uri_ksk_create_from_args (1, keywords);
132 start = GNUNET_TIME_absolute_get(); 132 start = GNUNET_TIME_absolute_get ();
133 search = 133 search =
134 GNUNET_FS_search_start(fs, kuri, 1, GNUNET_FS_SEARCH_OPTION_NONE, 134 GNUNET_FS_search_start (fs, kuri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
135 "search"); 135 "search");
136 GNUNET_FS_uri_destroy(kuri); 136 GNUNET_FS_uri_destroy (kuri);
137 GNUNET_assert(search != NULL); 137 GNUNET_assert (search != NULL);
138 break; 138 break;
139 139
140 case GNUNET_FS_STATUS_SEARCH_RESULT: 140 case GNUNET_FS_STATUS_SEARCH_RESULT:
141 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 141 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
142 "Search complete.\n"); 142 "Search complete.\n");
143 GNUNET_SCHEDULER_add_now(&abort_search_task, NULL); 143 GNUNET_SCHEDULER_add_now (&abort_search_task, NULL);
144 break; 144 break;
145 145
146 case GNUNET_FS_STATUS_PUBLISH_ERROR: 146 case GNUNET_FS_STATUS_PUBLISH_ERROR:
147 fprintf(stderr, "Error publishing file: %s\n", 147 fprintf (stderr, "Error publishing file: %s\n",
148 event->value.publish.specifics.error.message); 148 event->value.publish.specifics.error.message);
149 GNUNET_break(0); 149 GNUNET_break (0);
150 GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL); 150 GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
151 break; 151 break;
152 152
153 case GNUNET_FS_STATUS_SEARCH_ERROR: 153 case GNUNET_FS_STATUS_SEARCH_ERROR:
154 fprintf(stderr, "Error searching file: %s\n", 154 fprintf (stderr, "Error searching file: %s\n",
155 event->value.search.specifics.error.message); 155 event->value.search.specifics.error.message);
156 GNUNET_SCHEDULER_add_now(&abort_search_task, NULL); 156 GNUNET_SCHEDULER_add_now (&abort_search_task, NULL);
157 break; 157 break;
158 158
159 case GNUNET_FS_STATUS_PUBLISH_START: 159 case GNUNET_FS_STATUS_PUBLISH_START:
160 GNUNET_assert(0 == strcmp("publish-context", event->value.publish.cctx)); 160 GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));
161 GNUNET_assert(NULL == event->value.publish.pctx); 161 GNUNET_assert (NULL == event->value.publish.pctx);
162 GNUNET_assert(FILESIZE == event->value.publish.size); 162 GNUNET_assert (FILESIZE == event->value.publish.size);
163 GNUNET_assert(0 == event->value.publish.completed); 163 GNUNET_assert (0 == event->value.publish.completed);
164 GNUNET_assert(1 == event->value.publish.anonymity); 164 GNUNET_assert (1 == event->value.publish.anonymity);
165 break; 165 break;
166 166
167 case GNUNET_FS_STATUS_PUBLISH_STOPPED: 167 case GNUNET_FS_STATUS_PUBLISH_STOPPED:
168 GNUNET_assert(publish == event->value.publish.pc); 168 GNUNET_assert (publish == event->value.publish.pc);
169 GNUNET_assert(FILESIZE == event->value.publish.size); 169 GNUNET_assert (FILESIZE == event->value.publish.size);
170 GNUNET_assert(1 == event->value.publish.anonymity); 170 GNUNET_assert (1 == event->value.publish.anonymity);
171 GNUNET_FS_stop(fs); 171 GNUNET_FS_stop (fs);
172 fs = NULL; 172 fs = NULL;
173 break; 173 break;
174 174
175 case GNUNET_FS_STATUS_SEARCH_START: 175 case GNUNET_FS_STATUS_SEARCH_START:
176 GNUNET_assert(search == NULL); 176 GNUNET_assert (search == NULL);
177 GNUNET_assert(0 == strcmp("search", event->value.search.cctx)); 177 GNUNET_assert (0 == strcmp ("search", event->value.search.cctx));
178 GNUNET_assert(1 == event->value.search.anonymity); 178 GNUNET_assert (1 == event->value.search.anonymity);
179 break; 179 break;
180 180
181 case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED: 181 case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
182 break; 182 break;
183 183
184 case GNUNET_FS_STATUS_SEARCH_STOPPED: 184 case GNUNET_FS_STATUS_SEARCH_STOPPED:
185 GNUNET_assert(search == event->value.search.sc); 185 GNUNET_assert (search == event->value.search.sc);
186 GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL); 186 GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
187 break; 187 break;
188 188
189 default: 189 default:
190 fprintf(stderr, "Unexpected event: %d\n", event->status); 190 fprintf (stderr, "Unexpected event: %d\n", event->status);
191 break; 191 break;
192 } 192 }
193 return NULL; 193 return NULL;
194} 194}
195 195
196 196
197static void 197static void
198run(void *cls, 198run (void *cls,
199 const struct GNUNET_CONFIGURATION_Handle *cfg, 199 const struct GNUNET_CONFIGURATION_Handle *cfg,
200 struct GNUNET_TESTING_Peer *peer) 200 struct GNUNET_TESTING_Peer *peer)
201{ 201{
202 const char *keywords[] = { 202 const char *keywords[] = {
203 "down_foo", 203 "down_foo",
@@ -210,40 +210,40 @@ run(void *cls,
210 struct GNUNET_FS_FileInformation *fi; 210 struct GNUNET_FS_FileInformation *fi;
211 size_t i; 211 size_t i;
212 212
213 fs = GNUNET_FS_start(cfg, "test-fs-search", &progress_cb, NULL, 213 fs = GNUNET_FS_start (cfg, "test-fs-search", &progress_cb, NULL,
214 GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END); 214 GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
215 GNUNET_assert(NULL != fs); 215 GNUNET_assert (NULL != fs);
216 buf = GNUNET_malloc(FILESIZE); 216 buf = GNUNET_malloc (FILESIZE);
217 for (i = 0; i < FILESIZE; i++) 217 for (i = 0; i < FILESIZE; i++)
218 buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256); 218 buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
219 meta = GNUNET_CONTAINER_meta_data_create(); 219 meta = GNUNET_CONTAINER_meta_data_create ();
220 kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords); 220 kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
221 bo.content_priority = 42; 221 bo.content_priority = 42;
222 bo.anonymity_level = 1; 222 bo.anonymity_level = 1;
223 bo.replication_level = 0; 223 bo.replication_level = 0;
224 bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME); 224 bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
225 fi = GNUNET_FS_file_information_create_from_data(fs, "publish-context", 225 fi = GNUNET_FS_file_information_create_from_data (fs, "publish-context",
226 FILESIZE, buf, kuri, meta, 226 FILESIZE, buf, kuri, meta,
227 GNUNET_NO, &bo); 227 GNUNET_NO, &bo);
228 GNUNET_FS_uri_destroy(kuri); 228 GNUNET_FS_uri_destroy (kuri);
229 GNUNET_CONTAINER_meta_data_destroy(meta); 229 GNUNET_CONTAINER_meta_data_destroy (meta);
230 GNUNET_assert(NULL != fi); 230 GNUNET_assert (NULL != fi);
231 start = GNUNET_TIME_absolute_get(); 231 start = GNUNET_TIME_absolute_get ();
232 publish = 232 publish =
233 GNUNET_FS_publish_start(fs, fi, NULL, NULL, NULL, 233 GNUNET_FS_publish_start (fs, fi, NULL, NULL, NULL,
234 GNUNET_FS_PUBLISH_OPTION_NONE); 234 GNUNET_FS_PUBLISH_OPTION_NONE);
235 GNUNET_assert(publish != NULL); 235 GNUNET_assert (publish != NULL);
236 timeout_task = GNUNET_SCHEDULER_add_delayed(LIFETIME, 236 timeout_task = GNUNET_SCHEDULER_add_delayed (LIFETIME,
237 &abort_error, NULL); 237 &abort_error, NULL);
238} 238}
239 239
240 240
241int 241int
242main(int argc, char *argv[]) 242main (int argc, char *argv[])
243{ 243{
244 if (0 != GNUNET_TESTING_peer_run("test-fs-search", 244 if (0 != GNUNET_TESTING_peer_run ("test-fs-search",
245 "test_fs_search_data.conf", 245 "test_fs_search_data.conf",
246 &run, NULL)) 246 &run, NULL))
247 return 1; 247 return 1;
248 return err; 248 return err;
249} 249}