aboutsummaryrefslogtreecommitdiff
path: root/src/dht/plugin_dhtlog_mysql.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/dht/plugin_dhtlog_mysql.c')
-rw-r--r--src/dht/plugin_dhtlog_mysql.c1071
1 files changed, 556 insertions, 515 deletions
diff --git a/src/dht/plugin_dhtlog_mysql.c b/src/dht/plugin_dhtlog_mysql.c
index 8e4357b1c..c653f912a 100644
--- a/src/dht/plugin_dhtlog_mysql.c
+++ b/src/dht/plugin_dhtlog_mysql.c
@@ -188,11 +188,10 @@ run_statement (const char *statement)
188{ 188{
189 mysql_query (conn, statement); 189 mysql_query (conn, statement);
190 if (mysql_error (conn)[0]) 190 if (mysql_error (conn)[0])
191 { 191 {
192 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 192 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "mysql_query");
193 "mysql_query"); 193 return GNUNET_SYSERR;
194 return GNUNET_SYSERR; 194 }
195 }
196 return GNUNET_OK; 195 return GNUNET_OK;
197} 196}
198 197
@@ -253,46 +252,46 @@ itable ()
253 return GNUNET_SYSERR; 252 return GNUNET_SYSERR;
254 253
255 if (MRUNS ("CREATE TABLE IF NOT EXISTS `trials` (" 254 if (MRUNS ("CREATE TABLE IF NOT EXISTS `trials` ("
256 "`trialuid` int(10) unsigned NOT NULL auto_increment," 255 "`trialuid` int(10) unsigned NOT NULL auto_increment,"
257 "`other_trial_identifier` int(10) unsigned NOT NULL default '0'," 256 "`other_trial_identifier` int(10) unsigned NOT NULL default '0',"
258 "`numnodes` int(10) unsigned NOT NULL," 257 "`numnodes` int(10) unsigned NOT NULL,"
259 "`topology` int(10) NOT NULL," 258 "`topology` int(10) NOT NULL,"
260 "`blacklist_topology` int(11) NOT NULL," 259 "`blacklist_topology` int(11) NOT NULL,"
261 "`connect_topology` int(11) NOT NULL," 260 "`connect_topology` int(11) NOT NULL,"
262 "`connect_topology_option` int(11) NOT NULL," 261 "`connect_topology_option` int(11) NOT NULL,"
263 "`topology_percentage` float NOT NULL," 262 "`topology_percentage` float NOT NULL,"
264 "`topology_probability` float NOT NULL," 263 "`topology_probability` float NOT NULL,"
265 "`connect_topology_option_modifier` float NOT NULL," 264 "`connect_topology_option_modifier` float NOT NULL,"
266 "`starttime` datetime NOT NULL," 265 "`starttime` datetime NOT NULL,"
267 "`endtime` datetime NOT NULL," 266 "`endtime` datetime NOT NULL,"
268 "`puts` int(10) unsigned NOT NULL," 267 "`puts` int(10) unsigned NOT NULL,"
269 "`gets` int(10) unsigned NOT NULL," 268 "`gets` int(10) unsigned NOT NULL,"
270 "`concurrent` int(10) unsigned NOT NULL," 269 "`concurrent` int(10) unsigned NOT NULL,"
271 "`settle_time` int(10) unsigned NOT NULL," 270 "`settle_time` int(10) unsigned NOT NULL,"
272 "`totalConnections` int(10) unsigned NOT NULL," 271 "`totalConnections` int(10) unsigned NOT NULL,"
273 "`message` text NOT NULL," 272 "`message` text NOT NULL,"
274 "`num_rounds` int(10) unsigned NOT NULL," 273 "`num_rounds` int(10) unsigned NOT NULL,"
275 "`malicious_getters` int(10) unsigned NOT NULL," 274 "`malicious_getters` int(10) unsigned NOT NULL,"
276 "`malicious_putters` int(10) unsigned NOT NULL," 275 "`malicious_putters` int(10) unsigned NOT NULL,"
277 "`malicious_droppers` int(10) unsigned NOT NULL," 276 "`malicious_droppers` int(10) unsigned NOT NULL,"
278 "`topology_modifier` double NOT NULL," 277 "`topology_modifier` double NOT NULL,"
279 "`malicious_get_frequency` int(10) unsigned NOT NULL," 278 "`malicious_get_frequency` int(10) unsigned NOT NULL,"
280 "`malicious_put_frequency` int(10) unsigned NOT NULL," 279 "`malicious_put_frequency` int(10) unsigned NOT NULL,"
281 "`stop_closest` int(10) unsigned NOT NULL," 280 "`stop_closest` int(10) unsigned NOT NULL,"
282 "`stop_found` int(10) unsigned NOT NULL," 281 "`stop_found` int(10) unsigned NOT NULL,"
283 "`strict_kademlia` int(10) unsigned NOT NULL," 282 "`strict_kademlia` int(10) unsigned NOT NULL,"
284 "`gets_succeeded` int(10) unsigned NOT NULL," 283 "`gets_succeeded` int(10) unsigned NOT NULL,"
285 "PRIMARY KEY (`trialuid`)," 284 "PRIMARY KEY (`trialuid`),"
286 "UNIQUE KEY `trialuid` (`trialuid`)" 285 "UNIQUE KEY `trialuid` (`trialuid`)"
287 ") ENGINE=MyISAM DEFAULT CHARSET=utf8 AUTO_INCREMENT=1")) 286 ") ENGINE=MyISAM DEFAULT CHARSET=utf8 AUTO_INCREMENT=1"))
288 return GNUNET_SYSERR; 287 return GNUNET_SYSERR;
289 288
290 if (MRUNS ("CREATE TABLE IF NOT EXISTS `topology` (" 289 if (MRUNS ("CREATE TABLE IF NOT EXISTS `topology` ("
291 "`topology_uid` int(10) unsigned NOT NULL AUTO_INCREMENT," 290 "`topology_uid` int(10) unsigned NOT NULL AUTO_INCREMENT,"
292 "`trialuid` int(10) unsigned NOT NULL," 291 "`trialuid` int(10) unsigned NOT NULL,"
293 "`date` datetime NOT NULL," 292 "`date` datetime NOT NULL,"
294 "`connections` int(10) unsigned NOT NULL," 293 "`connections` int(10) unsigned NOT NULL,"
295 "PRIMARY KEY (`topology_uid`)) ENGINE=MyISAM DEFAULT CHARSET=utf8 AUTO_INCREMENT=1")) 294 "PRIMARY KEY (`topology_uid`)) ENGINE=MyISAM DEFAULT CHARSET=utf8 AUTO_INCREMENT=1"))
296 return GNUNET_SYSERR; 295 return GNUNET_SYSERR;
297 296
298 if (MRUNS ("CREATE TABLE IF NOT EXISTS `extended_topology` (" 297 if (MRUNS ("CREATE TABLE IF NOT EXISTS `extended_topology` ("
@@ -305,27 +304,27 @@ itable ()
305 return GNUNET_SYSERR; 304 return GNUNET_SYSERR;
306 305
307 if (MRUNS ("CREATE TABLE IF NOT EXISTS `node_statistics` (" 306 if (MRUNS ("CREATE TABLE IF NOT EXISTS `node_statistics` ("
308 "`stat_uid` int(10) unsigned NOT NULL AUTO_INCREMENT," 307 "`stat_uid` int(10) unsigned NOT NULL AUTO_INCREMENT,"
309 "`trialuid` int(10) unsigned NOT NULL," 308 "`trialuid` int(10) unsigned NOT NULL,"
310 "`nodeuid` int(10) unsigned NOT NULL," 309 "`nodeuid` int(10) unsigned NOT NULL,"
311 "`route_requests` int(10) unsigned NOT NULL," 310 "`route_requests` int(10) unsigned NOT NULL,"
312 "`route_forwards` int(10) unsigned NOT NULL," 311 "`route_forwards` int(10) unsigned NOT NULL,"
313 "`result_requests` int(10) unsigned NOT NULL," 312 "`result_requests` int(10) unsigned NOT NULL,"
314 "`client_results` int(10) unsigned NOT NULL," 313 "`client_results` int(10) unsigned NOT NULL,"
315 "`result_forwards` int(10) unsigned NOT NULL," 314 "`result_forwards` int(10) unsigned NOT NULL,"
316 "`gets` int(10) unsigned NOT NULL," 315 "`gets` int(10) unsigned NOT NULL,"
317 "`puts` int(10) unsigned NOT NULL," 316 "`puts` int(10) unsigned NOT NULL,"
318 "`data_inserts` int(10) unsigned NOT NULL," 317 "`data_inserts` int(10) unsigned NOT NULL,"
319 "`find_peer_requests` int(10) unsigned NOT NULL," 318 "`find_peer_requests` int(10) unsigned NOT NULL,"
320 "`find_peers_started` int(10) unsigned NOT NULL," 319 "`find_peers_started` int(10) unsigned NOT NULL,"
321 "`gets_started` int(10) unsigned NOT NULL," 320 "`gets_started` int(10) unsigned NOT NULL,"
322 "`puts_started` int(10) unsigned NOT NULL," 321 "`puts_started` int(10) unsigned NOT NULL,"
323 "`find_peer_responses_received` int(10) unsigned NOT NULL," 322 "`find_peer_responses_received` int(10) unsigned NOT NULL,"
324 "`get_responses_received` int(10) unsigned NOT NULL," 323 "`get_responses_received` int(10) unsigned NOT NULL,"
325 "`find_peer_responses_sent` int(10) unsigned NOT NULL," 324 "`find_peer_responses_sent` int(10) unsigned NOT NULL,"
326 "`get_responses_sent` int(10) unsigned NOT NULL," 325 "`get_responses_sent` int(10) unsigned NOT NULL,"
327 "PRIMARY KEY (`stat_uid`)" 326 "PRIMARY KEY (`stat_uid`)"
328 ") ENGINE=MyISAM DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;")) 327 ") ENGINE=MyISAM DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;"))
329 return GNUNET_SYSERR; 328 return GNUNET_SYSERR;
330 329
331 if (MRUNS ("SET AUTOCOMMIT = 1")) 330 if (MRUNS ("SET AUTOCOMMIT = 1"))
@@ -359,15 +358,15 @@ void
359prepared_statement_close (struct StatementHandle *s) 358prepared_statement_close (struct StatementHandle *s)
360{ 359{
361 if (s == NULL) 360 if (s == NULL)
362 { 361 {
363 return; 362 return;
364 } 363 }
365 364
366 GNUNET_free_non_null(s->query); 365 GNUNET_free_non_null (s->query);
367 366
368 if (s->valid == GNUNET_YES) 367 if (s->valid == GNUNET_YES)
369 mysql_stmt_close(s->statement); 368 mysql_stmt_close (s->statement);
370 GNUNET_free(s); 369 GNUNET_free (s);
371} 370}
372 371
373/* 372/*
@@ -390,61 +389,65 @@ iopen (struct GNUNET_DHTLOG_Plugin *plugin)
390 return GNUNET_SYSERR; 389 return GNUNET_SYSERR;
391 390
392 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (plugin->cfg, 391 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (plugin->cfg,
393 "MYSQL", "DATABASE", 392 "MYSQL", "DATABASE",
394 &database)) 393 &database))
395 { 394 {
396 database = GNUNET_strdup("gnunet"); 395 database = GNUNET_strdup ("gnunet");
397 } 396 }
398 397
399 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (plugin->cfg, 398 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (plugin->cfg,
400 "MYSQL", "USER", &user)) 399 "MYSQL", "USER",
401 { 400 &user))
402 user = GNUNET_strdup("dht"); 401 {
403 } 402 user = GNUNET_strdup ("dht");
403 }
404 404
405 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (plugin->cfg, 405 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (plugin->cfg,
406 "MYSQL", "PASSWORD", &password)) 406 "MYSQL", "PASSWORD",
407 { 407 &password))
408 password = GNUNET_strdup("dhttest**"); 408 {
409 } 409 password = GNUNET_strdup ("dhttest**");
410 }
410 411
411 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (plugin->cfg, 412 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (plugin->cfg,
412 "MYSQL", "SERVER", &server)) 413 "MYSQL", "SERVER",
413 { 414 &server))
414 server = GNUNET_strdup("localhost"); 415 {
415 } 416 server = GNUNET_strdup ("localhost");
417 }
416 418
417 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (plugin->cfg, 419 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (plugin->cfg,
418 "MYSQL", "MYSQL_PORT", &port)) 420 "MYSQL", "MYSQL_PORT",
419 { 421 &port))
420 port = 0; 422 {
421 } 423 port = 0;
424 }
422 425
423 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to mysql with: user %s, pass %s, server %s, database %s, port %d\n", 426 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
427 "Connecting to mysql with: user %s, pass %s, server %s, database %s, port %d\n",
424 user, password, server, database, port); 428 user, password, server, database, port);
425 429
426 reconnect = 0; 430 reconnect = 0;
427 timeout = 60; /* in seconds */ 431 timeout = 60; /* in seconds */
428 mysql_options (conn, MYSQL_OPT_RECONNECT, &reconnect); 432 mysql_options (conn, MYSQL_OPT_RECONNECT, &reconnect);
429 mysql_options (conn, 433 mysql_options (conn, MYSQL_OPT_CONNECT_TIMEOUT, (const void *) &timeout);
430 MYSQL_OPT_CONNECT_TIMEOUT, (const void *) &timeout); 434 mysql_options (conn, MYSQL_SET_CHARSET_NAME, "UTF8");
431 mysql_options(conn, MYSQL_SET_CHARSET_NAME, "UTF8");
432 mysql_options (conn, MYSQL_OPT_READ_TIMEOUT, (const void *) &timeout); 435 mysql_options (conn, MYSQL_OPT_READ_TIMEOUT, (const void *) &timeout);
433 mysql_options (conn, MYSQL_OPT_WRITE_TIMEOUT, (const void *) &timeout); 436 mysql_options (conn, MYSQL_OPT_WRITE_TIMEOUT, (const void *) &timeout);
434 mysql_real_connect (conn, server, user, password, 437 mysql_real_connect (conn, server, user, password,
435 database, (unsigned int) port, NULL, CLIENT_IGNORE_SIGPIPE); 438 database, (unsigned int) port, NULL,
439 CLIENT_IGNORE_SIGPIPE);
436 440
437 GNUNET_free_non_null(server); 441 GNUNET_free_non_null (server);
438 GNUNET_free_non_null(password); 442 GNUNET_free_non_null (password);
439 GNUNET_free_non_null(user); 443 GNUNET_free_non_null (user);
440 GNUNET_free_non_null(database); 444 GNUNET_free_non_null (database);
441 445
442 if (mysql_error (conn)[0]) 446 if (mysql_error (conn)[0])
443 { 447 {
444 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 448 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "mysql_real_connect");
445 "mysql_real_connect"); 449 return GNUNET_SYSERR;
446 return GNUNET_SYSERR; 450 }
447 }
448 451
449#if OLD 452#if OLD
450 db = GNUNET_MYSQL_database_open (coreAPI->ectx, coreAPI->cfg); 453 db = GNUNET_MYSQL_database_open (coreAPI->ectx, coreAPI->cfg);
@@ -473,10 +476,10 @@ iopen (struct GNUNET_DHTLOG_Plugin *plugin)
473 PINIT (insert_topology, INSERT_TOPOLOGY_STMT) || 476 PINIT (insert_topology, INSERT_TOPOLOGY_STMT) ||
474 PINIT (update_topology, UPDATE_TOPOLOGY_STMT) || 477 PINIT (update_topology, UPDATE_TOPOLOGY_STMT) ||
475 PINIT (extend_topology, EXTEND_TOPOLOGY_STMT) || 478 PINIT (extend_topology, EXTEND_TOPOLOGY_STMT) ||
476 PINIT (update_node_malicious, SET_MALICIOUS_STMT) ) 479 PINIT (update_node_malicious, SET_MALICIOUS_STMT))
477 { 480 {
478 return GNUNET_SYSERR; 481 return GNUNET_SYSERR;
479 } 482 }
480#undef PINIT 483#undef PINIT
481 484
482 return ret; 485 return ret;
@@ -504,13 +507,13 @@ prepare_statement (struct StatementHandle *ret)
504 return GNUNET_SYSERR; 507 return GNUNET_SYSERR;
505 508
506 if (mysql_stmt_prepare (ret->statement, ret->query, strlen (ret->query))) 509 if (mysql_stmt_prepare (ret->statement, ret->query, strlen (ret->query)))
507 { 510 {
508 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 511 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
509 "mysql_stmt_prepare `%s', %s", ret->query, mysql_error(conn)); 512 "mysql_stmt_prepare `%s', %s", ret->query, mysql_error (conn));
510 mysql_stmt_close (ret->statement); 513 mysql_stmt_close (ret->statement);
511 ret->statement = NULL; 514 ret->statement = NULL;
512 return GNUNET_SYSERR; 515 return GNUNET_SYSERR;
513 } 516 }
514 ret->valid = GNUNET_YES; 517 ret->valid = GNUNET_YES;
515 return GNUNET_OK; 518 return GNUNET_OK;
516} 519}
@@ -533,67 +536,71 @@ init_params (struct StatementHandle *s, va_list ap)
533 536
534 pc = mysql_stmt_param_count (s->statement); 537 pc = mysql_stmt_param_count (s->statement);
535 if (pc > MAX_PARAM) 538 if (pc > MAX_PARAM)
536 { 539 {
537 /* increase internal constant! */ 540 /* increase internal constant! */
538 GNUNET_break (0); 541 GNUNET_break (0);
539 return GNUNET_SYSERR; 542 return GNUNET_SYSERR;
540 } 543 }
541 memset (qbind, 0, sizeof (qbind)); 544 memset (qbind, 0, sizeof (qbind));
542 off = 0; 545 off = 0;
543 ft = 0; 546 ft = 0;
544 while ((pc > 0) && (-1 != (ft = va_arg (ap, enum enum_field_types)))) 547 while ((pc > 0) && (-1 != (ft = va_arg (ap, enum enum_field_types))))
548 {
549 qbind[off].buffer_type = ft;
550 switch (ft)
545 { 551 {
546 qbind[off].buffer_type = ft; 552 case MYSQL_TYPE_FLOAT:
547 switch (ft) 553 qbind[off].buffer = va_arg (ap, float *);
548 { 554
549 case MYSQL_TYPE_FLOAT: 555 break;
550 qbind[off].buffer = va_arg (ap, float *); 556 case MYSQL_TYPE_LONGLONG:
551 break; 557 qbind[off].buffer = va_arg (ap, unsigned long long *);
552 case MYSQL_TYPE_LONGLONG: 558 qbind[off].is_unsigned = va_arg (ap, int);
553 qbind[off].buffer = va_arg (ap, unsigned long long *); 559
554 qbind[off].is_unsigned = va_arg (ap, int); 560 break;
555 break; 561 case MYSQL_TYPE_LONG:
556 case MYSQL_TYPE_LONG: 562 qbind[off].buffer = va_arg (ap, unsigned int *);
557 qbind[off].buffer = va_arg (ap, unsigned int *); 563 qbind[off].is_unsigned = va_arg (ap, int);
558 qbind[off].is_unsigned = va_arg (ap, int); 564
559 break; 565 break;
560 case MYSQL_TYPE_VAR_STRING: 566 case MYSQL_TYPE_VAR_STRING:
561 case MYSQL_TYPE_STRING: 567 case MYSQL_TYPE_STRING:
562 case MYSQL_TYPE_BLOB: 568 case MYSQL_TYPE_BLOB:
563 qbind[off].buffer = va_arg (ap, void *); 569 qbind[off].buffer = va_arg (ap, void *);
564 qbind[off].buffer_length = va_arg (ap, unsigned long); 570 qbind[off].buffer_length = va_arg (ap, unsigned long);
565 qbind[off].length = va_arg (ap, unsigned long *); 571 qbind[off].length = va_arg (ap, unsigned long *);
566 break; 572
567 default: 573 break;
568 /* unsupported type */ 574 default:
569 GNUNET_break (0); 575 /* unsupported type */
570 return GNUNET_SYSERR;
571 }
572 pc--;
573 off++;
574 }
575 if (!((pc == 0) && (ft != -1) && (va_arg (ap, int) == -1)))
576 {
577 GNUNET_break (0); 576 GNUNET_break (0);
578 return GNUNET_SYSERR; 577 return GNUNET_SYSERR;
579 } 578 }
579 pc--;
580 off++;
581 }
582 if (!((pc == 0) && (ft != -1) && (va_arg (ap, int) == -1)))
583 {
584 GNUNET_break (0);
585 return GNUNET_SYSERR;
586 }
580 if (mysql_stmt_bind_param (s->statement, qbind)) 587 if (mysql_stmt_bind_param (s->statement, qbind))
581 { 588 {
582 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 589 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
583 _("`%s' failed at %s:%d with error: %s\n"), 590 _("`%s' failed at %s:%d with error: %s\n"),
584 "mysql_stmt_bind_param", 591 "mysql_stmt_bind_param",
585 __FILE__, __LINE__, mysql_stmt_error (s->statement)); 592 __FILE__, __LINE__, mysql_stmt_error (s->statement));
586 return GNUNET_SYSERR; 593 return GNUNET_SYSERR;
587 } 594 }
588 595
589 if (mysql_stmt_execute (s->statement)) 596 if (mysql_stmt_execute (s->statement))
590 { 597 {
591 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 598 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
592 _("`%s' failed at %s:%d with error: %s\n"), 599 _("`%s' failed at %s:%d with error: %s\n"),
593 "mysql_stmt_execute", 600 "mysql_stmt_execute",
594 __FILE__, __LINE__, mysql_stmt_error (s->statement)); 601 __FILE__, __LINE__, mysql_stmt_error (s->statement));
595 return GNUNET_SYSERR; 602 return GNUNET_SYSERR;
596 } 603 }
597 604
598 return GNUNET_OK; 605 return GNUNET_OK;
599} 606}
@@ -619,8 +626,7 @@ prepared_statement_run_select (struct StatementHandle *s,
619 unsigned int result_size, 626 unsigned int result_size,
620 MYSQL_BIND * results, 627 MYSQL_BIND * results,
621 GNUNET_MysqlDataProcessor 628 GNUNET_MysqlDataProcessor
622 processor, void *processor_cls, 629 processor, void *processor_cls, ...)
623 ...)
624{ 630{
625 va_list ap; 631 va_list ap;
626 int ret; 632 int ret;
@@ -628,52 +634,52 @@ prepared_statement_run_select (struct StatementHandle *s,
628 int total; 634 int total;
629 635
630 if (GNUNET_OK != prepare_statement (s)) 636 if (GNUNET_OK != prepare_statement (s))
631 { 637 {
632 GNUNET_break (0); 638 GNUNET_break (0);
633 return GNUNET_SYSERR; 639 return GNUNET_SYSERR;
634 } 640 }
635 va_start (ap, processor_cls); 641 va_start (ap, processor_cls);
636 if (GNUNET_OK != init_params (s, ap)) 642 if (GNUNET_OK != init_params (s, ap))
637 { 643 {
638 GNUNET_break (0); 644 GNUNET_break (0);
639 va_end (ap); 645 va_end (ap);
640 return GNUNET_SYSERR; 646 return GNUNET_SYSERR;
641 } 647 }
642 va_end (ap); 648 va_end (ap);
643 rsize = mysql_stmt_field_count (s->statement); 649 rsize = mysql_stmt_field_count (s->statement);
644 if (rsize > result_size) 650 if (rsize > result_size)
645 { 651 {
646 GNUNET_break (0); 652 GNUNET_break (0);
647 return GNUNET_SYSERR; 653 return GNUNET_SYSERR;
648 } 654 }
649 if (mysql_stmt_bind_result (s->statement, results)) 655 if (mysql_stmt_bind_result (s->statement, results))
656 {
657 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
658 _("`%s' failed at %s:%d with error: %s\n"),
659 "mysql_stmt_bind_result",
660 __FILE__, __LINE__, mysql_stmt_error (s->statement));
661 return GNUNET_SYSERR;
662 }
663
664 total = 0;
665 while (1)
666 {
667 ret = mysql_stmt_fetch (s->statement);
668 if (ret == MYSQL_NO_DATA)
669 break;
670 if (ret != 0)
650 { 671 {
651 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 672 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
652 _("`%s' failed at %s:%d with error: %s\n"), 673 _("`%s' failed at %s:%d with error: %s\n"),
653 "mysql_stmt_bind_result", 674 "mysql_stmt_fetch",
654 __FILE__, __LINE__, mysql_stmt_error (s->statement)); 675 __FILE__, __LINE__, mysql_stmt_error (s->statement));
655 return GNUNET_SYSERR; 676 return GNUNET_SYSERR;
656 } 677 }
657 678 if (processor != NULL)
658 total = 0; 679 if (GNUNET_OK != processor (processor_cls, rsize, results))
659 while (1)
660 {
661 ret = mysql_stmt_fetch (s->statement);
662 if (ret == MYSQL_NO_DATA)
663 break; 680 break;
664 if (ret != 0) 681 total++;
665 { 682 }
666 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
667 _("`%s' failed at %s:%d with error: %s\n"),
668 "mysql_stmt_fetch",
669 __FILE__, __LINE__, mysql_stmt_error (s->statement));
670 return GNUNET_SYSERR;
671 }
672 if (processor != NULL)
673 if (GNUNET_OK != processor (processor_cls, rsize, results))
674 break;
675 total++;
676 }
677 mysql_stmt_reset (s->statement); 683 mysql_stmt_reset (s->statement);
678 return total; 684 return total;
679} 685}
@@ -695,23 +701,22 @@ get_node_uid (unsigned long long *nodeuid, const GNUNET_HashCode * peerHash)
695 p_len = strlen ((char *) &encPeer); 701 p_len = strlen ((char *) &encPeer);
696 702
697 if (1 != prepared_statement_run_select (get_nodeuid, 703 if (1 != prepared_statement_run_select (get_nodeuid,
698 1, 704 1,
699 rbind, 705 rbind,
700 return_ok, 706 return_ok,
701 NULL, 707 NULL,
702 MYSQL_TYPE_LONGLONG, 708 MYSQL_TYPE_LONGLONG,
703 &current_trial, 709 &current_trial,
704 GNUNET_YES, 710 GNUNET_YES,
705 MYSQL_TYPE_VAR_STRING, 711 MYSQL_TYPE_VAR_STRING,
706 &encPeer, 712 &encPeer,
707 max_varchar_len, 713 max_varchar_len, &p_len, -1))
708 &p_len, -1)) 714 {
709 {
710#if DEBUG_DHTLOG 715#if DEBUG_DHTLOG
711 fprintf (stderr, "FAILED\n"); 716 fprintf (stderr, "FAILED\n");
712#endif 717#endif
713 return GNUNET_SYSERR; 718 return GNUNET_SYSERR;
714 } 719 }
715 return GNUNET_OK; 720 return GNUNET_OK;
716} 721}
717 722
@@ -727,12 +732,10 @@ get_current_trial (unsigned long long *trialuid)
727 732
728 if ((GNUNET_OK != 733 if ((GNUNET_OK !=
729 prepared_statement_run_select (get_trial, 734 prepared_statement_run_select (get_trial,
730 1, 735 1, rbind, return_ok, NULL, -1)))
731 rbind, 736 {
732 return_ok, NULL, -1))) 737 return GNUNET_SYSERR;
733 { 738 }
734 return GNUNET_SYSERR;
735 }
736 739
737 return GNUNET_OK; 740 return GNUNET_OK;
738} 741}
@@ -749,12 +752,10 @@ get_current_topology (unsigned long long *topologyuid)
749 752
750 if ((GNUNET_OK != 753 if ((GNUNET_OK !=
751 prepared_statement_run_select (get_topology, 754 prepared_statement_run_select (get_topology,
752 1, 755 1, rbind, return_ok, NULL, -1)))
753 rbind, 756 {
754 return_ok, NULL, -1))) 757 return GNUNET_SYSERR;
755 { 758 }
756 return GNUNET_SYSERR;
757 }
758 759
759 return GNUNET_OK; 760 return GNUNET_OK;
760} 761}
@@ -765,6 +766,7 @@ get_dhtkey_uid (unsigned long long *dhtkeyuid, const GNUNET_HashCode * key)
765 MYSQL_BIND rbind[1]; 766 MYSQL_BIND rbind[1];
766 struct GNUNET_CRYPTO_HashAsciiEncoded encKey; 767 struct GNUNET_CRYPTO_HashAsciiEncoded encKey;
767 unsigned long long k_len; 768 unsigned long long k_len;
769
768 memset (rbind, 0, sizeof (rbind)); 770 memset (rbind, 0, sizeof (rbind));
769 rbind[0].buffer_type = MYSQL_TYPE_LONG; 771 rbind[0].buffer_type = MYSQL_TYPE_LONG;
770 rbind[0].is_unsigned = 1; 772 rbind[0].is_unsigned = 1;
@@ -772,7 +774,9 @@ get_dhtkey_uid (unsigned long long *dhtkeyuid, const GNUNET_HashCode * key)
772 GNUNET_CRYPTO_hash_to_enc (key, &encKey); 774 GNUNET_CRYPTO_hash_to_enc (key, &encKey);
773 k_len = strlen ((char *) &encKey); 775 k_len = strlen ((char *) &encKey);
774#if DEBUG_DHTLOG 776#if DEBUG_DHTLOG
775 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Searching for dhtkey `%s' in trial %llu\n", GNUNET_h2s(key), current_trial); 777 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
778 "Searching for dhtkey `%s' in trial %llu\n", GNUNET_h2s (key),
779 current_trial);
776#endif 780#endif
777 if ((GNUNET_OK != 781 if ((GNUNET_OK !=
778 prepared_statement_run_select (get_dhtkeyuid, 782 prepared_statement_run_select (get_dhtkeyuid,
@@ -784,11 +788,10 @@ get_dhtkey_uid (unsigned long long *dhtkeyuid, const GNUNET_HashCode * key)
784 max_varchar_len, 788 max_varchar_len,
785 &k_len, 789 &k_len,
786 MYSQL_TYPE_LONGLONG, 790 MYSQL_TYPE_LONGLONG,
787 &current_trial, 791 &current_trial, GNUNET_YES, -1)))
788 GNUNET_YES, -1))) 792 {
789 { 793 return GNUNET_SYSERR;
790 return GNUNET_SYSERR; 794 }
791 }
792 795
793 return GNUNET_OK; 796 return GNUNET_OK;
794} 797}
@@ -813,22 +816,22 @@ prepared_statement_run (struct StatementHandle *s,
813 va_list ap; 816 va_list ap;
814 int affected; 817 int affected;
815 818
816 if (GNUNET_OK != prepare_statement(s)) 819 if (GNUNET_OK != prepare_statement (s))
817 { 820 {
818 GNUNET_break(0); 821 GNUNET_break (0);
819 return GNUNET_SYSERR; 822 return GNUNET_SYSERR;
820 } 823 }
821 GNUNET_assert(s->valid == GNUNET_YES); 824 GNUNET_assert (s->valid == GNUNET_YES);
822 if (s->statement == NULL) 825 if (s->statement == NULL)
823 return GNUNET_SYSERR; 826 return GNUNET_SYSERR;
824 827
825 va_start (ap, insert_id); 828 va_start (ap, insert_id);
826 829
827 if (GNUNET_OK != init_params (s, ap)) 830 if (GNUNET_OK != init_params (s, ap))
828 { 831 {
829 va_end (ap); 832 va_end (ap);
830 return GNUNET_SYSERR; 833 return GNUNET_SYSERR;
831 } 834 }
832 835
833 va_end (ap); 836 va_end (ap);
834 affected = mysql_stmt_affected_rows (s->statement); 837 affected = mysql_stmt_affected_rows (s->statement);
@@ -846,53 +849,73 @@ prepared_statement_run (struct StatementHandle *s,
846 * 849 *
847 * @return GNUNET_OK on success, GNUNET_SYSERR on failure 850 * @return GNUNET_OK on success, GNUNET_SYSERR on failure
848 */ 851 */
849int add_trial (struct GNUNET_DHTLOG_TrialInfo *trial_info) 852int
853add_trial (struct GNUNET_DHTLOG_TrialInfo *trial_info)
850{ 854{
851 MYSQL_STMT *stmt; 855 MYSQL_STMT *stmt;
852 int ret; 856 int ret;
853 unsigned long long m_len; 857 unsigned long long m_len;
858
854 m_len = strlen (trial_info->message); 859 m_len = strlen (trial_info->message);
855 860
856 stmt = mysql_stmt_init(conn); 861 stmt = mysql_stmt_init (conn);
857 if (GNUNET_OK != 862 if (GNUNET_OK !=
858 (ret = prepared_statement_run (insert_trial, &current_trial, 863 (ret = prepared_statement_run (insert_trial, &current_trial,
859 MYSQL_TYPE_LONG, &trial_info->other_identifier, GNUNET_YES, 864 MYSQL_TYPE_LONG,
860 MYSQL_TYPE_LONG, &trial_info->num_nodes, GNUNET_YES, 865 &trial_info->other_identifier, GNUNET_YES,
861 MYSQL_TYPE_LONG, &trial_info->topology, GNUNET_YES, 866 MYSQL_TYPE_LONG, &trial_info->num_nodes,
862 MYSQL_TYPE_FLOAT, &trial_info->topology_percentage, 867 GNUNET_YES, MYSQL_TYPE_LONG,
863 MYSQL_TYPE_FLOAT, &trial_info->topology_probability, 868 &trial_info->topology, GNUNET_YES,
864 MYSQL_TYPE_LONG, &trial_info->blacklist_topology, GNUNET_YES, 869 MYSQL_TYPE_FLOAT,
865 MYSQL_TYPE_LONG, &trial_info->connect_topology, GNUNET_YES, 870 &trial_info->topology_percentage,
866 MYSQL_TYPE_LONG, &trial_info->connect_topology_option, GNUNET_YES, 871 MYSQL_TYPE_FLOAT,
867 MYSQL_TYPE_FLOAT, &trial_info->connect_topology_option_modifier, 872 &trial_info->topology_probability,
868 MYSQL_TYPE_LONG, &trial_info->puts, GNUNET_YES, 873 MYSQL_TYPE_LONG,
869 MYSQL_TYPE_LONG, &trial_info->gets, GNUNET_YES, 874 &trial_info->blacklist_topology,
870 MYSQL_TYPE_LONG, &trial_info->concurrent, GNUNET_YES, 875 GNUNET_YES, MYSQL_TYPE_LONG,
871 MYSQL_TYPE_LONG, &trial_info->settle_time, GNUNET_YES, 876 &trial_info->connect_topology, GNUNET_YES,
872 MYSQL_TYPE_LONG, &trial_info->num_rounds, GNUNET_YES, 877 MYSQL_TYPE_LONG,
873 MYSQL_TYPE_LONG, &trial_info->malicious_getters, GNUNET_YES, 878 &trial_info->connect_topology_option,
874 MYSQL_TYPE_LONG, &trial_info->malicious_putters, GNUNET_YES, 879 GNUNET_YES, MYSQL_TYPE_FLOAT,
875 MYSQL_TYPE_LONG, &trial_info->malicious_droppers, GNUNET_YES, 880 &trial_info->connect_topology_option_modifier,
876 MYSQL_TYPE_LONG, &trial_info->malicious_get_frequency, GNUNET_YES, 881 MYSQL_TYPE_LONG, &trial_info->puts,
877 MYSQL_TYPE_LONG, &trial_info->malicious_put_frequency, GNUNET_YES, 882 GNUNET_YES, MYSQL_TYPE_LONG,
878 MYSQL_TYPE_LONG, &trial_info->stop_closest, GNUNET_YES, 883 &trial_info->gets, GNUNET_YES,
879 MYSQL_TYPE_LONG, &trial_info->stop_found, GNUNET_YES, 884 MYSQL_TYPE_LONG, &trial_info->concurrent,
880 MYSQL_TYPE_LONG, &trial_info->strict_kademlia, GNUNET_YES, 885 GNUNET_YES, MYSQL_TYPE_LONG,
881 MYSQL_TYPE_LONG, &trial_info->gets_succeeded, GNUNET_YES, 886 &trial_info->settle_time, GNUNET_YES,
882 MYSQL_TYPE_BLOB, trial_info->message, max_varchar_len + 887 MYSQL_TYPE_LONG, &trial_info->num_rounds,
883 max_varchar_len, &m_len, 888 GNUNET_YES, MYSQL_TYPE_LONG,
884 -1))) 889 &trial_info->malicious_getters, GNUNET_YES,
890 MYSQL_TYPE_LONG,
891 &trial_info->malicious_putters, GNUNET_YES,
892 MYSQL_TYPE_LONG,
893 &trial_info->malicious_droppers,
894 GNUNET_YES, MYSQL_TYPE_LONG,
895 &trial_info->malicious_get_frequency,
896 GNUNET_YES, MYSQL_TYPE_LONG,
897 &trial_info->malicious_put_frequency,
898 GNUNET_YES, MYSQL_TYPE_LONG,
899 &trial_info->stop_closest, GNUNET_YES,
900 MYSQL_TYPE_LONG, &trial_info->stop_found,
901 GNUNET_YES, MYSQL_TYPE_LONG,
902 &trial_info->strict_kademlia, GNUNET_YES,
903 MYSQL_TYPE_LONG,
904 &trial_info->gets_succeeded, GNUNET_YES,
905 MYSQL_TYPE_BLOB, trial_info->message,
906 max_varchar_len + max_varchar_len, &m_len,
907 -1)))
908 {
909 if (ret == GNUNET_SYSERR)
885 { 910 {
886 if (ret == GNUNET_SYSERR) 911 mysql_stmt_close (stmt);
887 { 912 return GNUNET_SYSERR;
888 mysql_stmt_close(stmt);
889 return GNUNET_SYSERR;
890 }
891 } 913 }
914 }
892 915
893 get_current_trial (&current_trial); 916 get_current_trial (&current_trial);
894 917
895 mysql_stmt_close(stmt); 918 mysql_stmt_close (stmt);
896 return GNUNET_OK; 919 return GNUNET_OK;
897} 920}
898 921
@@ -904,19 +927,20 @@ int add_trial (struct GNUNET_DHTLOG_TrialInfo *trial_info)
904 * 927 *
905 * @return GNUNET_OK on success, GNUNET_SYSERR on failure 928 * @return GNUNET_OK on success, GNUNET_SYSERR on failure
906 */ 929 */
907int add_round (unsigned int round_type, unsigned int round_count) 930int
931add_round (unsigned int round_type, unsigned int round_count)
908{ 932{
909 933
910 MYSQL_STMT *stmt; 934 MYSQL_STMT *stmt;
911 int ret; 935 int ret;
912 936
913 stmt = mysql_stmt_init(conn); 937 stmt = mysql_stmt_init (conn);
914 ret = prepared_statement_run (insert_round, 938 ret = prepared_statement_run (insert_round,
915 NULL, 939 NULL,
916 MYSQL_TYPE_LONGLONG, &current_trial, GNUNET_YES, 940 MYSQL_TYPE_LONGLONG, &current_trial, GNUNET_YES,
917 MYSQL_TYPE_LONG, &round_type, GNUNET_YES, 941 MYSQL_TYPE_LONG, &round_type, GNUNET_YES,
918 MYSQL_TYPE_LONG, &round_count, GNUNET_YES, -1); 942 MYSQL_TYPE_LONG, &round_count, GNUNET_YES, -1);
919 mysql_stmt_close(stmt); 943 mysql_stmt_close (stmt);
920 if (ret != GNUNET_OK) 944 if (ret != GNUNET_OK)
921 return GNUNET_SYSERR; 945 return GNUNET_SYSERR;
922 return ret; 946 return ret;
@@ -933,22 +957,24 @@ int add_round (unsigned int round_type, unsigned int round_count)
933 * 957 *
934 * @return GNUNET_OK on success, GNUNET_SYSERR on failure 958 * @return GNUNET_OK on success, GNUNET_SYSERR on failure
935 */ 959 */
936int add_round_details (unsigned int round_type, unsigned int round_count, 960int
937 unsigned int num_messages, unsigned int num_messages_succeeded) 961add_round_details (unsigned int round_type, unsigned int round_count,
962 unsigned int num_messages,
963 unsigned int num_messages_succeeded)
938{ 964{
939 MYSQL_STMT *stmt; 965 MYSQL_STMT *stmt;
940 int ret; 966 int ret;
941 967
942 stmt = mysql_stmt_init(conn); 968 stmt = mysql_stmt_init (conn);
943 ret = prepared_statement_run (insert_round_details, 969 ret = prepared_statement_run (insert_round_details,
944 NULL, 970 NULL,
945 MYSQL_TYPE_LONGLONG, &current_trial, GNUNET_YES, 971 MYSQL_TYPE_LONGLONG, &current_trial, GNUNET_YES,
946 MYSQL_TYPE_LONG, &round_type, GNUNET_YES, 972 MYSQL_TYPE_LONG, &round_type, GNUNET_YES,
947 MYSQL_TYPE_LONG, &round_count, GNUNET_YES, 973 MYSQL_TYPE_LONG, &round_count, GNUNET_YES,
948 MYSQL_TYPE_LONG, &num_messages, GNUNET_YES, 974 MYSQL_TYPE_LONG, &num_messages, GNUNET_YES,
949 MYSQL_TYPE_LONG, &num_messages_succeeded, GNUNET_YES, 975 MYSQL_TYPE_LONG, &num_messages_succeeded,
950 -1); 976 GNUNET_YES, -1);
951 mysql_stmt_close(stmt); 977 mysql_stmt_close (stmt);
952 if (ret != GNUNET_OK) 978 if (ret != GNUNET_OK)
953 return GNUNET_SYSERR; 979 return GNUNET_SYSERR;
954 return ret; 980 return ret;
@@ -985,53 +1011,61 @@ add_stat (const struct GNUNET_PeerIdentity *peer, unsigned int route_requests,
985 unsigned int data_inserts, unsigned int find_peer_requests, 1011 unsigned int data_inserts, unsigned int find_peer_requests,
986 unsigned int find_peers_started, unsigned int gets_started, 1012 unsigned int find_peers_started, unsigned int gets_started,
987 unsigned int puts_started, unsigned int find_peer_responses_received, 1013 unsigned int puts_started, unsigned int find_peer_responses_received,
988 unsigned int get_responses_received, unsigned int find_peer_responses_sent, 1014 unsigned int get_responses_received,
1015 unsigned int find_peer_responses_sent,
989 unsigned int get_responses_sent) 1016 unsigned int get_responses_sent)
990{ 1017{
991 MYSQL_STMT *stmt; 1018 MYSQL_STMT *stmt;
992 int ret; 1019 int ret;
993 unsigned long long peer_uid; 1020 unsigned long long peer_uid;
994 unsigned long long return_uid; 1021 unsigned long long return_uid;
1022
995 if (peer == NULL) 1023 if (peer == NULL)
996 return GNUNET_SYSERR; 1024 return GNUNET_SYSERR;
997 1025
998 if (GNUNET_OK != get_node_uid (&peer_uid, &peer->hashPubKey)) 1026 if (GNUNET_OK != get_node_uid (&peer_uid, &peer->hashPubKey))
999 { 1027 {
1000 return GNUNET_SYSERR; 1028 return GNUNET_SYSERR;
1001 } 1029 }
1002 1030
1003 stmt = mysql_stmt_init(conn); 1031 stmt = mysql_stmt_init (conn);
1004 if (GNUNET_OK != 1032 if (GNUNET_OK !=
1005 (ret = prepared_statement_run (insert_stat, 1033 (ret = prepared_statement_run (insert_stat,
1006 &return_uid, 1034 &return_uid,
1007 MYSQL_TYPE_LONGLONG, &current_trial, GNUNET_YES, 1035 MYSQL_TYPE_LONGLONG, &current_trial,
1008 MYSQL_TYPE_LONGLONG, &peer_uid, GNUNET_YES, 1036 GNUNET_YES, MYSQL_TYPE_LONGLONG, &peer_uid,
1009 MYSQL_TYPE_LONG, &route_requests, GNUNET_YES, 1037 GNUNET_YES, MYSQL_TYPE_LONG,
1010 MYSQL_TYPE_LONG, &route_forwards, GNUNET_YES, 1038 &route_requests, GNUNET_YES,
1011 MYSQL_TYPE_LONG, &result_requests, GNUNET_YES, 1039 MYSQL_TYPE_LONG, &route_forwards,
1012 MYSQL_TYPE_LONG, &client_requests, GNUNET_YES, 1040 GNUNET_YES, MYSQL_TYPE_LONG,
1013 MYSQL_TYPE_LONG, &result_forwards, GNUNET_YES, 1041 &result_requests, GNUNET_YES,
1042 MYSQL_TYPE_LONG, &client_requests,
1043 GNUNET_YES, MYSQL_TYPE_LONG,
1044 &result_forwards, GNUNET_YES,
1014 MYSQL_TYPE_LONG, &gets, GNUNET_YES, 1045 MYSQL_TYPE_LONG, &gets, GNUNET_YES,
1015 MYSQL_TYPE_LONG, &puts, GNUNET_YES, 1046 MYSQL_TYPE_LONG, &puts, GNUNET_YES,
1016 MYSQL_TYPE_LONG, &data_inserts, GNUNET_YES, 1047 MYSQL_TYPE_LONG, &data_inserts, GNUNET_YES,
1017 MYSQL_TYPE_LONG, &find_peer_requests, GNUNET_YES, 1048 MYSQL_TYPE_LONG, &find_peer_requests,
1018 MYSQL_TYPE_LONG, &find_peers_started, GNUNET_YES, 1049 GNUNET_YES, MYSQL_TYPE_LONG,
1050 &find_peers_started, GNUNET_YES,
1019 MYSQL_TYPE_LONG, &gets_started, GNUNET_YES, 1051 MYSQL_TYPE_LONG, &gets_started, GNUNET_YES,
1020 MYSQL_TYPE_LONG, &puts_started, GNUNET_YES, 1052 MYSQL_TYPE_LONG, &puts_started, GNUNET_YES,
1021 MYSQL_TYPE_LONG, &find_peer_responses_received, GNUNET_YES, 1053 MYSQL_TYPE_LONG,
1022 MYSQL_TYPE_LONG, &get_responses_received, GNUNET_YES, 1054 &find_peer_responses_received, GNUNET_YES,
1023 MYSQL_TYPE_LONG, &find_peer_responses_sent, GNUNET_YES, 1055 MYSQL_TYPE_LONG, &get_responses_received,
1024 MYSQL_TYPE_LONG, &get_responses_sent, GNUNET_YES, 1056 GNUNET_YES, MYSQL_TYPE_LONG,
1025 -1))) 1057 &find_peer_responses_sent, GNUNET_YES,
1058 MYSQL_TYPE_LONG, &get_responses_sent,
1059 GNUNET_YES, -1)))
1060 {
1061 if (ret == GNUNET_SYSERR)
1026 { 1062 {
1027 if (ret == GNUNET_SYSERR) 1063 mysql_stmt_close (stmt);
1028 { 1064 return GNUNET_SYSERR;
1029 mysql_stmt_close(stmt);
1030 return GNUNET_SYSERR;
1031 }
1032 } 1065 }
1066 }
1033 1067
1034 mysql_stmt_close(stmt); 1068 mysql_stmt_close (stmt);
1035 return GNUNET_OK; 1069 return GNUNET_OK;
1036} 1070}
1037 1071
@@ -1047,39 +1081,41 @@ add_stat (const struct GNUNET_PeerIdentity *peer, unsigned int route_requests,
1047 */ 1081 */
1048int 1082int
1049add_generic_stat (const struct GNUNET_PeerIdentity *peer, 1083add_generic_stat (const struct GNUNET_PeerIdentity *peer,
1050 const char *name, 1084 const char *name, const char *section, uint64_t value)
1051 const char *section, uint64_t value)
1052{ 1085{
1053 unsigned long long peer_uid; 1086 unsigned long long peer_uid;
1054 unsigned long long section_len; 1087 unsigned long long section_len;
1055 unsigned long long name_len; 1088 unsigned long long name_len;
1056 int ret; 1089 int ret;
1090
1057 if (peer == NULL) 1091 if (peer == NULL)
1058 return GNUNET_SYSERR; 1092 return GNUNET_SYSERR;
1059 1093
1060 if (GNUNET_OK != get_node_uid (&peer_uid, &peer->hashPubKey)) 1094 if (GNUNET_OK != get_node_uid (&peer_uid, &peer->hashPubKey))
1061 { 1095 {
1062 return GNUNET_SYSERR; 1096 return GNUNET_SYSERR;
1063 } 1097 }
1064 1098
1065 section_len = strlen(section); 1099 section_len = strlen (section);
1066 name_len = strlen(name); 1100 name_len = strlen (name);
1067 1101
1068 if (GNUNET_OK != 1102 if (GNUNET_OK !=
1069 (ret = prepared_statement_run (insert_generic_stat, 1103 (ret = prepared_statement_run (insert_generic_stat,
1070 NULL, 1104 NULL,
1071 MYSQL_TYPE_LONGLONG, &current_trial, GNUNET_YES, 1105 MYSQL_TYPE_LONGLONG, &current_trial,
1072 MYSQL_TYPE_LONGLONG, &peer_uid, GNUNET_YES, 1106 GNUNET_YES, MYSQL_TYPE_LONGLONG, &peer_uid,
1073 MYSQL_TYPE_VAR_STRING, &section, max_varchar_len, &section_len, 1107 GNUNET_YES, MYSQL_TYPE_VAR_STRING,
1074 MYSQL_TYPE_VAR_STRING, &name, max_varchar_len, &name_len, 1108 &section, max_varchar_len, &section_len,
1109 MYSQL_TYPE_VAR_STRING, &name,
1110 max_varchar_len, &name_len,
1075 MYSQL_TYPE_LONGLONG, &value, GNUNET_YES, 1111 MYSQL_TYPE_LONGLONG, &value, GNUNET_YES,
1076 -1))) 1112 -1)))
1113 {
1114 if (ret == GNUNET_SYSERR)
1077 { 1115 {
1078 if (ret == GNUNET_SYSERR) 1116 return GNUNET_SYSERR;
1079 {
1080 return GNUNET_SYSERR;
1081 }
1082 } 1117 }
1118 }
1083 return GNUNET_OK; 1119 return GNUNET_OK;
1084} 1120}
1085 1121
@@ -1101,23 +1137,24 @@ add_dhtkey (unsigned long long *dhtkeyuid, const GNUNET_HashCode * dhtkey)
1101 unsigned long long k_len; 1137 unsigned long long k_len;
1102 unsigned long long h_len; 1138 unsigned long long h_len;
1103 unsigned long long curr_dhtkeyuid; 1139 unsigned long long curr_dhtkeyuid;
1140
1104 GNUNET_CRYPTO_hash_to_enc (dhtkey, &encKey); 1141 GNUNET_CRYPTO_hash_to_enc (dhtkey, &encKey);
1105 k_len = strlen ((char *) &encKey); 1142 k_len = strlen ((char *) &encKey);
1106 h_len = sizeof (GNUNET_HashCode); 1143 h_len = sizeof (GNUNET_HashCode);
1107 curr_dhtkeyuid = 0; 1144 curr_dhtkeyuid = 0;
1108 ret = get_dhtkey_uid(&curr_dhtkeyuid, dhtkey); 1145 ret = get_dhtkey_uid (&curr_dhtkeyuid, dhtkey);
1109 if (curr_dhtkeyuid != 0) /* dhtkey already exists */ 1146 if (curr_dhtkeyuid != 0) /* dhtkey already exists */
1110 { 1147 {
1111 if (dhtkeyuid != NULL) 1148 if (dhtkeyuid != NULL)
1112 *dhtkeyuid = curr_dhtkeyuid; 1149 *dhtkeyuid = curr_dhtkeyuid;
1113 return GNUNET_OK; 1150 return GNUNET_OK;
1114 } 1151 }
1115 else if (ret == GNUNET_SYSERR) 1152 else if (ret == GNUNET_SYSERR)
1116 { 1153 {
1117#if DEBUG_DHTLOG 1154#if DEBUG_DHTLOG
1118 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Failed to get dhtkeyuid!\n"); 1155 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to get dhtkeyuid!\n");
1119#endif 1156#endif
1120 } 1157 }
1121 1158
1122 if (GNUNET_OK != 1159 if (GNUNET_OK !=
1123 (ret = prepared_statement_run (insert_dhtkey, 1160 (ret = prepared_statement_run (insert_dhtkey,
@@ -1131,14 +1168,13 @@ add_dhtkey (unsigned long long *dhtkeyuid, const GNUNET_HashCode * dhtkey)
1131 GNUNET_YES, 1168 GNUNET_YES,
1132 MYSQL_TYPE_BLOB, 1169 MYSQL_TYPE_BLOB,
1133 dhtkey, 1170 dhtkey,
1134 sizeof (GNUNET_HashCode), 1171 sizeof (GNUNET_HashCode), &h_len, -1)))
1135 &h_len, -1))) 1172 {
1173 if (ret == GNUNET_SYSERR)
1136 { 1174 {
1137 if (ret == GNUNET_SYSERR) 1175 return GNUNET_SYSERR;
1138 {
1139 return GNUNET_SYSERR;
1140 }
1141 } 1176 }
1177 }
1142 1178
1143 return GNUNET_OK; 1179 return GNUNET_OK;
1144} 1180}
@@ -1154,7 +1190,7 @@ add_dhtkey (unsigned long long *dhtkeyuid, const GNUNET_HashCode * dhtkey)
1154 * @return GNUNET_OK on success, GNUNET_SYSERR on failure 1190 * @return GNUNET_OK on success, GNUNET_SYSERR on failure
1155 */ 1191 */
1156int 1192int
1157add_node (unsigned long long *nodeuid, struct GNUNET_PeerIdentity * node) 1193add_node (unsigned long long *nodeuid, struct GNUNET_PeerIdentity *node)
1158{ 1194{
1159 struct GNUNET_CRYPTO_HashAsciiEncoded encPeer; 1195 struct GNUNET_CRYPTO_HashAsciiEncoded encPeer;
1160 unsigned long p_len; 1196 unsigned long p_len;
@@ -1170,16 +1206,17 @@ add_node (unsigned long long *nodeuid, struct GNUNET_PeerIdentity * node)
1170 if (GNUNET_OK != 1206 if (GNUNET_OK !=
1171 (ret = prepared_statement_run (insert_node, 1207 (ret = prepared_statement_run (insert_node,
1172 nodeuid, 1208 nodeuid,
1173 MYSQL_TYPE_LONGLONG, &current_trial, GNUNET_YES, 1209 MYSQL_TYPE_LONGLONG, &current_trial,
1174 MYSQL_TYPE_VAR_STRING, &encPeer, max_varchar_len, &p_len, 1210 GNUNET_YES, MYSQL_TYPE_VAR_STRING,
1175 MYSQL_TYPE_BLOB, &node->hashPubKey, sizeof (GNUNET_HashCode), 1211 &encPeer, max_varchar_len, &p_len,
1176 &h_len, -1))) 1212 MYSQL_TYPE_BLOB, &node->hashPubKey,
1213 sizeof (GNUNET_HashCode), &h_len, -1)))
1214 {
1215 if (ret == GNUNET_SYSERR)
1177 { 1216 {
1178 if (ret == GNUNET_SYSERR) 1217 return GNUNET_SYSERR;
1179 {
1180 return GNUNET_SYSERR;
1181 }
1182 } 1218 }
1219 }
1183 return GNUNET_OK; 1220 return GNUNET_OK;
1184} 1221}
1185 1222
@@ -1197,16 +1234,16 @@ update_trials (unsigned int gets_succeeded)
1197 1234
1198 if (GNUNET_OK != 1235 if (GNUNET_OK !=
1199 (ret = prepared_statement_run (update_trial, 1236 (ret = prepared_statement_run (update_trial,
1200 NULL, 1237 NULL,
1201 MYSQL_TYPE_LONG, &gets_succeeded, GNUNET_YES, 1238 MYSQL_TYPE_LONG, &gets_succeeded,
1202 MYSQL_TYPE_LONGLONG, &current_trial, GNUNET_YES, 1239 GNUNET_YES, MYSQL_TYPE_LONGLONG,
1203 -1))) 1240 &current_trial, GNUNET_YES, -1)))
1241 {
1242 if (ret == GNUNET_SYSERR)
1204 { 1243 {
1205 if (ret == GNUNET_SYSERR) 1244 return GNUNET_SYSERR;
1206 {
1207 return GNUNET_SYSERR;
1208 }
1209 } 1245 }
1246 }
1210 if (ret > 0) 1247 if (ret > 0)
1211 return GNUNET_OK; 1248 return GNUNET_OK;
1212 else 1249 else
@@ -1222,27 +1259,28 @@ update_trials (unsigned int gets_succeeded)
1222 * 1259 *
1223 * @return GNUNET_OK on success, GNUNET_SYSERR on failure. 1260 * @return GNUNET_OK on success, GNUNET_SYSERR on failure.
1224 */ 1261 */
1225int set_malicious (struct GNUNET_PeerIdentity *peer) 1262int
1263set_malicious (struct GNUNET_PeerIdentity *peer)
1226{ 1264{
1227 unsigned long long p_len; 1265 unsigned long long p_len;
1228 int ret; 1266 int ret;
1229 char *temp_str; 1267 char *temp_str;
1230 1268
1231 temp_str = GNUNET_strdup(GNUNET_h2s_full(&peer->hashPubKey)); 1269 temp_str = GNUNET_strdup (GNUNET_h2s_full (&peer->hashPubKey));
1232 p_len = strlen(temp_str); 1270 p_len = strlen (temp_str);
1233 1271
1234 if (GNUNET_OK != 1272 if (GNUNET_OK !=
1235 (ret = prepared_statement_run (update_node_malicious, 1273 (ret = prepared_statement_run (update_node_malicious,
1236 NULL, 1274 NULL,
1237 MYSQL_TYPE_LONGLONG, &current_trial, GNUNET_YES, 1275 MYSQL_TYPE_LONGLONG, &current_trial,
1238 MYSQL_TYPE_VAR_STRING, temp_str, max_varchar_len, &p_len, 1276 GNUNET_YES, MYSQL_TYPE_VAR_STRING,
1239 -1))) 1277 temp_str, max_varchar_len, &p_len, -1)))
1278 {
1279 if (ret == GNUNET_SYSERR)
1240 { 1280 {
1241 if (ret == GNUNET_SYSERR) 1281 return GNUNET_SYSERR;
1242 {
1243 return GNUNET_SYSERR;
1244 }
1245 } 1282 }
1283 }
1246 return GNUNET_OK; 1284 return GNUNET_OK;
1247} 1285}
1248 1286
@@ -1261,18 +1299,18 @@ add_connections (unsigned int totalConnections)
1261 1299
1262 if (GNUNET_OK != 1300 if (GNUNET_OK !=
1263 (ret = prepared_statement_run (update_connection, 1301 (ret = prepared_statement_run (update_connection,
1264 NULL, 1302 NULL,
1265 MYSQL_TYPE_LONG, 1303 MYSQL_TYPE_LONG,
1266 &totalConnections, 1304 &totalConnections,
1267 GNUNET_YES, 1305 GNUNET_YES,
1268 MYSQL_TYPE_LONGLONG, 1306 MYSQL_TYPE_LONGLONG,
1269 &current_trial, GNUNET_YES, -1))) 1307 &current_trial, GNUNET_YES, -1)))
1308 {
1309 if (ret == GNUNET_SYSERR)
1270 { 1310 {
1271 if (ret == GNUNET_SYSERR) 1311 return GNUNET_SYSERR;
1272 {
1273 return GNUNET_SYSERR;
1274 }
1275 } 1312 }
1313 }
1276 if (ret > 0) 1314 if (ret > 0)
1277 return GNUNET_OK; 1315 return GNUNET_OK;
1278 else 1316 else
@@ -1295,65 +1333,66 @@ add_connections (unsigned int totalConnections)
1295int 1333int
1296add_query (unsigned long long *sqlqueryuid, unsigned long long queryid, 1334add_query (unsigned long long *sqlqueryuid, unsigned long long queryid,
1297 unsigned int type, unsigned int hops, int succeeded, 1335 unsigned int type, unsigned int hops, int succeeded,
1298 const struct GNUNET_PeerIdentity * node, const GNUNET_HashCode * key) 1336 const struct GNUNET_PeerIdentity *node, const GNUNET_HashCode * key)
1299{ 1337{
1300 int ret; 1338 int ret;
1301 unsigned long long peer_uid, key_uid; 1339 unsigned long long peer_uid, key_uid;
1340
1302 peer_uid = 0; 1341 peer_uid = 0;
1303 key_uid = 0; 1342 key_uid = 0;
1304 1343
1305 if ((node != NULL) 1344 if ((node != NULL)
1306 && (GNUNET_OK == get_node_uid (&peer_uid, &node->hashPubKey))) 1345 && (GNUNET_OK == get_node_uid (&peer_uid, &node->hashPubKey)))
1307 { 1346 {
1308 1347
1309 } 1348 }
1310 else 1349 else
1311 { 1350 {
1312 return GNUNET_SYSERR; 1351 return GNUNET_SYSERR;
1313 } 1352 }
1314 1353
1315 if ((key != NULL) && (GNUNET_OK == get_dhtkey_uid (&key_uid, key))) 1354 if ((key != NULL) && (GNUNET_OK == get_dhtkey_uid (&key_uid, key)))
1316 { 1355 {
1317 1356
1318 } 1357 }
1319 else if ((key != NULL) && (key->bits[(512 / 8 / sizeof (unsigned int)) - 1] == 42)) /* Malicious marker */ 1358 else if ((key != NULL) && (key->bits[(512 / 8 / sizeof (unsigned int)) - 1] == 42)) /* Malicious marker */
1320 { 1359 {
1321 key_uid = 0; 1360 key_uid = 0;
1322 } 1361 }
1323 else 1362 else
1324 { 1363 {
1325 return GNUNET_SYSERR; 1364 return GNUNET_SYSERR;
1326 } 1365 }
1327 1366
1328 if (GNUNET_OK != 1367 if (GNUNET_OK !=
1329 (ret = prepared_statement_run (insert_query, 1368 (ret = prepared_statement_run (insert_query,
1330 sqlqueryuid, 1369 sqlqueryuid,
1331 MYSQL_TYPE_LONGLONG, 1370 MYSQL_TYPE_LONGLONG,
1332 &current_trial, 1371 &current_trial,
1333 GNUNET_YES, 1372 GNUNET_YES,
1334 MYSQL_TYPE_LONG, 1373 MYSQL_TYPE_LONG,
1335 &type, 1374 &type,
1336 GNUNET_NO, 1375 GNUNET_NO,
1337 MYSQL_TYPE_LONG, 1376 MYSQL_TYPE_LONG,
1338 &hops, 1377 &hops,
1339 GNUNET_YES, 1378 GNUNET_YES,
1340 MYSQL_TYPE_LONGLONG, 1379 MYSQL_TYPE_LONGLONG,
1341 &key_uid, 1380 &key_uid,
1342 GNUNET_YES, 1381 GNUNET_YES,
1343 MYSQL_TYPE_LONGLONG, 1382 MYSQL_TYPE_LONGLONG,
1344 &queryid, 1383 &queryid,
1345 GNUNET_YES, 1384 GNUNET_YES,
1346 MYSQL_TYPE_LONG, 1385 MYSQL_TYPE_LONG,
1347 &succeeded, 1386 &succeeded,
1348 GNUNET_NO, 1387 GNUNET_NO,
1349 MYSQL_TYPE_LONGLONG, 1388 MYSQL_TYPE_LONGLONG,
1350 &peer_uid, GNUNET_YES, -1))) 1389 &peer_uid, GNUNET_YES, -1)))
1390 {
1391 if (ret == GNUNET_SYSERR)
1351 { 1392 {
1352 if (ret == GNUNET_SYSERR) 1393 return GNUNET_SYSERR;
1353 {
1354 return GNUNET_SYSERR;
1355 }
1356 } 1394 }
1395 }
1357 if (ret > 0) 1396 if (ret > 0)
1358 return GNUNET_OK; 1397 return GNUNET_OK;
1359 else 1398 else
@@ -1378,9 +1417,10 @@ add_query (unsigned long long *sqlqueryuid, unsigned long long queryid,
1378int 1417int
1379add_route (unsigned long long *sqlqueryuid, unsigned long long queryid, 1418add_route (unsigned long long *sqlqueryuid, unsigned long long queryid,
1380 unsigned int type, unsigned int hops, 1419 unsigned int type, unsigned int hops,
1381 int succeeded, const struct GNUNET_PeerIdentity * node, 1420 int succeeded, const struct GNUNET_PeerIdentity *node,
1382 const GNUNET_HashCode * key, const struct GNUNET_PeerIdentity * from_node, 1421 const GNUNET_HashCode * key,
1383 const struct GNUNET_PeerIdentity * to_node) 1422 const struct GNUNET_PeerIdentity *from_node,
1423 const struct GNUNET_PeerIdentity *to_node)
1384{ 1424{
1385 unsigned long long peer_uid = 0; 1425 unsigned long long peer_uid = 0;
1386 unsigned long long key_uid = 0; 1426 unsigned long long key_uid = 0;
@@ -1397,60 +1437,60 @@ add_route (unsigned long long *sqlqueryuid, unsigned long long queryid,
1397 to_uid = 0; 1437 to_uid = 0;
1398 1438
1399 if ((node != NULL)) 1439 if ((node != NULL))
1440 {
1441 if (1 != get_node_uid (&peer_uid, &node->hashPubKey))
1400 { 1442 {
1401 if (1 != get_node_uid (&peer_uid, &node->hashPubKey)) 1443 return GNUNET_SYSERR;
1402 {
1403 return GNUNET_SYSERR;
1404 }
1405 } 1444 }
1445 }
1406 else 1446 else
1407 return GNUNET_SYSERR; 1447 return GNUNET_SYSERR;
1408 1448
1409 if ((key != NULL)) 1449 if ((key != NULL))
1450 {
1451 if (1 != get_dhtkey_uid (&key_uid, key))
1410 { 1452 {
1411 if (1 != get_dhtkey_uid (&key_uid, key)) 1453 return GNUNET_SYSERR;
1412 {
1413 return GNUNET_SYSERR;
1414 }
1415 } 1454 }
1455 }
1416 else 1456 else
1417 return GNUNET_SYSERR; 1457 return GNUNET_SYSERR;
1418 1458
1419 if (GNUNET_OK != 1459 if (GNUNET_OK !=
1420 (ret = prepared_statement_run (insert_route, 1460 (ret = prepared_statement_run (insert_route,
1421 sqlqueryuid, 1461 sqlqueryuid,
1422 MYSQL_TYPE_LONGLONG, 1462 MYSQL_TYPE_LONGLONG,
1423 &current_trial, 1463 &current_trial,
1424 GNUNET_YES, 1464 GNUNET_YES,
1425 MYSQL_TYPE_LONG, 1465 MYSQL_TYPE_LONG,
1426 &type, 1466 &type,
1427 GNUNET_NO, 1467 GNUNET_NO,
1428 MYSQL_TYPE_LONG, 1468 MYSQL_TYPE_LONG,
1429 &hops, 1469 &hops,
1430 GNUNET_YES, 1470 GNUNET_YES,
1431 MYSQL_TYPE_LONGLONG, 1471 MYSQL_TYPE_LONGLONG,
1432 &key_uid, 1472 &key_uid,
1433 GNUNET_YES, 1473 GNUNET_YES,
1434 MYSQL_TYPE_LONGLONG, 1474 MYSQL_TYPE_LONGLONG,
1435 &queryid, 1475 &queryid,
1436 GNUNET_YES, 1476 GNUNET_YES,
1437 MYSQL_TYPE_LONG, 1477 MYSQL_TYPE_LONG,
1438 &succeeded, 1478 &succeeded,
1439 GNUNET_NO, 1479 GNUNET_NO,
1440 MYSQL_TYPE_LONGLONG, 1480 MYSQL_TYPE_LONGLONG,
1441 &peer_uid, 1481 &peer_uid,
1442 GNUNET_YES, 1482 GNUNET_YES,
1443 MYSQL_TYPE_LONGLONG, 1483 MYSQL_TYPE_LONGLONG,
1444 &from_uid, 1484 &from_uid,
1445 GNUNET_YES, 1485 GNUNET_YES,
1446 MYSQL_TYPE_LONGLONG, 1486 MYSQL_TYPE_LONGLONG,
1447 &to_uid, GNUNET_YES, -1))) 1487 &to_uid, GNUNET_YES, -1)))
1488 {
1489 if (ret == GNUNET_SYSERR)
1448 { 1490 {
1449 if (ret == GNUNET_SYSERR) 1491 return GNUNET_SYSERR;
1450 {
1451 return GNUNET_SYSERR;
1452 }
1453 } 1492 }
1493 }
1454 if (ret > 0) 1494 if (ret > 0)
1455 return GNUNET_OK; 1495 return GNUNET_OK;
1456 else 1496 else
@@ -1470,7 +1510,7 @@ update_current_topology (unsigned int connections)
1470 int ret; 1510 int ret;
1471 unsigned long long topologyuid; 1511 unsigned long long topologyuid;
1472 1512
1473 get_current_topology(&topologyuid); 1513 get_current_topology (&topologyuid);
1474 1514
1475 if (GNUNET_OK != 1515 if (GNUNET_OK !=
1476 (ret = prepared_statement_run (update_topology, 1516 (ret = prepared_statement_run (update_topology,
@@ -1480,12 +1520,12 @@ update_current_topology (unsigned int connections)
1480 GNUNET_YES, 1520 GNUNET_YES,
1481 MYSQL_TYPE_LONGLONG, 1521 MYSQL_TYPE_LONGLONG,
1482 &topologyuid, GNUNET_YES, -1))) 1522 &topologyuid, GNUNET_YES, -1)))
1523 {
1524 if (ret == GNUNET_SYSERR)
1483 { 1525 {
1484 if (ret == GNUNET_SYSERR) 1526 return GNUNET_SYSERR;
1485 {
1486 return GNUNET_SYSERR;
1487 }
1488 } 1527 }
1528 }
1489 if (ret > 0) 1529 if (ret > 0)
1490 return GNUNET_OK; 1530 return GNUNET_OK;
1491 return GNUNET_SYSERR; 1531 return GNUNET_SYSERR;
@@ -1507,15 +1547,15 @@ add_topology (int num_connections)
1507 if (GNUNET_OK != 1547 if (GNUNET_OK !=
1508 (ret = prepared_statement_run (insert_topology, 1548 (ret = prepared_statement_run (insert_topology,
1509 NULL, 1549 NULL,
1510 MYSQL_TYPE_LONGLONG, &current_trial, GNUNET_YES, 1550 MYSQL_TYPE_LONGLONG, &current_trial,
1511 MYSQL_TYPE_LONG, &num_connections, GNUNET_YES, 1551 GNUNET_YES, MYSQL_TYPE_LONG,
1512 -1))) 1552 &num_connections, GNUNET_YES, -1)))
1553 {
1554 if (ret == GNUNET_SYSERR)
1513 { 1555 {
1514 if (ret == GNUNET_SYSERR) 1556 return GNUNET_SYSERR;
1515 {
1516 return GNUNET_SYSERR;
1517 }
1518 } 1557 }
1558 }
1519 if (ret > 0) 1559 if (ret > 0)
1520 return GNUNET_OK; 1560 return GNUNET_OK;
1521 return GNUNET_SYSERR; 1561 return GNUNET_SYSERR;
@@ -1530,18 +1570,19 @@ add_topology (int num_connections)
1530 * @return GNUNET_OK on success, GNUNET_SYSERR on failure 1570 * @return GNUNET_OK on success, GNUNET_SYSERR on failure
1531 */ 1571 */
1532int 1572int
1533add_extended_topology (const struct GNUNET_PeerIdentity *first, const struct GNUNET_PeerIdentity *second) 1573add_extended_topology (const struct GNUNET_PeerIdentity *first,
1574 const struct GNUNET_PeerIdentity *second)
1534{ 1575{
1535 int ret; 1576 int ret;
1536 unsigned long long first_uid; 1577 unsigned long long first_uid;
1537 unsigned long long second_uid; 1578 unsigned long long second_uid;
1538 unsigned long long topologyuid; 1579 unsigned long long topologyuid;
1539 1580
1540 if (GNUNET_OK != get_current_topology(&topologyuid)) 1581 if (GNUNET_OK != get_current_topology (&topologyuid))
1541 return GNUNET_SYSERR; 1582 return GNUNET_SYSERR;
1542 if (GNUNET_OK != get_node_uid(&first_uid, &first->hashPubKey)) 1583 if (GNUNET_OK != get_node_uid (&first_uid, &first->hashPubKey))
1543 return GNUNET_SYSERR; 1584 return GNUNET_SYSERR;
1544 if (GNUNET_OK != get_node_uid(&second_uid, &second->hashPubKey)) 1585 if (GNUNET_OK != get_node_uid (&second_uid, &second->hashPubKey))
1545 return GNUNET_SYSERR; 1586 return GNUNET_SYSERR;
1546 1587
1547 if (GNUNET_OK != 1588 if (GNUNET_OK !=
@@ -1554,14 +1595,13 @@ add_extended_topology (const struct GNUNET_PeerIdentity *first, const struct GNU
1554 &first_uid, 1595 &first_uid,
1555 GNUNET_YES, 1596 GNUNET_YES,
1556 MYSQL_TYPE_LONGLONG, 1597 MYSQL_TYPE_LONGLONG,
1557 &second_uid, 1598 &second_uid, GNUNET_YES, -1)))
1558 GNUNET_YES,-1))) 1599 {
1600 if (ret == GNUNET_SYSERR)
1559 { 1601 {
1560 if (ret == GNUNET_SYSERR) 1602 return GNUNET_SYSERR;
1561 {
1562 return GNUNET_SYSERR;
1563 }
1564 } 1603 }
1604 }
1565 if (ret > 0) 1605 if (ret > 0)
1566 return GNUNET_OK; 1606 return GNUNET_OK;
1567 return GNUNET_SYSERR; 1607 return GNUNET_SYSERR;
@@ -1576,25 +1616,27 @@ add_extended_topology (const struct GNUNET_PeerIdentity *first, const struct GNU
1576 * @return the handle to the server, or NULL on error 1616 * @return the handle to the server, or NULL on error
1577 */ 1617 */
1578void * 1618void *
1579libgnunet_plugin_dhtlog_mysql_init (void * cls) 1619libgnunet_plugin_dhtlog_mysql_init (void *cls)
1580{ 1620{
1581 struct GNUNET_DHTLOG_Plugin *plugin = cls; 1621 struct GNUNET_DHTLOG_Plugin *plugin = cls;
1582 1622
1583 cfg = plugin->cfg; 1623 cfg = plugin->cfg;
1584 max_varchar_len = 255; 1624 max_varchar_len = 255;
1585#if DEBUG_DHTLOG 1625#if DEBUG_DHTLOG
1586 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MySQL DHT Logger: initializing database\n"); 1626 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1627 "MySQL DHT Logger: initializing database\n");
1587#endif 1628#endif
1588 1629
1589 if (iopen (plugin) != GNUNET_OK) 1630 if (iopen (plugin) != GNUNET_OK)
1590 { 1631 {
1591 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, 1632 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1592 _("Failed to initialize MySQL database connection for dhtlog.\n")); 1633 _
1593 return NULL; 1634 ("Failed to initialize MySQL database connection for dhtlog.\n"));
1594 } 1635 return NULL;
1595 1636 }
1596 GNUNET_assert(plugin->dhtlog_api == NULL); 1637
1597 plugin->dhtlog_api = GNUNET_malloc(sizeof(struct GNUNET_DHTLOG_Handle)); 1638 GNUNET_assert (plugin->dhtlog_api == NULL);
1639 plugin->dhtlog_api = GNUNET_malloc (sizeof (struct GNUNET_DHTLOG_Handle));
1598 plugin->dhtlog_api->insert_trial = &add_trial; 1640 plugin->dhtlog_api->insert_trial = &add_trial;
1599 plugin->dhtlog_api->insert_stat = &add_stat; 1641 plugin->dhtlog_api->insert_stat = &add_stat;
1600 plugin->dhtlog_api->insert_round = &add_round; 1642 plugin->dhtlog_api->insert_round = &add_round;
@@ -1619,36 +1661,35 @@ libgnunet_plugin_dhtlog_mysql_init (void * cls)
1619 * Shutdown the plugin. 1661 * Shutdown the plugin.
1620 */ 1662 */
1621void * 1663void *
1622libgnunet_plugin_dhtlog_mysql_done (void * cls) 1664libgnunet_plugin_dhtlog_mysql_done (void *cls)
1623{ 1665{
1624 struct GNUNET_DHTLOG_Handle *dhtlog_api = cls; 1666 struct GNUNET_DHTLOG_Handle *dhtlog_api = cls;
1625 1667
1626 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 1668 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MySQL DHT Logger: database shutdown\n");
1627 "MySQL DHT Logger: database shutdown\n"); 1669 GNUNET_assert (dhtlog_api != NULL);
1628 GNUNET_assert(dhtlog_api != NULL); 1670 prepared_statement_close (insert_query);
1629 prepared_statement_close(insert_query); 1671 prepared_statement_close (insert_route);
1630 prepared_statement_close(insert_route); 1672 prepared_statement_close (insert_trial);
1631 prepared_statement_close(insert_trial); 1673 prepared_statement_close (insert_round);
1632 prepared_statement_close(insert_round); 1674 prepared_statement_close (insert_round_details);
1633 prepared_statement_close(insert_round_details); 1675 prepared_statement_close (insert_node);
1634 prepared_statement_close(insert_node); 1676 prepared_statement_close (insert_dhtkey);
1635 prepared_statement_close(insert_dhtkey); 1677 prepared_statement_close (update_trial);
1636 prepared_statement_close(update_trial); 1678 prepared_statement_close (get_dhtkeyuid);
1637 prepared_statement_close(get_dhtkeyuid); 1679 prepared_statement_close (get_nodeuid);
1638 prepared_statement_close(get_nodeuid); 1680 prepared_statement_close (update_connection);
1639 prepared_statement_close(update_connection); 1681 prepared_statement_close (get_trial);
1640 prepared_statement_close(get_trial); 1682 prepared_statement_close (get_topology);
1641 prepared_statement_close(get_topology); 1683 prepared_statement_close (insert_topology);
1642 prepared_statement_close(insert_topology); 1684 prepared_statement_close (update_topology);
1643 prepared_statement_close(update_topology); 1685 prepared_statement_close (extend_topology);
1644 prepared_statement_close(extend_topology); 1686 prepared_statement_close (update_node_malicious);
1645 prepared_statement_close(update_node_malicious);
1646 1687
1647 if (conn != NULL) 1688 if (conn != NULL)
1648 mysql_close (conn); 1689 mysql_close (conn);
1649 conn = NULL; 1690 conn = NULL;
1650 mysql_library_end(); 1691 mysql_library_end ();
1651 GNUNET_free(dhtlog_api); 1692 GNUNET_free (dhtlog_api);
1652 return NULL; 1693 return NULL;
1653} 1694}
1654 1695
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-24 23:25:44 +0000