diff options
Diffstat (limited to 'src/datacache/plugin_datacache_mysql.c')
-rw-r--r-- | src/datacache/plugin_datacache_mysql.c | 769 |
1 files changed, 374 insertions, 395 deletions
diff --git a/src/datacache/plugin_datacache_mysql.c b/src/datacache/plugin_datacache_mysql.c index 8e477409e..f4530ccef 100644 --- a/src/datacache/plugin_datacache_mysql.c +++ b/src/datacache/plugin_datacache_mysql.c | |||
@@ -127,7 +127,7 @@ struct GNUNET_MysqlStatementHandle | |||
127 | /** | 127 | /** |
128 | * Context for all functions in this plugin. | 128 | * Context for all functions in this plugin. |
129 | */ | 129 | */ |
130 | struct Plugin | 130 | struct Plugin |
131 | { | 131 | { |
132 | /** | 132 | /** |
133 | * Our execution environment. | 133 | * Our execution environment. |
@@ -183,6 +183,7 @@ get_my_cnf_path (const struct GNUNET_CONFIGURATION_Handle *cfg) | |||
183 | char *cnffile; | 183 | char *cnffile; |
184 | char *home_dir; | 184 | char *home_dir; |
185 | struct stat st; | 185 | struct stat st; |
186 | |||
186 | #ifndef WINDOWS | 187 | #ifndef WINDOWS |
187 | struct passwd *pw; | 188 | struct passwd *pw; |
188 | #endif | 189 | #endif |
@@ -191,44 +192,46 @@ get_my_cnf_path (const struct GNUNET_CONFIGURATION_Handle *cfg) | |||
191 | #ifndef WINDOWS | 192 | #ifndef WINDOWS |
192 | pw = getpwuid (getuid ()); | 193 | pw = getpwuid (getuid ()); |
193 | if (!pw) | 194 | if (!pw) |
194 | { | 195 | { |
195 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, | 196 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "getpwuid"); |
196 | "getpwuid"); | 197 | return NULL; |
197 | return NULL; | 198 | } |
198 | } | ||
199 | if (GNUNET_YES == | 199 | if (GNUNET_YES == |
200 | GNUNET_CONFIGURATION_have_value (cfg, | 200 | GNUNET_CONFIGURATION_have_value (cfg, "datacache-mysql", "CONFIG")) |
201 | "datacache-mysql", "CONFIG")) | 201 | { |
202 | { | 202 | GNUNET_assert (GNUNET_OK == |
203 | GNUNET_assert (GNUNET_OK == | 203 | GNUNET_CONFIGURATION_get_value_filename (cfg, |
204 | GNUNET_CONFIGURATION_get_value_filename (cfg, | 204 | "datacache-mysql", |
205 | "datacache-mysql", "CONFIG", &cnffile)); | 205 | "CONFIG", |
206 | configured = GNUNET_YES; | 206 | &cnffile)); |
207 | } | 207 | configured = GNUNET_YES; |
208 | } | ||
208 | else | 209 | else |
209 | { | 210 | { |
210 | home_dir = GNUNET_strdup (pw->pw_dir); | 211 | home_dir = GNUNET_strdup (pw->pw_dir); |
212 | GNUNET_asprintf (&cnffile, "%s/.my.cnf", home_dir); | ||
213 | GNUNET_free (home_dir); | ||
214 | configured = GNUNET_NO; | ||
215 | } | ||
211 | #else | 216 | #else |
212 | home_dir = (char *) GNUNET_malloc (_MAX_PATH + 1); | 217 | home_dir = (char *) GNUNET_malloc (_MAX_PATH + 1); |
213 | plibc_conv_to_win_path ("~/", home_dir); | 218 | plibc_conv_to_win_path ("~/", home_dir); |
219 | GNUNET_asprintf (&cnffile, "%s/.my.cnf", home_dir); | ||
220 | GNUNET_free (home_dir); | ||
221 | configured = GNUNET_NO; | ||
214 | #endif | 222 | #endif |
215 | GNUNET_asprintf (&cnffile, "%s/.my.cnf", home_dir); | ||
216 | GNUNET_free (home_dir); | ||
217 | configured = GNUNET_NO; | ||
218 | } | ||
219 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 223 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
220 | _("Trying to use file `%s' for MySQL configuration.\n"), | 224 | _("Trying to use file `%s' for MySQL configuration.\n"), cnffile); |
221 | cnffile); | ||
222 | if ((0 != STAT (cnffile, &st)) || | 225 | if ((0 != STAT (cnffile, &st)) || |
223 | (0 != ACCESS (cnffile, R_OK)) || (!S_ISREG (st.st_mode))) | 226 | (0 != ACCESS (cnffile, R_OK)) || (!S_ISREG (st.st_mode))) |
224 | { | 227 | { |
225 | if (configured == GNUNET_YES) | 228 | if (configured == GNUNET_YES) |
226 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 229 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
227 | _("Could not access file `%s': %s\n"), cnffile, | 230 | _("Could not access file `%s': %s\n"), cnffile, |
228 | STRERROR (errno)); | 231 | STRERROR (errno)); |
229 | GNUNET_free (cnffile); | 232 | GNUNET_free (cnffile); |
230 | return NULL; | 233 | return NULL; |
231 | } | 234 | } |
232 | return cnffile; | 235 | return cnffile; |
233 | } | 236 | } |
234 | 237 | ||
@@ -240,13 +243,10 @@ get_my_cnf_path (const struct GNUNET_CONFIGURATION_Handle *cfg) | |||
240 | * @param s prepared statement | 243 | * @param s prepared statement |
241 | */ | 244 | */ |
242 | static void | 245 | static void |
243 | prepared_statement_destroy (struct Plugin *plugin, | 246 | prepared_statement_destroy (struct Plugin *plugin, |
244 | struct GNUNET_MysqlStatementHandle | 247 | struct GNUNET_MysqlStatementHandle *s) |
245 | *s) | ||
246 | { | 248 | { |
247 | GNUNET_CONTAINER_DLL_remove (plugin->shead, | 249 | GNUNET_CONTAINER_DLL_remove (plugin->shead, plugin->stail, s); |
248 | plugin->stail, | ||
249 | s); | ||
250 | if (s->valid) | 250 | if (s->valid) |
251 | mysql_stmt_close (s->statement); | 251 | mysql_stmt_close (s->statement); |
252 | GNUNET_free (s->query); | 252 | GNUNET_free (s->query); |
@@ -262,13 +262,12 @@ static int | |||
262 | iclose (struct Plugin *plugin) | 262 | iclose (struct Plugin *plugin) |
263 | { | 263 | { |
264 | while (NULL != plugin->shead) | 264 | while (NULL != plugin->shead) |
265 | prepared_statement_destroy (plugin, | 265 | prepared_statement_destroy (plugin, plugin->shead); |
266 | plugin->shead); | ||
267 | if (plugin->dbf != NULL) | 266 | if (plugin->dbf != NULL) |
268 | { | 267 | { |
269 | mysql_close (plugin->dbf); | 268 | mysql_close (plugin->dbf); |
270 | plugin->dbf = NULL; | 269 | plugin->dbf = NULL; |
271 | } | 270 | } |
272 | return GNUNET_OK; | 271 | return GNUNET_OK; |
273 | } | 272 | } |
274 | 273 | ||
@@ -298,71 +297,75 @@ iopen (struct Plugin *ret) | |||
298 | mysql_options (ret->dbf, MYSQL_READ_DEFAULT_GROUP, "client"); | 297 | mysql_options (ret->dbf, MYSQL_READ_DEFAULT_GROUP, "client"); |
299 | reconnect = 0; | 298 | reconnect = 0; |
300 | mysql_options (ret->dbf, MYSQL_OPT_RECONNECT, &reconnect); | 299 | mysql_options (ret->dbf, MYSQL_OPT_RECONNECT, &reconnect); |
301 | mysql_options (ret->dbf, | 300 | mysql_options (ret->dbf, MYSQL_OPT_CONNECT_TIMEOUT, (const void *) &timeout); |
302 | MYSQL_OPT_CONNECT_TIMEOUT, (const void *) &timeout); | 301 | mysql_options (ret->dbf, MYSQL_SET_CHARSET_NAME, "UTF8"); |
303 | mysql_options(ret->dbf, MYSQL_SET_CHARSET_NAME, "UTF8"); | 302 | timeout = 60; /* in seconds */ |
304 | timeout = 60; /* in seconds */ | ||
305 | mysql_options (ret->dbf, MYSQL_OPT_READ_TIMEOUT, (const void *) &timeout); | 303 | mysql_options (ret->dbf, MYSQL_OPT_READ_TIMEOUT, (const void *) &timeout); |
306 | mysql_options (ret->dbf, MYSQL_OPT_WRITE_TIMEOUT, (const void *) &timeout); | 304 | mysql_options (ret->dbf, MYSQL_OPT_WRITE_TIMEOUT, (const void *) &timeout); |
307 | mysql_dbname = NULL; | 305 | mysql_dbname = NULL; |
308 | if (GNUNET_YES == GNUNET_CONFIGURATION_have_value (ret->env->cfg, | 306 | if (GNUNET_YES == GNUNET_CONFIGURATION_have_value (ret->env->cfg, |
309 | "datacache-mysql", "DATABASE")) | 307 | "datacache-mysql", |
310 | GNUNET_assert (GNUNET_OK == | 308 | "DATABASE")) |
311 | GNUNET_CONFIGURATION_get_value_string (ret->env->cfg, | 309 | GNUNET_assert (GNUNET_OK == |
312 | "datacache-mysql", "DATABASE", | 310 | GNUNET_CONFIGURATION_get_value_string (ret->env->cfg, |
313 | &mysql_dbname)); | 311 | "datacache-mysql", |
312 | "DATABASE", | ||
313 | &mysql_dbname)); | ||
314 | else | 314 | else |
315 | mysql_dbname = GNUNET_strdup ("gnunet"); | 315 | mysql_dbname = GNUNET_strdup ("gnunet"); |
316 | mysql_user = NULL; | 316 | mysql_user = NULL; |
317 | if (GNUNET_YES == GNUNET_CONFIGURATION_have_value (ret->env->cfg, | 317 | if (GNUNET_YES == GNUNET_CONFIGURATION_have_value (ret->env->cfg, |
318 | "datacache-mysql", "USER")) | 318 | "datacache-mysql", "USER")) |
319 | { | 319 | { |
320 | GNUNET_assert (GNUNET_OK == | 320 | GNUNET_assert (GNUNET_OK == |
321 | GNUNET_CONFIGURATION_get_value_string (ret->env->cfg, | 321 | GNUNET_CONFIGURATION_get_value_string (ret->env->cfg, |
322 | "datacache-mysql", "USER", | 322 | "datacache-mysql", |
323 | &mysql_user)); | 323 | "USER", &mysql_user)); |
324 | } | 324 | } |
325 | mysql_password = NULL; | 325 | mysql_password = NULL; |
326 | if (GNUNET_YES == GNUNET_CONFIGURATION_have_value (ret->env->cfg, | 326 | if (GNUNET_YES == GNUNET_CONFIGURATION_have_value (ret->env->cfg, |
327 | "datacache-mysql", "PASSWORD")) | 327 | "datacache-mysql", |
328 | { | 328 | "PASSWORD")) |
329 | GNUNET_assert (GNUNET_OK == | 329 | { |
330 | GNUNET_CONFIGURATION_get_value_string (ret->env->cfg, | 330 | GNUNET_assert (GNUNET_OK == |
331 | "datacache-mysql", "PASSWORD", | 331 | GNUNET_CONFIGURATION_get_value_string (ret->env->cfg, |
332 | &mysql_password)); | 332 | "datacache-mysql", |
333 | } | 333 | "PASSWORD", |
334 | &mysql_password)); | ||
335 | } | ||
334 | mysql_server = NULL; | 336 | mysql_server = NULL; |
335 | if (GNUNET_YES == GNUNET_CONFIGURATION_have_value (ret->env->cfg, | 337 | if (GNUNET_YES == GNUNET_CONFIGURATION_have_value (ret->env->cfg, |
336 | "datacache-mysql", "HOST")) | 338 | "datacache-mysql", "HOST")) |
337 | { | 339 | { |
338 | GNUNET_assert (GNUNET_OK == | 340 | GNUNET_assert (GNUNET_OK == |
339 | GNUNET_CONFIGURATION_get_value_string (ret->env->cfg, | 341 | GNUNET_CONFIGURATION_get_value_string (ret->env->cfg, |
340 | "datacache-mysql", "HOST", | 342 | "datacache-mysql", |
341 | &mysql_server)); | 343 | "HOST", |
342 | } | 344 | &mysql_server)); |
345 | } | ||
343 | mysql_port = 0; | 346 | mysql_port = 0; |
344 | if (GNUNET_YES == GNUNET_CONFIGURATION_have_value (ret->env->cfg, | 347 | if (GNUNET_YES == GNUNET_CONFIGURATION_have_value (ret->env->cfg, |
345 | "datacache-mysql", "PORT")) | 348 | "datacache-mysql", "PORT")) |
346 | { | 349 | { |
347 | GNUNET_assert (GNUNET_OK == | 350 | GNUNET_assert (GNUNET_OK == |
348 | GNUNET_CONFIGURATION_get_value_number (ret->env->cfg, "datacache-mysql", | 351 | GNUNET_CONFIGURATION_get_value_number (ret->env->cfg, |
349 | "PORT", &mysql_port)); | 352 | "datacache-mysql", |
350 | } | 353 | "PORT", &mysql_port)); |
354 | } | ||
351 | 355 | ||
352 | GNUNET_assert (mysql_dbname != NULL); | 356 | GNUNET_assert (mysql_dbname != NULL); |
353 | mysql_real_connect (ret->dbf, mysql_server, mysql_user, mysql_password, | 357 | mysql_real_connect (ret->dbf, mysql_server, mysql_user, mysql_password, |
354 | mysql_dbname, (unsigned int) mysql_port, NULL, | 358 | mysql_dbname, (unsigned int) mysql_port, NULL, |
355 | CLIENT_IGNORE_SIGPIPE); | 359 | CLIENT_IGNORE_SIGPIPE); |
356 | GNUNET_free_non_null (mysql_server); | 360 | GNUNET_free_non_null (mysql_server); |
357 | GNUNET_free_non_null (mysql_user); | 361 | GNUNET_free_non_null (mysql_user); |
358 | GNUNET_free_non_null (mysql_password); | 362 | GNUNET_free_non_null (mysql_password); |
359 | GNUNET_free (mysql_dbname); | 363 | GNUNET_free (mysql_dbname); |
360 | if (mysql_error (ret->dbf)[0]) | 364 | if (mysql_error (ret->dbf)[0]) |
361 | { | 365 | { |
362 | LOG_MYSQL (GNUNET_ERROR_TYPE_ERROR, | 366 | LOG_MYSQL (GNUNET_ERROR_TYPE_ERROR, "mysql_real_connect", ret); |
363 | "mysql_real_connect", ret); | 367 | return GNUNET_SYSERR; |
364 | return GNUNET_SYSERR; | 368 | } |
365 | } | ||
366 | return GNUNET_OK; | 369 | return GNUNET_OK; |
367 | } | 370 | } |
368 | 371 | ||
@@ -373,19 +376,17 @@ iopen (struct Plugin *ret) | |||
373 | * @return GNUNET_OK on success, GNUNET_SYSERR on error | 376 | * @return GNUNET_OK on success, GNUNET_SYSERR on error |
374 | */ | 377 | */ |
375 | static int | 378 | static int |
376 | run_statement (struct Plugin *plugin, | 379 | run_statement (struct Plugin *plugin, const char *statement) |
377 | const char *statement) | ||
378 | { | 380 | { |
379 | if ((NULL == plugin->dbf) && (GNUNET_OK != iopen (plugin))) | 381 | if ((NULL == plugin->dbf) && (GNUNET_OK != iopen (plugin))) |
380 | return GNUNET_SYSERR; | 382 | return GNUNET_SYSERR; |
381 | mysql_query (plugin->dbf, statement); | 383 | mysql_query (plugin->dbf, statement); |
382 | if (mysql_error (plugin->dbf)[0]) | 384 | if (mysql_error (plugin->dbf)[0]) |
383 | { | 385 | { |
384 | LOG_MYSQL (GNUNET_ERROR_TYPE_ERROR, | 386 | LOG_MYSQL (GNUNET_ERROR_TYPE_ERROR, "mysql_query", plugin); |
385 | "mysql_query", plugin); | 387 | iclose (plugin); |
386 | iclose (plugin); | 388 | return GNUNET_SYSERR; |
387 | return GNUNET_SYSERR; | 389 | } |
388 | } | ||
389 | return GNUNET_OK; | 390 | return GNUNET_OK; |
390 | } | 391 | } |
391 | 392 | ||
@@ -395,16 +396,13 @@ run_statement (struct Plugin *plugin, | |||
395 | * @return NULL on error | 396 | * @return NULL on error |
396 | */ | 397 | */ |
397 | static struct GNUNET_MysqlStatementHandle * | 398 | static struct GNUNET_MysqlStatementHandle * |
398 | prepared_statement_create (struct Plugin *plugin, | 399 | prepared_statement_create (struct Plugin *plugin, const char *statement) |
399 | const char *statement) | ||
400 | { | 400 | { |
401 | struct GNUNET_MysqlStatementHandle *ret; | 401 | struct GNUNET_MysqlStatementHandle *ret; |
402 | 402 | ||
403 | ret = GNUNET_malloc (sizeof (struct GNUNET_MysqlStatementHandle)); | 403 | ret = GNUNET_malloc (sizeof (struct GNUNET_MysqlStatementHandle)); |
404 | ret->query = GNUNET_strdup (statement); | 404 | ret->query = GNUNET_strdup (statement); |
405 | GNUNET_CONTAINER_DLL_insert (plugin->shead, | 405 | GNUNET_CONTAINER_DLL_insert (plugin->shead, plugin->stail, ret); |
406 | plugin->stail, | ||
407 | ret); | ||
408 | return ret; | 406 | return ret; |
409 | } | 407 | } |
410 | 408 | ||
@@ -415,32 +413,27 @@ prepared_statement_create (struct Plugin *plugin, | |||
415 | * @return GNUNET_OK on success | 413 | * @return GNUNET_OK on success |
416 | */ | 414 | */ |
417 | static int | 415 | static int |
418 | prepare_statement (struct Plugin *plugin, | 416 | prepare_statement (struct Plugin *plugin, |
419 | struct GNUNET_MysqlStatementHandle *ret) | 417 | struct GNUNET_MysqlStatementHandle *ret) |
420 | { | 418 | { |
421 | if (GNUNET_YES == ret->valid) | 419 | if (GNUNET_YES == ret->valid) |
422 | return GNUNET_OK; | 420 | return GNUNET_OK; |
423 | if ((NULL == plugin->dbf) && | 421 | if ((NULL == plugin->dbf) && (GNUNET_OK != iopen (plugin))) |
424 | (GNUNET_OK != iopen (plugin))) | ||
425 | return GNUNET_SYSERR; | 422 | return GNUNET_SYSERR; |
426 | ret->statement = mysql_stmt_init (plugin->dbf); | 423 | ret->statement = mysql_stmt_init (plugin->dbf); |
427 | if (ret->statement == NULL) | 424 | if (ret->statement == NULL) |
428 | { | 425 | { |
429 | iclose (plugin); | 426 | iclose (plugin); |
430 | return GNUNET_SYSERR; | 427 | return GNUNET_SYSERR; |
431 | } | 428 | } |
432 | if (mysql_stmt_prepare (ret->statement, | 429 | if (mysql_stmt_prepare (ret->statement, ret->query, strlen (ret->query))) |
433 | ret->query, | 430 | { |
434 | strlen (ret->query))) | 431 | LOG_MYSQL (GNUNET_ERROR_TYPE_ERROR, "mysql_stmt_prepare", plugin); |
435 | { | 432 | mysql_stmt_close (ret->statement); |
436 | LOG_MYSQL (GNUNET_ERROR_TYPE_ERROR, | 433 | ret->statement = NULL; |
437 | "mysql_stmt_prepare", | 434 | iclose (plugin); |
438 | plugin); | 435 | return GNUNET_SYSERR; |
439 | mysql_stmt_close (ret->statement); | 436 | } |
440 | ret->statement = NULL; | ||
441 | iclose (plugin); | ||
442 | return GNUNET_SYSERR; | ||
443 | } | ||
444 | ret->valid = GNUNET_YES; | 437 | ret->valid = GNUNET_YES; |
445 | return GNUNET_OK; | 438 | return GNUNET_OK; |
446 | 439 | ||
@@ -458,8 +451,7 @@ prepare_statement (struct Plugin *plugin, | |||
458 | */ | 451 | */ |
459 | static int | 452 | static int |
460 | init_params (struct Plugin *plugin, | 453 | init_params (struct Plugin *plugin, |
461 | struct GNUNET_MysqlStatementHandle *s, | 454 | struct GNUNET_MysqlStatementHandle *s, va_list ap) |
462 | va_list ap) | ||
463 | { | 455 | { |
464 | MYSQL_BIND qbind[MAX_PARAM]; | 456 | MYSQL_BIND qbind[MAX_PARAM]; |
465 | unsigned int pc; | 457 | unsigned int pc; |
@@ -468,68 +460,72 @@ init_params (struct Plugin *plugin, | |||
468 | 460 | ||
469 | pc = mysql_stmt_param_count (s->statement); | 461 | pc = mysql_stmt_param_count (s->statement); |
470 | if (pc > MAX_PARAM) | 462 | if (pc > MAX_PARAM) |
471 | { | 463 | { |
472 | /* increase internal constant! */ | 464 | /* increase internal constant! */ |
473 | GNUNET_break (0); | 465 | GNUNET_break (0); |
474 | return GNUNET_SYSERR; | 466 | return GNUNET_SYSERR; |
475 | } | 467 | } |
476 | memset (qbind, 0, sizeof (qbind)); | 468 | memset (qbind, 0, sizeof (qbind)); |
477 | off = 0; | 469 | off = 0; |
478 | ft = 0; | 470 | ft = 0; |
479 | while ( (pc > 0) && (-1 != (int) (ft = va_arg (ap, enum enum_field_types))) ) | 471 | while ((pc > 0) && (-1 != (int) (ft = va_arg (ap, enum enum_field_types)))) |
480 | { | 472 | { |
481 | qbind[off].buffer_type = ft; | 473 | qbind[off].buffer_type = ft; |
482 | switch (ft) | 474 | switch (ft) |
483 | { | ||
484 | case MYSQL_TYPE_FLOAT: | ||
485 | qbind[off].buffer = va_arg (ap, float *); | ||
486 | break; | ||
487 | case MYSQL_TYPE_LONGLONG: | ||
488 | qbind[off].buffer = va_arg (ap, unsigned long long *); | ||
489 | qbind[off].is_unsigned = va_arg (ap, int); | ||
490 | break; | ||
491 | case MYSQL_TYPE_LONG: | ||
492 | qbind[off].buffer = va_arg (ap, unsigned int *); | ||
493 | qbind[off].is_unsigned = va_arg (ap, int); | ||
494 | break; | ||
495 | case MYSQL_TYPE_VAR_STRING: | ||
496 | case MYSQL_TYPE_STRING: | ||
497 | case MYSQL_TYPE_BLOB: | ||
498 | qbind[off].buffer = va_arg (ap, void *); | ||
499 | qbind[off].buffer_length = va_arg (ap, unsigned long); | ||
500 | qbind[off].length = va_arg (ap, unsigned long *); | ||
501 | break; | ||
502 | default: | ||
503 | /* unsupported type */ | ||
504 | GNUNET_break (0); | ||
505 | return GNUNET_SYSERR; | ||
506 | } | ||
507 | pc--; | ||
508 | off++; | ||
509 | } | ||
510 | if (! ( (pc == 0) && (-1 != (int) ft) && (va_arg (ap, int) == -1)) ) | ||
511 | { | 475 | { |
476 | case MYSQL_TYPE_FLOAT: | ||
477 | qbind[off].buffer = va_arg (ap, float *); | ||
478 | |||
479 | break; | ||
480 | case MYSQL_TYPE_LONGLONG: | ||
481 | qbind[off].buffer = va_arg (ap, unsigned long long *); | ||
482 | qbind[off].is_unsigned = va_arg (ap, int); | ||
483 | |||
484 | break; | ||
485 | case MYSQL_TYPE_LONG: | ||
486 | qbind[off].buffer = va_arg (ap, unsigned int *); | ||
487 | qbind[off].is_unsigned = va_arg (ap, int); | ||
488 | |||
489 | break; | ||
490 | case MYSQL_TYPE_VAR_STRING: | ||
491 | case MYSQL_TYPE_STRING: | ||
492 | case MYSQL_TYPE_BLOB: | ||
493 | qbind[off].buffer = va_arg (ap, void *); | ||
494 | qbind[off].buffer_length = va_arg (ap, unsigned long); | ||
495 | qbind[off].length = va_arg (ap, unsigned long *); | ||
496 | |||
497 | break; | ||
498 | default: | ||
499 | /* unsupported type */ | ||
512 | GNUNET_break (0); | 500 | GNUNET_break (0); |
513 | return GNUNET_SYSERR; | 501 | return GNUNET_SYSERR; |
514 | } | 502 | } |
503 | pc--; | ||
504 | off++; | ||
505 | } | ||
506 | if (!((pc == 0) && (-1 != (int) ft) && (va_arg (ap, int) == -1))) | ||
507 | { | ||
508 | GNUNET_break (0); | ||
509 | return GNUNET_SYSERR; | ||
510 | } | ||
515 | if (mysql_stmt_bind_param (s->statement, qbind)) | 511 | if (mysql_stmt_bind_param (s->statement, qbind)) |
516 | { | 512 | { |
517 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 513 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
518 | _("`%s' failed at %s:%d with error: %s\n"), | 514 | _("`%s' failed at %s:%d with error: %s\n"), |
519 | "mysql_stmt_bind_param", | 515 | "mysql_stmt_bind_param", |
520 | __FILE__, __LINE__, mysql_stmt_error (s->statement)); | 516 | __FILE__, __LINE__, mysql_stmt_error (s->statement)); |
521 | iclose (plugin); | 517 | iclose (plugin); |
522 | return GNUNET_SYSERR; | 518 | return GNUNET_SYSERR; |
523 | } | 519 | } |
524 | if (mysql_stmt_execute (s->statement)) | 520 | if (mysql_stmt_execute (s->statement)) |
525 | { | 521 | { |
526 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 522 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
527 | _("`%s' failed at %s:%d with error: %s\n"), | 523 | _("`%s' failed at %s:%d with error: %s\n"), |
528 | "mysql_stmt_execute", | 524 | "mysql_stmt_execute", |
529 | __FILE__, __LINE__, mysql_stmt_error (s->statement)); | 525 | __FILE__, __LINE__, mysql_stmt_error (s->statement)); |
530 | iclose (plugin); | 526 | iclose (plugin); |
531 | return GNUNET_SYSERR; | 527 | return GNUNET_SYSERR; |
532 | } | 528 | } |
533 | return GNUNET_OK; | 529 | return GNUNET_OK; |
534 | } | 530 | } |
535 | 531 | ||
@@ -565,13 +561,12 @@ typedef int (*GNUNET_MysqlDataProcessor) (void *cls, | |||
565 | */ | 561 | */ |
566 | static int | 562 | static int |
567 | prepared_statement_run_select (struct Plugin *plugin, | 563 | prepared_statement_run_select (struct Plugin *plugin, |
568 | struct GNUNET_MysqlStatementHandle | 564 | struct GNUNET_MysqlStatementHandle |
569 | *s, | 565 | *s, |
570 | unsigned int result_size, | 566 | unsigned int result_size, |
571 | MYSQL_BIND * results, | 567 | MYSQL_BIND * results, |
572 | GNUNET_MysqlDataProcessor | 568 | GNUNET_MysqlDataProcessor |
573 | processor, void *processor_cls, | 569 | processor, void *processor_cls, ...) |
574 | ...) | ||
575 | { | 570 | { |
576 | va_list ap; | 571 | va_list ap; |
577 | int ret; | 572 | int ret; |
@@ -579,54 +574,54 @@ prepared_statement_run_select (struct Plugin *plugin, | |||
579 | int total; | 574 | int total; |
580 | 575 | ||
581 | if (GNUNET_OK != prepare_statement (plugin, s)) | 576 | if (GNUNET_OK != prepare_statement (plugin, s)) |
582 | { | 577 | { |
583 | GNUNET_break (0); | 578 | GNUNET_break (0); |
584 | return GNUNET_SYSERR; | 579 | return GNUNET_SYSERR; |
585 | } | 580 | } |
586 | va_start (ap, processor_cls); | 581 | va_start (ap, processor_cls); |
587 | if (GNUNET_OK != init_params (plugin, s, ap)) | 582 | if (GNUNET_OK != init_params (plugin, s, ap)) |
588 | { | 583 | { |
589 | GNUNET_break (0); | 584 | GNUNET_break (0); |
590 | va_end (ap); | 585 | va_end (ap); |
591 | return GNUNET_SYSERR; | 586 | return GNUNET_SYSERR; |
592 | } | 587 | } |
593 | va_end (ap); | 588 | va_end (ap); |
594 | rsize = mysql_stmt_field_count (s->statement); | 589 | rsize = mysql_stmt_field_count (s->statement); |
595 | if (rsize > result_size) | 590 | if (rsize > result_size) |
596 | { | 591 | { |
597 | GNUNET_break (0); | 592 | GNUNET_break (0); |
598 | return GNUNET_SYSERR; | 593 | return GNUNET_SYSERR; |
599 | } | 594 | } |
600 | if (mysql_stmt_bind_result (s->statement, results)) | 595 | if (mysql_stmt_bind_result (s->statement, results)) |
596 | { | ||
597 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
598 | _("`%s' failed at %s:%d with error: %s\n"), | ||
599 | "mysql_stmt_bind_result", | ||
600 | __FILE__, __LINE__, mysql_stmt_error (s->statement)); | ||
601 | iclose (plugin); | ||
602 | return GNUNET_SYSERR; | ||
603 | } | ||
604 | |||
605 | total = 0; | ||
606 | while (1) | ||
607 | { | ||
608 | ret = mysql_stmt_fetch (s->statement); | ||
609 | if (ret == MYSQL_NO_DATA) | ||
610 | break; | ||
611 | if (ret != 0) | ||
601 | { | 612 | { |
602 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 613 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
603 | _("`%s' failed at %s:%d with error: %s\n"), | 614 | _("`%s' failed at %s:%d with error: %s\n"), |
604 | "mysql_stmt_bind_result", | 615 | "mysql_stmt_fetch", |
605 | __FILE__, __LINE__, mysql_stmt_error (s->statement)); | 616 | __FILE__, __LINE__, mysql_stmt_error (s->statement)); |
606 | iclose (plugin); | 617 | iclose (plugin); |
607 | return GNUNET_SYSERR; | 618 | return GNUNET_SYSERR; |
608 | } | 619 | } |
609 | 620 | if (processor != NULL) | |
610 | total = 0; | 621 | if (GNUNET_OK != processor (processor_cls, rsize, results)) |
611 | while (1) | ||
612 | { | ||
613 | ret = mysql_stmt_fetch (s->statement); | ||
614 | if (ret == MYSQL_NO_DATA) | ||
615 | break; | 622 | break; |
616 | if (ret != 0) | 623 | total++; |
617 | { | 624 | } |
618 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
619 | _("`%s' failed at %s:%d with error: %s\n"), | ||
620 | "mysql_stmt_fetch", | ||
621 | __FILE__, __LINE__, mysql_stmt_error (s->statement)); | ||
622 | iclose (plugin); | ||
623 | return GNUNET_SYSERR; | ||
624 | } | ||
625 | if (processor != NULL) | ||
626 | if (GNUNET_OK != processor (processor_cls, rsize, results)) | ||
627 | break; | ||
628 | total++; | ||
629 | } | ||
630 | mysql_stmt_reset (s->statement); | 625 | mysql_stmt_reset (s->statement); |
631 | return total; | 626 | return total; |
632 | } | 627 | } |
@@ -648,8 +643,8 @@ prepared_statement_run_select (struct Plugin *plugin, | |||
648 | */ | 643 | */ |
649 | static int | 644 | static int |
650 | prepared_statement_run (struct Plugin *plugin, | 645 | prepared_statement_run (struct Plugin *plugin, |
651 | struct GNUNET_MysqlStatementHandle *s, | 646 | struct GNUNET_MysqlStatementHandle *s, |
652 | unsigned long long *insert_id, ...) | 647 | unsigned long long *insert_id, ...) |
653 | { | 648 | { |
654 | va_list ap; | 649 | va_list ap; |
655 | int affected; | 650 | int affected; |
@@ -658,10 +653,10 @@ prepared_statement_run (struct Plugin *plugin, | |||
658 | return GNUNET_SYSERR; | 653 | return GNUNET_SYSERR; |
659 | va_start (ap, insert_id); | 654 | va_start (ap, insert_id); |
660 | if (GNUNET_OK != init_params (plugin, s, ap)) | 655 | if (GNUNET_OK != init_params (plugin, s, ap)) |
661 | { | 656 | { |
662 | va_end (ap); | 657 | va_end (ap); |
663 | return GNUNET_SYSERR; | 658 | return GNUNET_SYSERR; |
664 | } | 659 | } |
665 | va_end (ap); | 660 | va_end (ap); |
666 | affected = mysql_stmt_affected_rows (s->statement); | 661 | affected = mysql_stmt_affected_rows (s->statement); |
667 | if (NULL != insert_id) | 662 | if (NULL != insert_id) |
@@ -718,13 +713,13 @@ itable (struct Plugin *plugin) | |||
718 | * @param discard_time when to discard the value in any case | 713 | * @param discard_time when to discard the value in any case |
719 | * @return 0 on error, number of bytes used otherwise | 714 | * @return 0 on error, number of bytes used otherwise |
720 | */ | 715 | */ |
721 | static size_t | 716 | static size_t |
722 | mysql_plugin_put (void *cls, | 717 | mysql_plugin_put (void *cls, |
723 | const GNUNET_HashCode * key, | 718 | const GNUNET_HashCode * key, |
724 | size_t size, | 719 | size_t size, |
725 | const char *data, | 720 | const char *data, |
726 | enum GNUNET_BLOCK_Type type, | 721 | enum GNUNET_BLOCK_Type type, |
727 | struct GNUNET_TIME_Absolute discard_time) | 722 | struct GNUNET_TIME_Absolute discard_time) |
728 | { | 723 | { |
729 | struct Plugin *plugin = cls; | 724 | struct Plugin *plugin = cls; |
730 | struct GNUNET_TIME_Absolute now; | 725 | struct GNUNET_TIME_Absolute now; |
@@ -751,25 +746,23 @@ mysql_plugin_put (void *cls, | |||
751 | v_discard_time = (unsigned long long) discard_time.abs_value; | 746 | v_discard_time = (unsigned long long) discard_time.abs_value; |
752 | if (GNUNET_OK == | 747 | if (GNUNET_OK == |
753 | prepared_statement_run (plugin, | 748 | prepared_statement_run (plugin, |
754 | plugin->update_value, | 749 | plugin->update_value, |
755 | NULL, | 750 | NULL, |
756 | MYSQL_TYPE_LONGLONG, | 751 | MYSQL_TYPE_LONGLONG, |
757 | &v_now, | 752 | &v_now, |
758 | GNUNET_YES, | 753 | GNUNET_YES, |
759 | MYSQL_TYPE_LONGLONG, | 754 | MYSQL_TYPE_LONGLONG, |
760 | &v_discard_time, | 755 | &v_discard_time, |
761 | GNUNET_YES, | 756 | GNUNET_YES, |
762 | MYSQL_TYPE_BLOB, | 757 | MYSQL_TYPE_BLOB, |
763 | key, | 758 | key, |
764 | sizeof (GNUNET_HashCode), | 759 | sizeof (GNUNET_HashCode), |
765 | &k_length, | 760 | &k_length, |
766 | MYSQL_TYPE_BLOB, | 761 | MYSQL_TYPE_BLOB, |
767 | &vhash, | 762 | &vhash, |
768 | sizeof (GNUNET_HashCode), | 763 | sizeof (GNUNET_HashCode), |
769 | &h_length, | 764 | &h_length, |
770 | MYSQL_TYPE_LONG, | 765 | MYSQL_TYPE_LONG, &v_type, GNUNET_YES, -1)) |
771 | &v_type, | ||
772 | GNUNET_YES, -1)) | ||
773 | return GNUNET_OK; | 766 | return GNUNET_OK; |
774 | 767 | ||
775 | /* now try INSERT */ | 768 | /* now try INSERT */ |
@@ -778,34 +771,33 @@ mysql_plugin_put (void *cls, | |||
778 | v_length = size; | 771 | v_length = size; |
779 | if (GNUNET_OK != | 772 | if (GNUNET_OK != |
780 | (ret = prepared_statement_run (plugin, | 773 | (ret = prepared_statement_run (plugin, |
781 | plugin->insert_value, | 774 | plugin->insert_value, |
782 | NULL, | 775 | NULL, |
783 | MYSQL_TYPE_LONG, | 776 | MYSQL_TYPE_LONG, |
784 | &type, | 777 | &type, |
785 | GNUNET_YES, | 778 | GNUNET_YES, |
786 | MYSQL_TYPE_LONGLONG, | 779 | MYSQL_TYPE_LONGLONG, |
787 | &v_now, | 780 | &v_now, |
788 | GNUNET_YES, | 781 | GNUNET_YES, |
789 | MYSQL_TYPE_LONGLONG, | 782 | MYSQL_TYPE_LONGLONG, |
790 | &v_discard_time, | 783 | &v_discard_time, |
791 | GNUNET_YES, | 784 | GNUNET_YES, |
792 | MYSQL_TYPE_BLOB, | 785 | MYSQL_TYPE_BLOB, |
793 | key, | 786 | key, |
794 | sizeof (GNUNET_HashCode), | 787 | sizeof (GNUNET_HashCode), |
795 | &k_length, | 788 | &k_length, |
796 | MYSQL_TYPE_BLOB, | 789 | MYSQL_TYPE_BLOB, |
797 | &vhash, | 790 | &vhash, |
798 | sizeof (GNUNET_HashCode), | 791 | sizeof (GNUNET_HashCode), |
799 | &h_length, | 792 | &h_length, |
800 | MYSQL_TYPE_BLOB, | 793 | MYSQL_TYPE_BLOB, |
801 | data, | 794 | data, |
802 | (unsigned long) size, | 795 | (unsigned long) size, &v_length, -1))) |
803 | &v_length, -1))) | 796 | { |
804 | { | 797 | if (ret == GNUNET_SYSERR) |
805 | if (ret == GNUNET_SYSERR) | 798 | itable (plugin); |
806 | itable (plugin); | 799 | return GNUNET_SYSERR; |
807 | return GNUNET_SYSERR; | 800 | } |
808 | } | ||
809 | return size + OVERHEAD; | 801 | return size + OVERHEAD; |
810 | } | 802 | } |
811 | 803 | ||
@@ -828,12 +820,11 @@ return_ok (void *cls, unsigned int num_values, MYSQL_BIND * values) | |||
828 | * @param iter_cls closure for iter | 820 | * @param iter_cls closure for iter |
829 | * @return the number of results found | 821 | * @return the number of results found |
830 | */ | 822 | */ |
831 | static unsigned int | 823 | static unsigned int |
832 | mysql_plugin_get (void *cls, | 824 | mysql_plugin_get (void *cls, |
833 | const GNUNET_HashCode * key, | 825 | const GNUNET_HashCode * key, |
834 | enum GNUNET_BLOCK_Type type, | 826 | enum GNUNET_BLOCK_Type type, |
835 | GNUNET_DATACACHE_Iterator iter, | 827 | GNUNET_DATACACHE_Iterator iter, void *iter_cls) |
836 | void *iter_cls) | ||
837 | { | 828 | { |
838 | struct Plugin *plugin = cls; | 829 | struct Plugin *plugin = cls; |
839 | MYSQL_BIND rbind[3]; | 830 | MYSQL_BIND rbind[3]; |
@@ -862,79 +853,72 @@ mysql_plugin_get (void *cls, | |||
862 | v_now = (unsigned long long) now.abs_value; | 853 | v_now = (unsigned long long) now.abs_value; |
863 | if ((GNUNET_OK != | 854 | if ((GNUNET_OK != |
864 | (ret = prepared_statement_run_select (plugin, | 855 | (ret = prepared_statement_run_select (plugin, |
865 | plugin->count_value, | 856 | plugin->count_value, |
866 | 1, | 857 | 1, |
867 | rbind, | 858 | rbind, |
868 | return_ok, | 859 | return_ok, |
869 | NULL, | 860 | NULL, |
870 | MYSQL_TYPE_BLOB, | 861 | MYSQL_TYPE_BLOB, |
871 | key, | 862 | key, |
872 | sizeof | 863 | sizeof |
873 | (GNUNET_HashCode), | 864 | (GNUNET_HashCode), |
874 | &h_length, | 865 | &h_length, |
875 | MYSQL_TYPE_LONG, | 866 | MYSQL_TYPE_LONG, |
876 | &v_type, GNUNET_YES, | 867 | &v_type, GNUNET_YES, |
877 | MYSQL_TYPE_LONGLONG, | 868 | MYSQL_TYPE_LONGLONG, |
878 | &v_now, GNUNET_YES, | 869 | &v_now, GNUNET_YES, |
879 | -1))) | 870 | -1))) || (-1 == total)) |
880 | || (-1 == total)) | 871 | { |
881 | { | 872 | if (ret == GNUNET_SYSERR) |
882 | if (ret == GNUNET_SYSERR) | 873 | itable (plugin); |
883 | itable (plugin); | 874 | return GNUNET_SYSERR; |
884 | return GNUNET_SYSERR; | 875 | } |
885 | } | ||
886 | if ((iter == NULL) || (total == 0)) | 876 | if ((iter == NULL) || (total == 0)) |
887 | return (int) total; | 877 | return (int) total; |
888 | 878 | ||
889 | off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, total); | 879 | off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, total); |
890 | cnt = 0; | 880 | cnt = 0; |
891 | while (cnt < total) | 881 | while (cnt < total) |
882 | { | ||
883 | memset (rbind, 0, sizeof (rbind)); | ||
884 | rbind[0].buffer_type = MYSQL_TYPE_BLOB; | ||
885 | rbind[0].buffer_length = sizeof (buffer); | ||
886 | rbind[0].length = &v_length; | ||
887 | rbind[0].buffer = buffer; | ||
888 | rbind[1].buffer_type = MYSQL_TYPE_LONGLONG; | ||
889 | rbind[1].is_unsigned = 1; | ||
890 | rbind[1].buffer = &v_expire; | ||
891 | off = (off + 1) % total; | ||
892 | if (GNUNET_OK != | ||
893 | (ret = prepared_statement_run_select (plugin, | ||
894 | plugin->select_value, | ||
895 | 2, | ||
896 | rbind, | ||
897 | return_ok, | ||
898 | NULL, | ||
899 | MYSQL_TYPE_BLOB, | ||
900 | key, | ||
901 | sizeof | ||
902 | (GNUNET_HashCode), | ||
903 | &h_length, | ||
904 | MYSQL_TYPE_LONG, | ||
905 | &v_type, | ||
906 | GNUNET_YES, | ||
907 | MYSQL_TYPE_LONGLONG, | ||
908 | &v_now, | ||
909 | GNUNET_YES, | ||
910 | MYSQL_TYPE_LONG, | ||
911 | &off, GNUNET_YES, -1))) | ||
892 | { | 912 | { |
893 | memset (rbind, 0, sizeof (rbind)); | 913 | if (ret == GNUNET_SYSERR) |
894 | rbind[0].buffer_type = MYSQL_TYPE_BLOB; | 914 | itable (plugin); |
895 | rbind[0].buffer_length = sizeof (buffer); | 915 | return GNUNET_SYSERR; |
896 | rbind[0].length = &v_length; | ||
897 | rbind[0].buffer = buffer; | ||
898 | rbind[1].buffer_type = MYSQL_TYPE_LONGLONG; | ||
899 | rbind[1].is_unsigned = 1; | ||
900 | rbind[1].buffer = &v_expire; | ||
901 | off = (off + 1) % total; | ||
902 | if (GNUNET_OK != | ||
903 | (ret = prepared_statement_run_select (plugin, | ||
904 | plugin->select_value, | ||
905 | 2, | ||
906 | rbind, | ||
907 | return_ok, | ||
908 | NULL, | ||
909 | MYSQL_TYPE_BLOB, | ||
910 | key, | ||
911 | sizeof | ||
912 | (GNUNET_HashCode), | ||
913 | &h_length, | ||
914 | MYSQL_TYPE_LONG, | ||
915 | &v_type, | ||
916 | GNUNET_YES, | ||
917 | MYSQL_TYPE_LONGLONG, | ||
918 | &v_now, | ||
919 | GNUNET_YES, | ||
920 | MYSQL_TYPE_LONG, | ||
921 | &off, | ||
922 | GNUNET_YES, | ||
923 | -1))) | ||
924 | { | ||
925 | if (ret == GNUNET_SYSERR) | ||
926 | itable (plugin); | ||
927 | return GNUNET_SYSERR; | ||
928 | } | ||
929 | cnt++; | ||
930 | expire.abs_value = v_expire; | ||
931 | if (GNUNET_OK != iter (iter_cls, | ||
932 | expire, | ||
933 | key, | ||
934 | v_length, buffer, | ||
935 | type)) | ||
936 | break; | ||
937 | } | 916 | } |
917 | cnt++; | ||
918 | expire.abs_value = v_expire; | ||
919 | if (GNUNET_OK != iter (iter_cls, expire, key, v_length, buffer, type)) | ||
920 | break; | ||
921 | } | ||
938 | return cnt; | 922 | return cnt; |
939 | } | 923 | } |
940 | 924 | ||
@@ -945,8 +929,8 @@ mysql_plugin_get (void *cls, | |||
945 | * | 929 | * |
946 | * @param cls closure (our "struct Plugin") | 930 | * @param cls closure (our "struct Plugin") |
947 | * @return GNUNET_OK on success, GNUNET_SYSERR on error | 931 | * @return GNUNET_OK on success, GNUNET_SYSERR on error |
948 | */ | 932 | */ |
949 | static int | 933 | static int |
950 | mysql_plugin_del (void *cls) | 934 | mysql_plugin_del (void *cls) |
951 | { | 935 | { |
952 | struct Plugin *plugin = cls; | 936 | struct Plugin *plugin = cls; |
@@ -982,40 +966,37 @@ mysql_plugin_del (void *cls) | |||
982 | rbind[3].buffer = buffer; | 966 | rbind[3].buffer = buffer; |
983 | if ((GNUNET_OK != | 967 | if ((GNUNET_OK != |
984 | (ret = prepared_statement_run_select (plugin, | 968 | (ret = prepared_statement_run_select (plugin, |
985 | plugin->select_old_value, | 969 | plugin->select_old_value, |
986 | 4, | 970 | 4, |
987 | rbind, | 971 | rbind, |
988 | return_ok, | 972 | return_ok, |
989 | NULL, | 973 | NULL, |
990 | -1))) || | 974 | -1))) || |
991 | (GNUNET_OK != | 975 | (GNUNET_OK != |
992 | (ret = prepared_statement_run (plugin, | 976 | (ret = prepared_statement_run (plugin, |
993 | plugin->delete_value, | 977 | plugin->delete_value, |
994 | NULL, | 978 | NULL, |
995 | MYSQL_TYPE_BLOB, | 979 | MYSQL_TYPE_BLOB, |
996 | &v_key, | 980 | &v_key, |
997 | sizeof (GNUNET_HashCode), | 981 | sizeof (GNUNET_HashCode), |
998 | &k_length, | 982 | &k_length, |
999 | MYSQL_TYPE_BLOB, | 983 | MYSQL_TYPE_BLOB, |
1000 | &vhash, | 984 | &vhash, |
1001 | sizeof (GNUNET_HashCode), | 985 | sizeof (GNUNET_HashCode), |
1002 | &h_length, | 986 | &h_length, |
1003 | MYSQL_TYPE_LONG, | 987 | MYSQL_TYPE_LONG, |
1004 | &v_type, | 988 | &v_type, |
1005 | GNUNET_YES, | 989 | GNUNET_YES, |
1006 | MYSQL_TYPE_BLOB, | 990 | MYSQL_TYPE_BLOB, |
1007 | buffer, | 991 | buffer, |
1008 | (unsigned long) | 992 | (unsigned long) |
1009 | sizeof (buffer), | 993 | sizeof (buffer), &v_length, -1)))) |
1010 | &v_length, -1)))) | 994 | { |
1011 | { | 995 | if (ret == GNUNET_SYSERR) |
1012 | if (ret == GNUNET_SYSERR) | 996 | itable (plugin); |
1013 | itable (plugin); | 997 | return GNUNET_SYSERR; |
1014 | return GNUNET_SYSERR; | 998 | } |
1015 | } | 999 | plugin->env->delete_notify (plugin->env->cls, &v_key, v_length + OVERHEAD); |
1016 | plugin->env->delete_notify (plugin->env->cls, | ||
1017 | &v_key, | ||
1018 | v_length + OVERHEAD); | ||
1019 | 1000 | ||
1020 | return GNUNET_OK; | 1001 | return GNUNET_OK; |
1021 | } | 1002 | } |
@@ -1037,21 +1018,19 @@ libgnunet_plugin_datacache_mysql_init (void *cls) | |||
1037 | plugin = GNUNET_malloc (sizeof (struct Plugin)); | 1018 | plugin = GNUNET_malloc (sizeof (struct Plugin)); |
1038 | plugin->env = env; | 1019 | plugin->env = env; |
1039 | plugin->cnffile = get_my_cnf_path (env->cfg); | 1020 | plugin->cnffile = get_my_cnf_path (env->cfg); |
1040 | if (GNUNET_OK != | 1021 | if (GNUNET_OK != iopen (plugin)) |
1041 | iopen (plugin)) | 1022 | { |
1042 | { | 1023 | GNUNET_free_non_null (plugin->cnffile); |
1043 | GNUNET_free_non_null (plugin->cnffile); | 1024 | GNUNET_free (plugin); |
1044 | GNUNET_free (plugin); | 1025 | return NULL; |
1045 | return NULL; | 1026 | } |
1046 | } | 1027 | if (GNUNET_OK != itable (plugin)) |
1047 | if (GNUNET_OK != | 1028 | { |
1048 | itable (plugin)) | 1029 | iclose (plugin); |
1049 | { | 1030 | GNUNET_free_non_null (plugin->cnffile); |
1050 | iclose (plugin); | 1031 | GNUNET_free (plugin); |
1051 | GNUNET_free_non_null (plugin->cnffile); | 1032 | return NULL; |
1052 | GNUNET_free (plugin); | 1033 | } |
1053 | return NULL; | ||
1054 | } | ||
1055 | api = GNUNET_malloc (sizeof (struct GNUNET_DATACACHE_PluginFunctions)); | 1034 | api = GNUNET_malloc (sizeof (struct GNUNET_DATACACHE_PluginFunctions)); |
1056 | api->cls = plugin; | 1035 | api->cls = plugin; |
1057 | api->get = &mysql_plugin_get; | 1036 | api->get = &mysql_plugin_get; |