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/datacache/plugin_datacache_sqlite.c | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/datacache/plugin_datacache_sqlite.c')
-rw-r--r-- | src/datacache/plugin_datacache_sqlite.c | 847 |
1 files changed, 425 insertions, 422 deletions
diff --git a/src/datacache/plugin_datacache_sqlite.c b/src/datacache/plugin_datacache_sqlite.c index b173af2f3..55a8a7fae 100644 --- a/src/datacache/plugin_datacache_sqlite.c +++ b/src/datacache/plugin_datacache_sqlite.c | |||
@@ -29,10 +29,10 @@ | |||
29 | #include "gnunet_sq_lib.h" | 29 | #include "gnunet_sq_lib.h" |
30 | #include <sqlite3.h> | 30 | #include <sqlite3.h> |
31 | 31 | ||
32 | #define LOG(kind, ...) GNUNET_log_from(kind, "datacache-sqlite", __VA_ARGS__) | 32 | #define LOG(kind, ...) GNUNET_log_from (kind, "datacache-sqlite", __VA_ARGS__) |
33 | 33 | ||
34 | #define LOG_STRERROR_FILE(kind, op, fn) \ | 34 | #define LOG_STRERROR_FILE(kind, op, fn) \ |
35 | GNUNET_log_from_strerror_file(kind, "datacache-sqlite", op, fn) | 35 | GNUNET_log_from_strerror_file (kind, "datacache-sqlite", op, fn) |
36 | 36 | ||
37 | 37 | ||
38 | /** | 38 | /** |
@@ -44,7 +44,8 @@ | |||
44 | /** | 44 | /** |
45 | * Context for all functions in this plugin. | 45 | * Context for all functions in this plugin. |
46 | */ | 46 | */ |
47 | struct Plugin { | 47 | struct Plugin |
48 | { | ||
48 | /** | 49 | /** |
49 | * Our execution environment. | 50 | * Our execution environment. |
50 | */ | 51 | */ |
@@ -117,14 +118,14 @@ struct Plugin { | |||
117 | */ | 118 | */ |
118 | #define LOG_SQLITE(db, level, cmd) \ | 119 | #define LOG_SQLITE(db, level, cmd) \ |
119 | do \ | 120 | do \ |
120 | { \ | 121 | { \ |
121 | LOG(level, \ | 122 | LOG (level, \ |
122 | _("`%s' failed at %s:%d with error: %s\n"), \ | 123 | _ ("`%s' failed at %s:%d with error: %s\n"), \ |
123 | cmd, \ | 124 | cmd, \ |
124 | __FILE__, \ | 125 | __FILE__, \ |
125 | __LINE__, \ | 126 | __LINE__, \ |
126 | sqlite3_errmsg(db)); \ | 127 | sqlite3_errmsg (db)); \ |
127 | } while (0) | 128 | } while (0) |
128 | 129 | ||
129 | 130 | ||
130 | /** | 131 | /** |
@@ -135,19 +136,19 @@ struct Plugin { | |||
135 | */ | 136 | */ |
136 | #define SQLITE3_EXEC(db, cmd) \ | 137 | #define SQLITE3_EXEC(db, cmd) \ |
137 | do \ | 138 | do \ |
138 | { \ | 139 | { \ |
139 | emsg = NULL; \ | 140 | emsg = NULL; \ |
140 | if (SQLITE_OK != sqlite3_exec(db, cmd, NULL, NULL, &emsg)) \ | 141 | if (SQLITE_OK != sqlite3_exec (db, cmd, NULL, NULL, &emsg)) \ |
141 | { \ | 142 | { \ |
142 | LOG(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, \ | 143 | LOG (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, \ |
143 | _("`%s' failed at %s:%d with error: %s\n"), \ | 144 | _ ("`%s' failed at %s:%d with error: %s\n"), \ |
144 | "sqlite3_exec", \ | 145 | "sqlite3_exec", \ |
145 | __FILE__, \ | 146 | __FILE__, \ |
146 | __LINE__, \ | 147 | __LINE__, \ |
147 | emsg); \ | 148 | emsg); \ |
148 | sqlite3_free(emsg); \ | 149 | sqlite3_free (emsg); \ |
149 | } \ | 150 | } \ |
150 | } while (0) | 151 | } while (0) |
151 | 152 | ||
152 | 153 | ||
153 | /** | 154 | /** |
@@ -159,17 +160,17 @@ struct Plugin { | |||
159 | * @return 0 on success | 160 | * @return 0 on success |
160 | */ | 161 | */ |
161 | static int | 162 | static int |
162 | sq_prepare(sqlite3 *dbh, | 163 | sq_prepare (sqlite3 *dbh, |
163 | const char *zSql, /* SQL statement, UTF-8 encoded */ | 164 | const char *zSql, /* SQL statement, UTF-8 encoded */ |
164 | sqlite3_stmt **ppStmt) | 165 | sqlite3_stmt **ppStmt) |
165 | { /* OUT: Statement handle */ | 166 | { /* OUT: Statement handle */ |
166 | char *dummy; | 167 | char *dummy; |
167 | 168 | ||
168 | return sqlite3_prepare(dbh, | 169 | return sqlite3_prepare (dbh, |
169 | zSql, | 170 | zSql, |
170 | strlen(zSql), | 171 | strlen (zSql), |
171 | ppStmt, | 172 | ppStmt, |
172 | (const char **)&dummy); | 173 | (const char **) &dummy); |
173 | } | 174 | } |
174 | 175 | ||
175 | 176 | ||
@@ -188,54 +189,55 @@ sq_prepare(sqlite3 *dbh, | |||
188 | * @return 0 if duplicate, -1 on error, number of bytes used otherwise | 189 | * @return 0 if duplicate, -1 on error, number of bytes used otherwise |
189 | */ | 190 | */ |
190 | static ssize_t | 191 | static ssize_t |
191 | sqlite_plugin_put(void *cls, | 192 | sqlite_plugin_put (void *cls, |
192 | const struct GNUNET_HashCode *key, | 193 | const struct GNUNET_HashCode *key, |
193 | uint32_t xor_distance, | 194 | uint32_t xor_distance, |
194 | size_t size, | 195 | size_t size, |
195 | const char *data, | 196 | const char *data, |
196 | enum GNUNET_BLOCK_Type type, | 197 | enum GNUNET_BLOCK_Type type, |
197 | struct GNUNET_TIME_Absolute discard_time, | 198 | struct GNUNET_TIME_Absolute discard_time, |
198 | unsigned int path_info_len, | 199 | unsigned int path_info_len, |
199 | const struct GNUNET_PeerIdentity *path_info) | 200 | const struct GNUNET_PeerIdentity *path_info) |
200 | { | 201 | { |
201 | struct Plugin *plugin = cls; | 202 | struct Plugin *plugin = cls; |
202 | uint32_t type32 = type; | 203 | uint32_t type32 = type; |
203 | struct GNUNET_SQ_QueryParam params[] = | 204 | struct GNUNET_SQ_QueryParam params[] = |
204 | { GNUNET_SQ_query_param_uint32(&type32), | 205 | { GNUNET_SQ_query_param_uint32 (&type32), |
205 | GNUNET_SQ_query_param_absolute_time(&discard_time), | 206 | GNUNET_SQ_query_param_absolute_time (&discard_time), |
206 | GNUNET_SQ_query_param_auto_from_type(key), | 207 | GNUNET_SQ_query_param_auto_from_type (key), |
207 | GNUNET_SQ_query_param_uint32(&xor_distance), | 208 | GNUNET_SQ_query_param_uint32 (&xor_distance), |
208 | GNUNET_SQ_query_param_fixed_size(data, size), | 209 | GNUNET_SQ_query_param_fixed_size (data, size), |
209 | GNUNET_SQ_query_param_fixed_size(path_info, | 210 | GNUNET_SQ_query_param_fixed_size (path_info, |
210 | path_info_len * | 211 | path_info_len |
211 | sizeof(struct GNUNET_PeerIdentity)), | 212 | * sizeof(struct GNUNET_PeerIdentity)), |
212 | GNUNET_SQ_query_param_end }; | 213 | GNUNET_SQ_query_param_end }; |
213 | 214 | ||
214 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 215 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
215 | "Processing PUT of %u bytes with key `%s' and expiration %s\n", | 216 | "Processing PUT of %u bytes with key `%s' and expiration %s\n", |
216 | (unsigned int)size, | 217 | (unsigned int) size, |
217 | GNUNET_h2s(key), | 218 | GNUNET_h2s (key), |
218 | GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_remaining( | 219 | GNUNET_STRINGS_relative_time_to_string ( |
219 | discard_time), | 220 | GNUNET_TIME_absolute_get_remaining ( |
220 | GNUNET_YES)); | 221 | discard_time), |
221 | if (GNUNET_OK != GNUNET_SQ_bind(plugin->insert_stmt, params)) | 222 | GNUNET_YES)); |
222 | { | 223 | if (GNUNET_OK != GNUNET_SQ_bind (plugin->insert_stmt, params)) |
223 | LOG_SQLITE(plugin->dbh, | 224 | { |
224 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | 225 | LOG_SQLITE (plugin->dbh, |
225 | "sqlite3_bind_xxx"); | 226 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, |
226 | GNUNET_SQ_reset(plugin->dbh, plugin->insert_stmt); | 227 | "sqlite3_bind_xxx"); |
227 | return -1; | 228 | GNUNET_SQ_reset (plugin->dbh, plugin->insert_stmt); |
228 | } | 229 | return -1; |
229 | if (SQLITE_DONE != sqlite3_step(plugin->insert_stmt)) | 230 | } |
230 | { | 231 | if (SQLITE_DONE != sqlite3_step (plugin->insert_stmt)) |
231 | LOG_SQLITE(plugin->dbh, | 232 | { |
232 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | 233 | LOG_SQLITE (plugin->dbh, |
233 | "sqlite3_step"); | 234 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, |
234 | GNUNET_SQ_reset(plugin->dbh, plugin->insert_stmt); | 235 | "sqlite3_step"); |
235 | return -1; | 236 | GNUNET_SQ_reset (plugin->dbh, plugin->insert_stmt); |
236 | } | 237 | return -1; |
238 | } | ||
237 | plugin->num_items++; | 239 | plugin->num_items++; |
238 | GNUNET_SQ_reset(plugin->dbh, plugin->insert_stmt); | 240 | GNUNET_SQ_reset (plugin->dbh, plugin->insert_stmt); |
239 | return size + OVERHEAD; | 241 | return size + OVERHEAD; |
240 | } | 242 | } |
241 | 243 | ||
@@ -252,11 +254,11 @@ sqlite_plugin_put(void *cls, | |||
252 | * @return the number of results found | 254 | * @return the number of results found |
253 | */ | 255 | */ |
254 | static unsigned int | 256 | static unsigned int |
255 | sqlite_plugin_get(void *cls, | 257 | sqlite_plugin_get (void *cls, |
256 | const struct GNUNET_HashCode *key, | 258 | const struct GNUNET_HashCode *key, |
257 | enum GNUNET_BLOCK_Type type, | 259 | enum GNUNET_BLOCK_Type type, |
258 | GNUNET_DATACACHE_Iterator iter, | 260 | GNUNET_DATACACHE_Iterator iter, |
259 | void *iter_cls) | 261 | void *iter_cls) |
260 | { | 262 | { |
261 | struct Plugin *plugin = cls; | 263 | struct Plugin *plugin = cls; |
262 | uint32_t type32 = type; | 264 | uint32_t type32 = type; |
@@ -270,100 +272,100 @@ sqlite_plugin_get(void *cls, | |||
270 | size_t psize; | 272 | size_t psize; |
271 | struct GNUNET_PeerIdentity *path; | 273 | struct GNUNET_PeerIdentity *path; |
272 | struct GNUNET_SQ_QueryParam params_count[] = | 274 | struct GNUNET_SQ_QueryParam params_count[] = |
273 | { GNUNET_SQ_query_param_auto_from_type(key), | 275 | { GNUNET_SQ_query_param_auto_from_type (key), |
274 | GNUNET_SQ_query_param_uint32(&type32), | 276 | GNUNET_SQ_query_param_uint32 (&type32), |
275 | GNUNET_SQ_query_param_absolute_time(&now), | 277 | GNUNET_SQ_query_param_absolute_time (&now), |
276 | GNUNET_SQ_query_param_end }; | 278 | GNUNET_SQ_query_param_end }; |
277 | struct GNUNET_SQ_QueryParam params_select[] = | 279 | struct GNUNET_SQ_QueryParam params_select[] = |
278 | { GNUNET_SQ_query_param_auto_from_type(key), | 280 | { GNUNET_SQ_query_param_auto_from_type (key), |
279 | GNUNET_SQ_query_param_uint32(&type32), | 281 | GNUNET_SQ_query_param_uint32 (&type32), |
280 | GNUNET_SQ_query_param_absolute_time(&now), | 282 | GNUNET_SQ_query_param_absolute_time (&now), |
281 | GNUNET_SQ_query_param_uint32(&off), | 283 | GNUNET_SQ_query_param_uint32 (&off), |
282 | GNUNET_SQ_query_param_end }; | 284 | GNUNET_SQ_query_param_end }; |
283 | struct GNUNET_SQ_ResultSpec rs[] = | 285 | struct GNUNET_SQ_ResultSpec rs[] = |
284 | { GNUNET_SQ_result_spec_variable_size(&dat, &size), | 286 | { GNUNET_SQ_result_spec_variable_size (&dat, &size), |
285 | GNUNET_SQ_result_spec_absolute_time(&exp), | 287 | GNUNET_SQ_result_spec_absolute_time (&exp), |
286 | GNUNET_SQ_result_spec_variable_size((void **)&path, &psize), | 288 | GNUNET_SQ_result_spec_variable_size ((void **) &path, &psize), |
287 | GNUNET_SQ_result_spec_end }; | 289 | GNUNET_SQ_result_spec_end }; |
288 | 290 | ||
289 | now = GNUNET_TIME_absolute_get(); | 291 | now = GNUNET_TIME_absolute_get (); |
290 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 292 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
291 | "Processing GET for key `%s'\n", | 293 | "Processing GET for key `%s'\n", |
292 | GNUNET_h2s(key)); | 294 | GNUNET_h2s (key)); |
295 | |||
296 | if (GNUNET_OK != GNUNET_SQ_bind (plugin->get_count_stmt, params_count)) | ||
297 | { | ||
298 | LOG_SQLITE (plugin->dbh, | ||
299 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | ||
300 | "sqlite3_bind_xxx"); | ||
301 | GNUNET_SQ_reset (plugin->dbh, plugin->get_count_stmt); | ||
302 | return 0; | ||
303 | } | ||
304 | if (SQLITE_ROW != sqlite3_step (plugin->get_count_stmt)) | ||
305 | { | ||
306 | LOG_SQLITE (plugin->dbh, | ||
307 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | ||
308 | "sqlite_step"); | ||
309 | GNUNET_SQ_reset (plugin->dbh, plugin->get_count_stmt); | ||
310 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
311 | "No content found when processing GET for key `%s'\n", | ||
312 | GNUNET_h2s (key)); | ||
313 | return 0; | ||
314 | } | ||
315 | total = sqlite3_column_int (plugin->get_count_stmt, 0); | ||
316 | GNUNET_SQ_reset (plugin->dbh, plugin->get_count_stmt); | ||
317 | if ((0 == total) || (NULL == iter)) | ||
318 | { | ||
319 | if (0 == total) | ||
320 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
321 | "No content found when processing GET for key `%s'\n", | ||
322 | GNUNET_h2s (key)); | ||
323 | return total; | ||
324 | } | ||
293 | 325 | ||
294 | if (GNUNET_OK != GNUNET_SQ_bind(plugin->get_count_stmt, params_count)) | 326 | cnt = 0; |
327 | off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, total); | ||
328 | while (cnt < total) | ||
329 | { | ||
330 | off = (off + 1) % total; | ||
331 | if (GNUNET_OK != GNUNET_SQ_bind (plugin->get_stmt, params_select)) | ||
295 | { | 332 | { |
296 | LOG_SQLITE(plugin->dbh, | 333 | LOG_SQLITE (plugin->dbh, |
297 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | 334 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, |
298 | "sqlite3_bind_xxx"); | 335 | "sqlite3_bind_xxx"); |
299 | GNUNET_SQ_reset(plugin->dbh, plugin->get_count_stmt); | 336 | GNUNET_SQ_reset (plugin->dbh, plugin->get_stmt); |
300 | return 0; | 337 | return cnt; |
301 | } | 338 | } |
302 | if (SQLITE_ROW != sqlite3_step(plugin->get_count_stmt)) | 339 | if (SQLITE_ROW != sqlite3_step (plugin->get_stmt)) |
340 | break; | ||
341 | if (GNUNET_OK != GNUNET_SQ_extract_result (plugin->get_stmt, rs)) | ||
303 | { | 342 | { |
304 | LOG_SQLITE(plugin->dbh, | 343 | GNUNET_break (0); |
305 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | 344 | GNUNET_SQ_reset (plugin->dbh, plugin->get_stmt); |
306 | "sqlite_step"); | 345 | break; |
307 | GNUNET_SQ_reset(plugin->dbh, plugin->get_count_stmt); | ||
308 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
309 | "No content found when processing GET for key `%s'\n", | ||
310 | GNUNET_h2s(key)); | ||
311 | return 0; | ||
312 | } | 346 | } |
313 | total = sqlite3_column_int(plugin->get_count_stmt, 0); | 347 | if (0 != psize % sizeof(struct GNUNET_PeerIdentity)) |
314 | GNUNET_SQ_reset(plugin->dbh, plugin->get_count_stmt); | ||
315 | if ((0 == total) || (NULL == iter)) | ||
316 | { | 348 | { |
317 | if (0 == total) | 349 | GNUNET_break (0); |
318 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 350 | psize = 0; |
319 | "No content found when processing GET for key `%s'\n", | 351 | path = NULL; |
320 | GNUNET_h2s(key)); | ||
321 | return total; | ||
322 | } | 352 | } |
323 | 353 | psize /= sizeof(struct GNUNET_PeerIdentity); | |
324 | cnt = 0; | 354 | cnt++; |
325 | off = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, total); | 355 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
326 | while (cnt < total) | 356 | "Found %u-byte result when processing GET for key `%s'\n", |
357 | (unsigned int) size, | ||
358 | GNUNET_h2s (key)); | ||
359 | if (GNUNET_OK != iter (iter_cls, key, size, dat, type, exp, psize, path)) | ||
327 | { | 360 | { |
328 | off = (off + 1) % total; | 361 | GNUNET_SQ_cleanup_result (rs); |
329 | if (GNUNET_OK != GNUNET_SQ_bind(plugin->get_stmt, params_select)) | 362 | GNUNET_SQ_reset (plugin->dbh, plugin->get_stmt); |
330 | { | 363 | break; |
331 | LOG_SQLITE(plugin->dbh, | ||
332 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | ||
333 | "sqlite3_bind_xxx"); | ||
334 | GNUNET_SQ_reset(plugin->dbh, plugin->get_stmt); | ||
335 | return cnt; | ||
336 | } | ||
337 | if (SQLITE_ROW != sqlite3_step(plugin->get_stmt)) | ||
338 | break; | ||
339 | if (GNUNET_OK != GNUNET_SQ_extract_result(plugin->get_stmt, rs)) | ||
340 | { | ||
341 | GNUNET_break(0); | ||
342 | GNUNET_SQ_reset(plugin->dbh, plugin->get_stmt); | ||
343 | break; | ||
344 | } | ||
345 | if (0 != psize % sizeof(struct GNUNET_PeerIdentity)) | ||
346 | { | ||
347 | GNUNET_break(0); | ||
348 | psize = 0; | ||
349 | path = NULL; | ||
350 | } | ||
351 | psize /= sizeof(struct GNUNET_PeerIdentity); | ||
352 | cnt++; | ||
353 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
354 | "Found %u-byte result when processing GET for key `%s'\n", | ||
355 | (unsigned int)size, | ||
356 | GNUNET_h2s(key)); | ||
357 | if (GNUNET_OK != iter(iter_cls, key, size, dat, type, exp, psize, path)) | ||
358 | { | ||
359 | GNUNET_SQ_cleanup_result(rs); | ||
360 | GNUNET_SQ_reset(plugin->dbh, plugin->get_stmt); | ||
361 | break; | ||
362 | } | ||
363 | GNUNET_SQ_cleanup_result(rs); | ||
364 | GNUNET_SQ_reset(plugin->dbh, plugin->get_stmt); | ||
365 | } | 364 | } |
366 | GNUNET_SQ_reset(plugin->dbh, plugin->get_stmt); | 365 | GNUNET_SQ_cleanup_result (rs); |
366 | GNUNET_SQ_reset (plugin->dbh, plugin->get_stmt); | ||
367 | } | ||
368 | GNUNET_SQ_reset (plugin->dbh, plugin->get_stmt); | ||
367 | return cnt; | 369 | return cnt; |
368 | } | 370 | } |
369 | 371 | ||
@@ -376,7 +378,7 @@ sqlite_plugin_get(void *cls, | |||
376 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error | 378 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error |
377 | */ | 379 | */ |
378 | static int | 380 | static int |
379 | sqlite_plugin_del(void *cls) | 381 | sqlite_plugin_del (void *cls) |
380 | { | 382 | { |
381 | struct Plugin *plugin = cls; | 383 | struct Plugin *plugin = cls; |
382 | uint64_t rowid; | 384 | uint64_t rowid; |
@@ -385,65 +387,66 @@ sqlite_plugin_del(void *cls) | |||
385 | struct GNUNET_HashCode hc; | 387 | struct GNUNET_HashCode hc; |
386 | struct GNUNET_TIME_Absolute now; | 388 | struct GNUNET_TIME_Absolute now; |
387 | struct GNUNET_SQ_ResultSpec rs[] = | 389 | struct GNUNET_SQ_ResultSpec rs[] = |
388 | { GNUNET_SQ_result_spec_uint64(&rowid), | 390 | { GNUNET_SQ_result_spec_uint64 (&rowid), |
389 | GNUNET_SQ_result_spec_auto_from_type(&hc), | 391 | GNUNET_SQ_result_spec_auto_from_type (&hc), |
390 | GNUNET_SQ_result_spec_variable_size((void **)&data, &dsize), | 392 | GNUNET_SQ_result_spec_variable_size ((void **) &data, &dsize), |
391 | GNUNET_SQ_result_spec_end }; | 393 | GNUNET_SQ_result_spec_end }; |
392 | struct GNUNET_SQ_QueryParam params[] = { GNUNET_SQ_query_param_uint64(&rowid), | 394 | struct GNUNET_SQ_QueryParam params[] = { GNUNET_SQ_query_param_uint64 ( |
395 | &rowid), | ||
393 | GNUNET_SQ_query_param_end }; | 396 | GNUNET_SQ_query_param_end }; |
394 | struct GNUNET_SQ_QueryParam time_params[] = | 397 | struct GNUNET_SQ_QueryParam time_params[] = |
395 | { GNUNET_SQ_query_param_absolute_time(&now), GNUNET_SQ_query_param_end }; | 398 | { GNUNET_SQ_query_param_absolute_time (&now), GNUNET_SQ_query_param_end }; |
396 | 399 | ||
397 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Processing DEL\n"); | 400 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing DEL\n"); |
398 | now = GNUNET_TIME_absolute_get(); | 401 | now = GNUNET_TIME_absolute_get (); |
399 | if (GNUNET_OK != GNUNET_SQ_bind(plugin->del_expired_stmt, time_params)) | 402 | if (GNUNET_OK != GNUNET_SQ_bind (plugin->del_expired_stmt, time_params)) |
400 | { | 403 | { |
401 | LOG_SQLITE(plugin->dbh, | 404 | LOG_SQLITE (plugin->dbh, |
402 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | 405 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, |
403 | "sqlite3_bind"); | 406 | "sqlite3_bind"); |
404 | GNUNET_SQ_reset(plugin->dbh, plugin->del_expired_stmt); | 407 | GNUNET_SQ_reset (plugin->dbh, plugin->del_expired_stmt); |
405 | return GNUNET_SYSERR; | 408 | return GNUNET_SYSERR; |
406 | } | 409 | } |
407 | if ((SQLITE_ROW != sqlite3_step(plugin->del_expired_stmt)) || | 410 | if ((SQLITE_ROW != sqlite3_step (plugin->del_expired_stmt)) || |
408 | (GNUNET_OK != GNUNET_SQ_extract_result(plugin->del_expired_stmt, rs))) | 411 | (GNUNET_OK != GNUNET_SQ_extract_result (plugin->del_expired_stmt, rs))) |
409 | { | 412 | { |
410 | GNUNET_SQ_reset(plugin->dbh, plugin->del_expired_stmt); | 413 | GNUNET_SQ_reset (plugin->dbh, plugin->del_expired_stmt); |
411 | if (SQLITE_ROW != sqlite3_step(plugin->del_select_stmt)) | 414 | if (SQLITE_ROW != sqlite3_step (plugin->del_select_stmt)) |
412 | { | ||
413 | LOG_SQLITE(plugin->dbh, | ||
414 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | ||
415 | "sqlite3_step"); | ||
416 | GNUNET_SQ_reset(plugin->dbh, plugin->del_select_stmt); | ||
417 | return GNUNET_SYSERR; | ||
418 | } | ||
419 | if (GNUNET_OK != GNUNET_SQ_extract_result(plugin->del_select_stmt, rs)) | ||
420 | { | ||
421 | GNUNET_SQ_reset(plugin->dbh, plugin->del_select_stmt); | ||
422 | GNUNET_break(0); | ||
423 | return GNUNET_SYSERR; | ||
424 | } | ||
425 | } | ||
426 | GNUNET_SQ_cleanup_result(rs); | ||
427 | GNUNET_SQ_reset(plugin->dbh, plugin->del_select_stmt); | ||
428 | if (GNUNET_OK != GNUNET_SQ_bind(plugin->del_stmt, params)) | ||
429 | { | 415 | { |
430 | LOG_SQLITE(plugin->dbh, | 416 | LOG_SQLITE (plugin->dbh, |
431 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | 417 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, |
432 | "sqlite3_bind"); | 418 | "sqlite3_step"); |
433 | GNUNET_SQ_reset(plugin->dbh, plugin->del_stmt); | 419 | GNUNET_SQ_reset (plugin->dbh, plugin->del_select_stmt); |
434 | return GNUNET_SYSERR; | 420 | return GNUNET_SYSERR; |
435 | } | 421 | } |
436 | if (SQLITE_DONE != sqlite3_step(plugin->del_stmt)) | 422 | if (GNUNET_OK != GNUNET_SQ_extract_result (plugin->del_select_stmt, rs)) |
437 | { | 423 | { |
438 | LOG_SQLITE(plugin->dbh, | 424 | GNUNET_SQ_reset (plugin->dbh, plugin->del_select_stmt); |
439 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | 425 | GNUNET_break (0); |
440 | "sqlite3_step"); | ||
441 | GNUNET_SQ_reset(plugin->dbh, plugin->del_stmt); | ||
442 | return GNUNET_SYSERR; | 426 | return GNUNET_SYSERR; |
443 | } | 427 | } |
428 | } | ||
429 | GNUNET_SQ_cleanup_result (rs); | ||
430 | GNUNET_SQ_reset (plugin->dbh, plugin->del_select_stmt); | ||
431 | if (GNUNET_OK != GNUNET_SQ_bind (plugin->del_stmt, params)) | ||
432 | { | ||
433 | LOG_SQLITE (plugin->dbh, | ||
434 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | ||
435 | "sqlite3_bind"); | ||
436 | GNUNET_SQ_reset (plugin->dbh, plugin->del_stmt); | ||
437 | return GNUNET_SYSERR; | ||
438 | } | ||
439 | if (SQLITE_DONE != sqlite3_step (plugin->del_stmt)) | ||
440 | { | ||
441 | LOG_SQLITE (plugin->dbh, | ||
442 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | ||
443 | "sqlite3_step"); | ||
444 | GNUNET_SQ_reset (plugin->dbh, plugin->del_stmt); | ||
445 | return GNUNET_SYSERR; | ||
446 | } | ||
444 | plugin->num_items--; | 447 | plugin->num_items--; |
445 | plugin->env->delete_notify(plugin->env->cls, &hc, dsize + OVERHEAD); | 448 | plugin->env->delete_notify (plugin->env->cls, &hc, dsize + OVERHEAD); |
446 | GNUNET_SQ_reset(plugin->dbh, plugin->del_stmt); | 449 | GNUNET_SQ_reset (plugin->dbh, plugin->del_stmt); |
447 | return GNUNET_OK; | 450 | return GNUNET_OK; |
448 | } | 451 | } |
449 | 452 | ||
@@ -457,9 +460,9 @@ sqlite_plugin_del(void *cls) | |||
457 | * @return the number of results found, zero (datacache empty) or one | 460 | * @return the number of results found, zero (datacache empty) or one |
458 | */ | 461 | */ |
459 | static unsigned int | 462 | static unsigned int |
460 | sqlite_plugin_get_random(void *cls, | 463 | sqlite_plugin_get_random (void *cls, |
461 | GNUNET_DATACACHE_Iterator iter, | 464 | GNUNET_DATACACHE_Iterator iter, |
462 | void *iter_cls) | 465 | void *iter_cls) |
463 | { | 466 | { |
464 | struct Plugin *plugin = cls; | 467 | struct Plugin *plugin = cls; |
465 | struct GNUNET_TIME_Absolute exp; | 468 | struct GNUNET_TIME_Absolute exp; |
@@ -470,14 +473,14 @@ sqlite_plugin_get_random(void *cls, | |||
470 | uint32_t type; | 473 | uint32_t type; |
471 | struct GNUNET_PeerIdentity *path; | 474 | struct GNUNET_PeerIdentity *path; |
472 | struct GNUNET_HashCode key; | 475 | struct GNUNET_HashCode key; |
473 | struct GNUNET_SQ_QueryParam params[] = { GNUNET_SQ_query_param_uint32(&off), | 476 | struct GNUNET_SQ_QueryParam params[] = { GNUNET_SQ_query_param_uint32 (&off), |
474 | GNUNET_SQ_query_param_end }; | 477 | GNUNET_SQ_query_param_end }; |
475 | struct GNUNET_SQ_ResultSpec rs[] = | 478 | struct GNUNET_SQ_ResultSpec rs[] = |
476 | { GNUNET_SQ_result_spec_variable_size(&dat, &size), | 479 | { GNUNET_SQ_result_spec_variable_size (&dat, &size), |
477 | GNUNET_SQ_result_spec_absolute_time(&exp), | 480 | GNUNET_SQ_result_spec_absolute_time (&exp), |
478 | GNUNET_SQ_result_spec_variable_size((void **)&path, &psize), | 481 | GNUNET_SQ_result_spec_variable_size ((void **) &path, &psize), |
479 | GNUNET_SQ_result_spec_auto_from_type(&key), | 482 | GNUNET_SQ_result_spec_auto_from_type (&key), |
480 | GNUNET_SQ_result_spec_uint32(&type), | 483 | GNUNET_SQ_result_spec_uint32 (&type), |
481 | GNUNET_SQ_result_spec_end }; | 484 | GNUNET_SQ_result_spec_end }; |
482 | 485 | ||
483 | if (0 == plugin->num_items) | 486 | if (0 == plugin->num_items) |
@@ -485,44 +488,44 @@ sqlite_plugin_get_random(void *cls, | |||
485 | if (NULL == iter) | 488 | if (NULL == iter) |
486 | return 1; | 489 | return 1; |
487 | off = | 490 | off = |
488 | GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, plugin->num_items); | 491 | GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, plugin->num_items); |
489 | if (GNUNET_OK != GNUNET_SQ_bind(plugin->get_random_stmt, params)) | 492 | if (GNUNET_OK != GNUNET_SQ_bind (plugin->get_random_stmt, params)) |
490 | { | 493 | { |
491 | return 0; | 494 | return 0; |
492 | } | 495 | } |
493 | if (SQLITE_ROW != sqlite3_step(plugin->get_random_stmt)) | 496 | if (SQLITE_ROW != sqlite3_step (plugin->get_random_stmt)) |
494 | { | 497 | { |
495 | GNUNET_break(0); | 498 | GNUNET_break (0); |
496 | GNUNET_SQ_reset(plugin->dbh, plugin->get_random_stmt); | 499 | GNUNET_SQ_reset (plugin->dbh, plugin->get_random_stmt); |
497 | return 0; | 500 | return 0; |
498 | } | 501 | } |
499 | if (GNUNET_OK != GNUNET_SQ_extract_result(plugin->get_random_stmt, rs)) | 502 | if (GNUNET_OK != GNUNET_SQ_extract_result (plugin->get_random_stmt, rs)) |
500 | { | 503 | { |
501 | GNUNET_break(0); | 504 | GNUNET_break (0); |
502 | GNUNET_SQ_reset(plugin->dbh, plugin->get_random_stmt); | 505 | GNUNET_SQ_reset (plugin->dbh, plugin->get_random_stmt); |
503 | return 0; | 506 | return 0; |
504 | } | 507 | } |
505 | if (0 != psize % sizeof(struct GNUNET_PeerIdentity)) | 508 | if (0 != psize % sizeof(struct GNUNET_PeerIdentity)) |
506 | { | 509 | { |
507 | GNUNET_break(0); | 510 | GNUNET_break (0); |
508 | psize = 0; | 511 | psize = 0; |
509 | path = NULL; | 512 | path = NULL; |
510 | } | 513 | } |
511 | psize /= sizeof(struct GNUNET_PeerIdentity); | 514 | psize /= sizeof(struct GNUNET_PeerIdentity); |
512 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 515 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
513 | "Found %u-byte result with key %s when processing GET-RANDOM\n", | 516 | "Found %u-byte result with key %s when processing GET-RANDOM\n", |
514 | (unsigned int)size, | 517 | (unsigned int) size, |
515 | GNUNET_h2s(&key)); | 518 | GNUNET_h2s (&key)); |
516 | (void)iter(iter_cls, | 519 | (void) iter (iter_cls, |
517 | &key, | 520 | &key, |
518 | size, | 521 | size, |
519 | dat, | 522 | dat, |
520 | (enum GNUNET_BLOCK_Type)type, | 523 | (enum GNUNET_BLOCK_Type) type, |
521 | exp, | 524 | exp, |
522 | psize, | 525 | psize, |
523 | path); | 526 | path); |
524 | GNUNET_SQ_cleanup_result(rs); | 527 | GNUNET_SQ_cleanup_result (rs); |
525 | GNUNET_SQ_reset(plugin->dbh, plugin->get_random_stmt); | 528 | GNUNET_SQ_reset (plugin->dbh, plugin->get_random_stmt); |
526 | return 1; | 529 | return 1; |
527 | } | 530 | } |
528 | 531 | ||
@@ -541,11 +544,11 @@ sqlite_plugin_get_random(void *cls, | |||
541 | * @return the number of results found | 544 | * @return the number of results found |
542 | */ | 545 | */ |
543 | static unsigned int | 546 | static unsigned int |
544 | sqlite_plugin_get_closest(void *cls, | 547 | sqlite_plugin_get_closest (void *cls, |
545 | const struct GNUNET_HashCode *key, | 548 | const struct GNUNET_HashCode *key, |
546 | unsigned int num_results, | 549 | unsigned int num_results, |
547 | GNUNET_DATACACHE_Iterator iter, | 550 | GNUNET_DATACACHE_Iterator iter, |
548 | void *iter_cls) | 551 | void *iter_cls) |
549 | { | 552 | { |
550 | struct Plugin *plugin = cls; | 553 | struct Plugin *plugin = cls; |
551 | uint32_t num_results32 = num_results; | 554 | uint32_t num_results32 = num_results; |
@@ -559,58 +562,58 @@ sqlite_plugin_get_closest(void *cls, | |||
559 | struct GNUNET_HashCode hc; | 562 | struct GNUNET_HashCode hc; |
560 | struct GNUNET_PeerIdentity *path; | 563 | struct GNUNET_PeerIdentity *path; |
561 | struct GNUNET_SQ_QueryParam params[] = | 564 | struct GNUNET_SQ_QueryParam params[] = |
562 | { GNUNET_SQ_query_param_auto_from_type(key), | 565 | { GNUNET_SQ_query_param_auto_from_type (key), |
563 | GNUNET_SQ_query_param_absolute_time(&now), | 566 | GNUNET_SQ_query_param_absolute_time (&now), |
564 | GNUNET_SQ_query_param_uint32(&num_results32), | 567 | GNUNET_SQ_query_param_uint32 (&num_results32), |
565 | GNUNET_SQ_query_param_end }; | 568 | GNUNET_SQ_query_param_end }; |
566 | struct GNUNET_SQ_ResultSpec rs[] = | 569 | struct GNUNET_SQ_ResultSpec rs[] = |
567 | { GNUNET_SQ_result_spec_variable_size(&dat, &size), | 570 | { GNUNET_SQ_result_spec_variable_size (&dat, &size), |
568 | GNUNET_SQ_result_spec_absolute_time(&exp), | 571 | GNUNET_SQ_result_spec_absolute_time (&exp), |
569 | GNUNET_SQ_result_spec_variable_size((void **)&path, &psize), | 572 | GNUNET_SQ_result_spec_variable_size ((void **) &path, &psize), |
570 | GNUNET_SQ_result_spec_uint32(&type), | 573 | GNUNET_SQ_result_spec_uint32 (&type), |
571 | GNUNET_SQ_result_spec_auto_from_type(&hc), | 574 | GNUNET_SQ_result_spec_auto_from_type (&hc), |
572 | GNUNET_SQ_result_spec_end }; | 575 | GNUNET_SQ_result_spec_end }; |
573 | 576 | ||
574 | now = GNUNET_TIME_absolute_get(); | 577 | now = GNUNET_TIME_absolute_get (); |
575 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 578 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
576 | "Processing GET_CLOSEST for key `%s'\n", | 579 | "Processing GET_CLOSEST for key `%s'\n", |
577 | GNUNET_h2s(key)); | 580 | GNUNET_h2s (key)); |
578 | if (GNUNET_OK != GNUNET_SQ_bind(plugin->get_closest_stmt, params)) | 581 | if (GNUNET_OK != GNUNET_SQ_bind (plugin->get_closest_stmt, params)) |
582 | { | ||
583 | LOG_SQLITE (plugin->dbh, | ||
584 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | ||
585 | "sqlite3_bind_xxx"); | ||
586 | GNUNET_SQ_reset (plugin->dbh, plugin->get_closest_stmt); | ||
587 | return 0; | ||
588 | } | ||
589 | cnt = 0; | ||
590 | while (SQLITE_ROW == sqlite3_step (plugin->get_closest_stmt)) | ||
591 | { | ||
592 | if (GNUNET_OK != GNUNET_SQ_extract_result (plugin->get_closest_stmt, rs)) | ||
579 | { | 593 | { |
580 | LOG_SQLITE(plugin->dbh, | 594 | GNUNET_break (0); |
581 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | 595 | break; |
582 | "sqlite3_bind_xxx"); | ||
583 | GNUNET_SQ_reset(plugin->dbh, plugin->get_closest_stmt); | ||
584 | return 0; | ||
585 | } | 596 | } |
586 | cnt = 0; | 597 | if (0 != psize % sizeof(struct GNUNET_PeerIdentity)) |
587 | while (SQLITE_ROW == sqlite3_step(plugin->get_closest_stmt)) | ||
588 | { | 598 | { |
589 | if (GNUNET_OK != GNUNET_SQ_extract_result(plugin->get_closest_stmt, rs)) | 599 | GNUNET_break (0); |
590 | { | 600 | psize = 0; |
591 | GNUNET_break(0); | 601 | path = NULL; |
592 | break; | 602 | } |
593 | } | 603 | psize /= sizeof(struct GNUNET_PeerIdentity); |
594 | if (0 != psize % sizeof(struct GNUNET_PeerIdentity)) | 604 | cnt++; |
595 | { | 605 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
596 | GNUNET_break(0); | 606 | "Found %u-byte result at %s when processing GET_CLOSE\n", |
597 | psize = 0; | 607 | (unsigned int) size, |
598 | path = NULL; | 608 | GNUNET_h2s (&hc)); |
599 | } | 609 | if (GNUNET_OK != iter (iter_cls, &hc, size, dat, type, exp, psize, path)) |
600 | psize /= sizeof(struct GNUNET_PeerIdentity); | 610 | { |
601 | cnt++; | 611 | GNUNET_SQ_cleanup_result (rs); |
602 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 612 | break; |
603 | "Found %u-byte result at %s when processing GET_CLOSE\n", | ||
604 | (unsigned int)size, | ||
605 | GNUNET_h2s(&hc)); | ||
606 | if (GNUNET_OK != iter(iter_cls, &hc, size, dat, type, exp, psize, path)) | ||
607 | { | ||
608 | GNUNET_SQ_cleanup_result(rs); | ||
609 | break; | ||
610 | } | ||
611 | GNUNET_SQ_cleanup_result(rs); | ||
612 | } | 613 | } |
613 | GNUNET_SQ_reset(plugin->dbh, plugin->get_closest_stmt); | 614 | GNUNET_SQ_cleanup_result (rs); |
615 | } | ||
616 | GNUNET_SQ_reset (plugin->dbh, plugin->get_closest_stmt); | ||
614 | return cnt; | 617 | return cnt; |
615 | } | 618 | } |
616 | 619 | ||
@@ -622,7 +625,7 @@ sqlite_plugin_get_closest(void *cls, | |||
622 | * @return the plugin's closure (our `struct Plugin`) | 625 | * @return the plugin's closure (our `struct Plugin`) |
623 | */ | 626 | */ |
624 | void * | 627 | void * |
625 | libgnunet_plugin_datacache_sqlite_init(void *cls) | 628 | libgnunet_plugin_datacache_sqlite_init (void *cls) |
626 | { | 629 | { |
627 | struct GNUNET_DATACACHE_PluginEnvironment *env = cls; | 630 | struct GNUNET_DATACACHE_PluginEnvironment *env = cls; |
628 | struct GNUNET_DATACACHE_PluginFunctions *api; | 631 | struct GNUNET_DATACACHE_PluginFunctions *api; |
@@ -632,111 +635,111 @@ libgnunet_plugin_datacache_sqlite_init(void *cls) | |||
632 | sqlite3 *dbh; | 635 | sqlite3 *dbh; |
633 | char *emsg; | 636 | char *emsg; |
634 | 637 | ||
635 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(env->cfg, | 638 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (env->cfg, |
636 | "datacache-sqlite", | 639 | "datacache-sqlite", |
637 | "IN_MEMORY")) | 640 | "IN_MEMORY")) |
641 | { | ||
642 | if (SQLITE_OK != sqlite3_open (":memory:", &dbh)) | ||
643 | return NULL; | ||
644 | fn_utf8 = NULL; | ||
645 | } | ||
646 | else | ||
647 | { | ||
648 | fn = GNUNET_DISK_mktemp ("gnunet-datacache"); | ||
649 | if (fn == NULL) | ||
638 | { | 650 | { |
639 | if (SQLITE_OK != sqlite3_open(":memory:", &dbh)) | 651 | GNUNET_break (0); |
640 | return NULL; | 652 | return NULL; |
641 | fn_utf8 = NULL; | ||
642 | } | 653 | } |
643 | else | 654 | /* fn should be UTF-8-encoded. If it isn't, it's a bug. */ |
655 | fn_utf8 = GNUNET_strdup (fn); | ||
656 | if (SQLITE_OK != sqlite3_open (fn_utf8, &dbh)) | ||
644 | { | 657 | { |
645 | fn = GNUNET_DISK_mktemp("gnunet-datacache"); | 658 | GNUNET_free (fn); |
646 | if (fn == NULL) | 659 | GNUNET_free (fn_utf8); |
647 | { | 660 | return NULL; |
648 | GNUNET_break(0); | ||
649 | return NULL; | ||
650 | } | ||
651 | /* fn should be UTF-8-encoded. If it isn't, it's a bug. */ | ||
652 | fn_utf8 = GNUNET_strdup(fn); | ||
653 | if (SQLITE_OK != sqlite3_open(fn_utf8, &dbh)) | ||
654 | { | ||
655 | GNUNET_free(fn); | ||
656 | GNUNET_free(fn_utf8); | ||
657 | return NULL; | ||
658 | } | ||
659 | GNUNET_free(fn); | ||
660 | } | 661 | } |
661 | 662 | GNUNET_free (fn); | |
662 | SQLITE3_EXEC(dbh, "PRAGMA temp_store=MEMORY"); | 663 | } |
663 | SQLITE3_EXEC(dbh, "PRAGMA locking_mode=EXCLUSIVE"); | 664 | |
664 | SQLITE3_EXEC(dbh, "PRAGMA journal_mode=OFF"); | 665 | SQLITE3_EXEC (dbh, "PRAGMA temp_store=MEMORY"); |
665 | SQLITE3_EXEC(dbh, "PRAGMA synchronous=OFF"); | 666 | SQLITE3_EXEC (dbh, "PRAGMA locking_mode=EXCLUSIVE"); |
666 | SQLITE3_EXEC(dbh, "PRAGMA page_size=4092"); | 667 | SQLITE3_EXEC (dbh, "PRAGMA journal_mode=OFF"); |
667 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(env->cfg, | 668 | SQLITE3_EXEC (dbh, "PRAGMA synchronous=OFF"); |
668 | "datacache-sqlite", | 669 | SQLITE3_EXEC (dbh, "PRAGMA page_size=4092"); |
669 | "IN_MEMORY")) | 670 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (env->cfg, |
670 | SQLITE3_EXEC(dbh, "PRAGMA sqlite_temp_store=3"); | 671 | "datacache-sqlite", |
671 | 672 | "IN_MEMORY")) | |
672 | SQLITE3_EXEC(dbh, | 673 | SQLITE3_EXEC (dbh, "PRAGMA sqlite_temp_store=3"); |
673 | "CREATE TABLE ds091 (" | 674 | |
674 | " type INTEGER NOT NULL DEFAULT 0," | 675 | SQLITE3_EXEC (dbh, |
675 | " expire INTEGER NOT NULL," | 676 | "CREATE TABLE ds091 (" |
676 | " key BLOB NOT NULL DEFAULT ''," | 677 | " type INTEGER NOT NULL DEFAULT 0," |
677 | " prox INTEGER NOT NULL," | 678 | " expire INTEGER NOT NULL," |
678 | " value BLOB NOT NULL," | 679 | " key BLOB NOT NULL DEFAULT ''," |
679 | " path BLOB DEFAULT '')"); | 680 | " prox INTEGER NOT NULL," |
680 | SQLITE3_EXEC(dbh, "CREATE INDEX idx_hashidx ON ds091 (key,type,expire)"); | 681 | " value BLOB NOT NULL," |
681 | SQLITE3_EXEC(dbh, "CREATE INDEX idx_prox_expire ON ds091 (prox,expire)"); | 682 | " path BLOB DEFAULT '')"); |
682 | SQLITE3_EXEC(dbh, "CREATE INDEX idx_expire_only ON ds091 (expire)"); | 683 | SQLITE3_EXEC (dbh, "CREATE INDEX idx_hashidx ON ds091 (key,type,expire)"); |
683 | plugin = GNUNET_new(struct Plugin); | 684 | SQLITE3_EXEC (dbh, "CREATE INDEX idx_prox_expire ON ds091 (prox,expire)"); |
685 | SQLITE3_EXEC (dbh, "CREATE INDEX idx_expire_only ON ds091 (expire)"); | ||
686 | plugin = GNUNET_new (struct Plugin); | ||
684 | plugin->env = env; | 687 | plugin->env = env; |
685 | plugin->dbh = dbh; | 688 | plugin->dbh = dbh; |
686 | plugin->fn = fn_utf8; | 689 | plugin->fn = fn_utf8; |
687 | 690 | ||
688 | if ((SQLITE_OK != | 691 | if ((SQLITE_OK != |
689 | sq_prepare(plugin->dbh, | 692 | sq_prepare (plugin->dbh, |
690 | "INSERT INTO ds091 (type, expire, key, prox, value, path) " | 693 | "INSERT INTO ds091 (type, expire, key, prox, value, path) " |
691 | "VALUES (?, ?, ?, ?, ?, ?)", | 694 | "VALUES (?, ?, ?, ?, ?, ?)", |
692 | &plugin->insert_stmt)) || | 695 | &plugin->insert_stmt)) || |
693 | (SQLITE_OK != sq_prepare(plugin->dbh, | 696 | (SQLITE_OK != sq_prepare (plugin->dbh, |
694 | "SELECT count(*) FROM ds091 " | 697 | "SELECT count(*) FROM ds091 " |
695 | "WHERE key=? AND type=? AND expire >= ?", | 698 | "WHERE key=? AND type=? AND expire >= ?", |
696 | &plugin->get_count_stmt)) || | 699 | &plugin->get_count_stmt)) || |
697 | (SQLITE_OK != | 700 | (SQLITE_OK != |
698 | sq_prepare(plugin->dbh, | 701 | sq_prepare (plugin->dbh, |
699 | "SELECT value,expire,path FROM ds091" | 702 | "SELECT value,expire,path FROM ds091" |
700 | " WHERE key=? AND type=? AND expire >= ? LIMIT 1 OFFSET ?", | 703 | " WHERE key=? AND type=? AND expire >= ? LIMIT 1 OFFSET ?", |
701 | &plugin->get_stmt)) || | 704 | &plugin->get_stmt)) || |
702 | (SQLITE_OK != sq_prepare(plugin->dbh, | 705 | (SQLITE_OK != sq_prepare (plugin->dbh, |
703 | "SELECT _ROWID_,key,value FROM ds091" | 706 | "SELECT _ROWID_,key,value FROM ds091" |
704 | " WHERE expire < ?" | 707 | " WHERE expire < ?" |
705 | " ORDER BY expire ASC LIMIT 1", | 708 | " ORDER BY expire ASC LIMIT 1", |
706 | &plugin->del_expired_stmt)) || | 709 | &plugin->del_expired_stmt)) || |
707 | (SQLITE_OK != sq_prepare(plugin->dbh, | 710 | (SQLITE_OK != sq_prepare (plugin->dbh, |
708 | "SELECT _ROWID_,key,value FROM ds091" | 711 | "SELECT _ROWID_,key,value FROM ds091" |
709 | " ORDER BY prox ASC, expire ASC LIMIT 1", | 712 | " ORDER BY prox ASC, expire ASC LIMIT 1", |
710 | &plugin->del_select_stmt)) || | 713 | &plugin->del_select_stmt)) || |
711 | (SQLITE_OK != sq_prepare(plugin->dbh, | 714 | (SQLITE_OK != sq_prepare (plugin->dbh, |
712 | "DELETE FROM ds091 WHERE _ROWID_=?", | 715 | "DELETE FROM ds091 WHERE _ROWID_=?", |
713 | &plugin->del_stmt)) || | 716 | &plugin->del_stmt)) || |
714 | (SQLITE_OK != sq_prepare(plugin->dbh, | 717 | (SQLITE_OK != sq_prepare (plugin->dbh, |
715 | "SELECT value,expire,path,key,type FROM ds091 " | 718 | "SELECT value,expire,path,key,type FROM ds091 " |
716 | "ORDER BY key LIMIT 1 OFFSET ?", | 719 | "ORDER BY key LIMIT 1 OFFSET ?", |
717 | &plugin->get_random_stmt)) || | 720 | &plugin->get_random_stmt)) || |
718 | (SQLITE_OK != | 721 | (SQLITE_OK != |
719 | sq_prepare(plugin->dbh, | 722 | sq_prepare (plugin->dbh, |
720 | "SELECT value,expire,path,type,key FROM ds091 " | 723 | "SELECT value,expire,path,type,key FROM ds091 " |
721 | "WHERE key>=? AND expire >= ? ORDER BY KEY ASC LIMIT ?", | 724 | "WHERE key>=? AND expire >= ? ORDER BY KEY ASC LIMIT ?", |
722 | &plugin->get_closest_stmt))) | 725 | &plugin->get_closest_stmt))) |
723 | { | 726 | { |
724 | LOG_SQLITE(plugin->dbh, | 727 | LOG_SQLITE (plugin->dbh, |
725 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | 728 | GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, |
726 | "sq_prepare"); | 729 | "sq_prepare"); |
727 | GNUNET_break(SQLITE_OK == sqlite3_close(plugin->dbh)); | 730 | GNUNET_break (SQLITE_OK == sqlite3_close (plugin->dbh)); |
728 | GNUNET_free(plugin); | 731 | GNUNET_free (plugin); |
729 | return NULL; | 732 | return NULL; |
730 | } | 733 | } |
731 | 734 | ||
732 | api = GNUNET_new(struct GNUNET_DATACACHE_PluginFunctions); | 735 | api = GNUNET_new (struct GNUNET_DATACACHE_PluginFunctions); |
733 | api->cls = plugin; | 736 | api->cls = plugin; |
734 | api->get = &sqlite_plugin_get; | 737 | api->get = &sqlite_plugin_get; |
735 | api->put = &sqlite_plugin_put; | 738 | api->put = &sqlite_plugin_put; |
736 | api->del = &sqlite_plugin_del; | 739 | api->del = &sqlite_plugin_del; |
737 | api->get_random = &sqlite_plugin_get_random; | 740 | api->get_random = &sqlite_plugin_get_random; |
738 | api->get_closest = &sqlite_plugin_get_closest; | 741 | api->get_closest = &sqlite_plugin_get_closest; |
739 | LOG(GNUNET_ERROR_TYPE_INFO, "Sqlite datacache running\n"); | 742 | LOG (GNUNET_ERROR_TYPE_INFO, "Sqlite datacache running\n"); |
740 | return api; | 743 | return api; |
741 | } | 744 | } |
742 | 745 | ||
@@ -748,7 +751,7 @@ libgnunet_plugin_datacache_sqlite_init(void *cls) | |||
748 | * @return NULL | 751 | * @return NULL |
749 | */ | 752 | */ |
750 | void * | 753 | void * |
751 | libgnunet_plugin_datacache_sqlite_done(void *cls) | 754 | libgnunet_plugin_datacache_sqlite_done (void *cls) |
752 | { | 755 | { |
753 | struct GNUNET_DATACACHE_PluginFunctions *api = cls; | 756 | struct GNUNET_DATACACHE_PluginFunctions *api = cls; |
754 | struct Plugin *plugin = api->cls; | 757 | struct Plugin *plugin = api->cls; |
@@ -758,45 +761,45 @@ libgnunet_plugin_datacache_sqlite_done(void *cls) | |||
758 | sqlite3_stmt *stmt; | 761 | sqlite3_stmt *stmt; |
759 | #endif | 762 | #endif |
760 | 763 | ||
761 | #if !WINDOWS || defined(__CYGWIN__) | 764 | #if ! WINDOWS || defined(__CYGWIN__) |
762 | if ((NULL != plugin->fn) && (0 != unlink(plugin->fn))) | 765 | if ((NULL != plugin->fn) && (0 != unlink (plugin->fn))) |
763 | LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "unlink", plugin->fn); | 766 | LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "unlink", plugin->fn); |
764 | GNUNET_free_non_null(plugin->fn); | 767 | GNUNET_free_non_null (plugin->fn); |
765 | #endif | 768 | #endif |
766 | sqlite3_finalize(plugin->insert_stmt); | 769 | sqlite3_finalize (plugin->insert_stmt); |
767 | sqlite3_finalize(plugin->get_count_stmt); | 770 | sqlite3_finalize (plugin->get_count_stmt); |
768 | sqlite3_finalize(plugin->get_stmt); | 771 | sqlite3_finalize (plugin->get_stmt); |
769 | sqlite3_finalize(plugin->del_select_stmt); | 772 | sqlite3_finalize (plugin->del_select_stmt); |
770 | sqlite3_finalize(plugin->del_expired_stmt); | 773 | sqlite3_finalize (plugin->del_expired_stmt); |
771 | sqlite3_finalize(plugin->del_stmt); | 774 | sqlite3_finalize (plugin->del_stmt); |
772 | sqlite3_finalize(plugin->get_random_stmt); | 775 | sqlite3_finalize (plugin->get_random_stmt); |
773 | sqlite3_finalize(plugin->get_closest_stmt); | 776 | sqlite3_finalize (plugin->get_closest_stmt); |
774 | result = sqlite3_close(plugin->dbh); | 777 | result = sqlite3_close (plugin->dbh); |
775 | #if SQLITE_VERSION_NUMBER >= 3007000 | 778 | #if SQLITE_VERSION_NUMBER >= 3007000 |
776 | if (SQLITE_BUSY == result) | 779 | if (SQLITE_BUSY == result) |
780 | { | ||
781 | LOG (GNUNET_ERROR_TYPE_WARNING, | ||
782 | _ ( | ||
783 | "Tried to close sqlite without finalizing all prepared statements.\n")); | ||
784 | stmt = sqlite3_next_stmt (plugin->dbh, NULL); | ||
785 | while (NULL != stmt) | ||
777 | { | 786 | { |
778 | LOG(GNUNET_ERROR_TYPE_WARNING, | 787 | result = sqlite3_finalize (stmt); |
779 | _( | 788 | if (result != SQLITE_OK) |
780 | "Tried to close sqlite without finalizing all prepared statements.\n")); | 789 | LOG (GNUNET_ERROR_TYPE_WARNING, |
781 | stmt = sqlite3_next_stmt(plugin->dbh, NULL); | 790 | "Failed to close statement %p: %d\n", |
782 | while (NULL != stmt) | 791 | stmt, |
783 | { | 792 | result); |
784 | result = sqlite3_finalize(stmt); | 793 | stmt = sqlite3_next_stmt (plugin->dbh, NULL); |
785 | if (result != SQLITE_OK) | ||
786 | LOG(GNUNET_ERROR_TYPE_WARNING, | ||
787 | "Failed to close statement %p: %d\n", | ||
788 | stmt, | ||
789 | result); | ||
790 | stmt = sqlite3_next_stmt(plugin->dbh, NULL); | ||
791 | } | ||
792 | result = sqlite3_close(plugin->dbh); | ||
793 | } | 794 | } |
795 | result = sqlite3_close (plugin->dbh); | ||
796 | } | ||
794 | #endif | 797 | #endif |
795 | if (SQLITE_OK != result) | 798 | if (SQLITE_OK != result) |
796 | LOG_SQLITE(plugin->dbh, GNUNET_ERROR_TYPE_ERROR, "sqlite3_close"); | 799 | LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR, "sqlite3_close"); |
797 | 800 | ||
798 | GNUNET_free(plugin); | 801 | GNUNET_free (plugin); |
799 | GNUNET_free(api); | 802 | GNUNET_free (api); |
800 | return NULL; | 803 | return NULL; |
801 | } | 804 | } |
802 | 805 | ||