src/dht/plugin_dhtlog_mysql_dump.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2006 - 2009 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 2, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file src/dht/plugin_dhtlog_mysql_dump.c
  23  * @brief MySQL logging plugin to record DHT operations to MySQL server,
  24  *        but write all queries to file instead of the actual server
  25  *        so that they can be imported later.  The idea is that connecting
  26  *        to the MySQL server X times can be really problematic, but hopefully
  27  *        writing to a single file is more reliable.
  28  * @author Nathan Evans
  29  *
  30  * Database: MySQL
  31  */
  32
  33 #include "platform.h"
  34 #include "gnunet_util_lib.h"
  35 #include "dhtlog.h"
  36
  37
  38 #define DEBUG_DHTLOG GNUNET_YES
  39
  40 /**
  41  * Maximum number of supported parameters for a prepared
  42  * statement.  Increase if needed.
  43  */
  44 #define MAX_PARAM 32
  45
  46
  47 static unsigned long max_varchar_len;
  48
  49 /**
  50  * The configuration the DHT service is running with
  51  */
  52 static const struct GNUNET_CONFIGURATION_Handle *cfg;
  53
  54 #define INSERT_QUERIES_STMT "prepare insert_query from 'INSERT INTO queries (trialuid, querytype, hops, dhtkeyuid, dhtqueryid, succeeded, nodeuid, time) "\
  55                           "VALUES (@temp_trial, ?, ?, ?, ?, ?, ?, ?)'"
  56
  57 #define INSERT_ROUTES_STMT "prepare insert_route from 'INSERT INTO routes (trialuid, querytype, hops, dhtkeyuid, dhtqueryid, succeeded, nodeuid, from_node, to_node) "\
  58                           "VALUES (@temp_trial, ?, ?, ?, ?, ?, ?, ?, ?)'"
  59
  60 #define INSERT_NODES_STMT "prepare insert_node from 'INSERT ignore INTO nodes (trialuid, nodeid) "\
  61                           "VALUES (@temp_trial, ?)'"
  62
  63 #define INSERT_TOPOLOGY_STMT "prepare insert_topology from 'INSERT INTO topology (trialuid, date, connections) "\
  64                              "VALUES (@temp_trial, ?, ?)'"
  65
  66 #define INSERT_ROUND_STMT "prepare insert_round from 'INSERT INTO rounds (trialuid, round_type, round_count, starttime) VALUES (@temp_trial, @rtype, @rcount, @curr_time)'"
  67
  68 #define EXTEND_TOPOLOGY_STMT "prepare extend_topology from 'INSERT INTO extended_topology (topology_uid, uid_first, uid_second) "\
  69                              "VALUES (@temp_topology, ?, ?)'"
  70
  71 #define UPDATE_TOPOLOGY_STMT "prepare update_topology from 'update topology set connections = ?  where topology_uid = @temp_topology'"
  72
  73 #define SET_MALICIOUS_STMT "prepare set_malicious from 'update nodes set malicious_dropper = 1  where trialuid = @temp_trial and nodeid = @temp_node'"
  74
  75 #define INSERT_TRIALS_STMT "prepare insert_trial from 'INSERT INTO trials"\
  76                            "(starttime, other_trial_identifier, numnodes, topology,"\
  77                            "topology_percentage, topology_probability,"\
  78                            "blacklist_topology, connect_topology, connect_topology_option,"\
  79                            "connect_topology_option_modifier, puts, gets, "\
  80                            "concurrent, settle_time, num_rounds, malicious_getters,"\
  81                            "malicious_putters, malicious_droppers, malicious_get_frequency,"\
  82                            "malicious_put_frequency, stop_closest, stop_found, strict_kademlia, "\
  83                            "gets_succeeded, message) "\
  84                            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'"
  85
  86 #define INSERT_GENERIC_STAT_STMT "prepare insert_generic_stat from 'INSERT INTO generic_stats" \
  87                                  "(trialuid, nodeuid, section, name, value)"\
  88                                  "VALUES (@temp_trial, @temp_node, @temp_section, @temp_stat, @temp_value)'"
  89
  90 #define INSERT_STAT_STMT "prepare insert_stat from 'INSERT INTO node_statistics"\
  91                             "(trialuid, nodeuid, route_requests,"\
  92                             "route_forwards, result_requests,"\
  93                             "client_results, result_forwards, gets,"\
  94                             "puts, data_inserts, find_peer_requests, "\
  95                             "find_peers_started, gets_started, puts_started, find_peer_responses_received,"\
  96                             "get_responses_received, find_peer_responses_sent, get_responses_sent) "\
  97                             "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'"
  98
  99 #define INSERT_DHTKEY_STMT "prepare insert_dhtkey from 'INSERT ignore INTO dhtkeys (dhtkey, trialuid) "\
 100                            "VALUES (?, @temp_trial)'"
 101
 102 #define UPDATE_TRIALS_STMT "prepare update_trial from 'UPDATE trials set endtime= ?, gets_succeeded = ? where trialuid = @temp_trial'"
 103
 104 #define UPDATE_CONNECTIONS_STMT "prepare update_conn from 'UPDATE trials set totalConnections = ? where trialuid = @temp_trial'"
 105
 106 #define GET_TRIAL_STMT "prepare select_trial from 'SELECT MAX( trialuid ) FROM trials into @temp_trial'"
 107
 108 #define GET_TOPOLOGY_STMT "prepare select_topology from 'SELECT MAX( topology_uid ) FROM topology into @temp_topology'"
 109
 110 #define GET_DHTKEYUID_STMT "prepare get_dhtkeyuid from 'SELECT dhtkeyuid FROM dhtkeys where dhtkey = ? and trialuid = @temp_trial'"
 111
 112 #define GET_NODEUID_STMT "prepare get_nodeuid from 'SELECT nodeuid FROM nodes where trialuid = @temp_trial and nodeid = ?'"
 113
 114 #define DATE_STR_SIZE 50
 115
 116 /**
 117  * File to dump all sql statements to.
 118  */
 119 FILE *outfile;
 120
 121
 122 static char *
 123 get_sql_time()
 124 {
 125   static char date[DATE_STR_SIZE];
 126   time_t timetmp;
 127   struct tm *tmptr;
 128
 129   time (&timetmp);
 130   memset (date, 0, DATE_STR_SIZE);
 131   tmptr = localtime (&timetmp);
 132   if (NULL != tmptr)
 133     strftime (date, DATE_STR_SIZE, "%Y-%m-%d %H:%M:%S", tmptr);
 134   else
 135     strcpy (date, "");
 136
 137   return date;
 138 }
 139
 140 /**
 141  * Create a prepared statement.
 142  *
 143  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
 144  */
 145 static int
 146 prepared_statement_create (const char *statement)
 147 {
 148   if (fprintf(outfile, "%s;\n", statement) > 0)
 149     return GNUNET_OK;
 150
 151   return GNUNET_SYSERR;
 152 }
 153
 154 /*
 155  * Initialize the prepared statements for use with dht test logging
 156  */
 157 static int
 158 iopen ()
 159 {
 160 #define PINIT(a) (GNUNET_OK != (prepared_statement_create(a)))
 161   if (PINIT (INSERT_QUERIES_STMT) ||
 162       PINIT (INSERT_ROUTES_STMT) ||
 163       PINIT (INSERT_ROUND_STMT) ||
 164       PINIT (INSERT_TRIALS_STMT) ||
 165       PINIT (SET_MALICIOUS_STMT) ||
 166       PINIT (INSERT_GENERIC_STAT_STMT) ||
 167       PINIT (INSERT_STAT_STMT) ||
 168       PINIT (INSERT_NODES_STMT) ||
 169       PINIT (INSERT_DHTKEY_STMT) ||
 170       PINIT (UPDATE_TRIALS_STMT) ||
 171       PINIT (GET_DHTKEYUID_STMT) ||
 172       PINIT (GET_NODEUID_STMT) ||
 173       PINIT (UPDATE_CONNECTIONS_STMT) ||
 174       PINIT (INSERT_TOPOLOGY_STMT) ||
 175       PINIT (EXTEND_TOPOLOGY_STMT) ||
 176       PINIT (UPDATE_TOPOLOGY_STMT) ||
 177       PINIT (GET_TRIAL_STMT) ||
 178       PINIT (GET_TOPOLOGY_STMT))
 179     {
 180       return GNUNET_SYSERR;
 181     }
 182 #undef PINIT
 183
 184   return GNUNET_OK;
 185 }
 186
 187 /*
 188  * Inserts the specified round into the dhttests.rounds table
 189  *
 190  * @param round_type the type of round that is being started
 191  * @param round_count counter for the round (if applicable)
 192  *
 193  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
 194  */
 195 int add_round (unsigned int round_type, unsigned int round_count)
 196 {
 197   int ret;
 198   if (outfile == NULL)
 199     return GNUNET_SYSERR;
 200
 201   ret = fprintf(outfile, "set @curr_time = \"%s\", @rtype = \"%u\", @rcount = \"%u\";\n", get_sql_time(), round_type, round_count);
 202
 203   if (ret < 0)
 204     return GNUNET_SYSERR;
 205   ret = fprintf(outfile, "execute insert_round;\n");
 206
 207   if (ret >= 0)
 208     return GNUNET_OK;
 209   return GNUNET_SYSERR;
 210 }
 211
 212 /*
 213  * Records the current topology (number of connections, time, trial)
 214  *
 215  * @param num_connections how many connections are in the topology
 216  *
 217  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
 218  */
 219 int
 220 add_topology (int num_connections)
 221 {
 222   int ret;
 223   if (outfile == NULL)
 224     return GNUNET_SYSERR;
 225
 226   ret = fprintf(outfile, "set @date = \"%s\", @num = %d;\n", get_sql_time(), num_connections);
 227
 228   if (ret < 0)
 229     return GNUNET_SYSERR;
 230   ret = fprintf(outfile, "execute insert_topology using "
 231                          "@date, @num;\n");
 232   if (ret < 0)
 233     return GNUNET_SYSERR;
 234
 235   ret = fprintf(outfile, "execute select_topology;\n");
 236
 237   if (ret >= 0)
 238     return GNUNET_OK;
 239   return GNUNET_SYSERR;
 240 }
 241
 242 /*
 243  * Records a connection between two peers in the current topology
 244  *
 245  * @param first one side of the connection
 246  * @param second other side of the connection
 247  *
 248  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
 249  */
 250 int
 251 add_extended_topology (const struct GNUNET_PeerIdentity *first, const struct GNUNET_PeerIdentity *second)
 252 {
 253   int ret;
 254   if (outfile == NULL)
 255     return GNUNET_SYSERR;
 256
 257   if (first != NULL)
 258     ret = fprintf(outfile, "select nodeuid from nodes where trialuid = @temp_trial and nodeid = \"%s\" into @temp_first_node;\n", GNUNET_h2s_full(&first->hashPubKey));
 259   else
 260     ret = fprintf(outfile, "set @temp_first_node = 0;\n");
 261
 262   if (ret < 0)
 263     return GNUNET_SYSERR;
 264
 265   if (second != NULL)
 266     ret = fprintf(outfile, "select nodeuid from nodes where trialuid = @temp_trial and nodeid = \"%s\" into @temp_second_node;\n", GNUNET_h2s_full(&second->hashPubKey));
 267   else
 268     ret = fprintf(outfile, "set @temp_second_node = 0;\n");
 269
 270   if (ret < 0)
 271     return GNUNET_SYSERR;
 272
 273   ret = fprintf(outfile, "execute extend_topology using "
 274                          "@temp_first_node, @temp_second_node;\n");
 275
 276   if (ret >= 0)
 277     return GNUNET_OK;
 278   return GNUNET_SYSERR;
 279 }
 280
 281
 282 /*
 283  * Inserts the specified trial into the dhttests.trials table
 284  *
 285  * @param trial_info struct containing the data to insert about this trial
 286  *
 287  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
 288  */
 289 int add_trial (struct GNUNET_DHTLOG_TrialInfo *trial_info)
 290 {
 291   int ret;
 292
 293   if (outfile == NULL)
 294     return GNUNET_SYSERR;
 295
 296   ret = fprintf(outfile, "set @date = \"%s\", @oid = %u, @num = %u, @topology = %u, @bl = %u, "
 297                    "@connect = %u, @c_t_o = %u, @c_t_o_m = %f, @t_p = %f, "
 298                    "@t_pr = %f, @puts = %u, @gets = %u, "
 299                    "@concurrent = %u, @settle = %u, @rounds = %u, "
 300                    "@m_gets = %u, @m_puts = %u, @m_drops = %u, "
 301                    "@m_g_f = %u, @m_p_f = %u, @s_c = %u, @s_f = %u,"
 302                    "@s_k = %u, @g_s = %u, @message = \"%s\";\n",
 303                    get_sql_time(), trial_info->other_identifier, trial_info->num_nodes, trial_info->topology,
 304                    trial_info->blacklist_topology, trial_info->connect_topology,
 305                    trial_info->connect_topology_option, trial_info->connect_topology_option_modifier,
 306                    trial_info->topology_percentage, trial_info->topology_probability,
 307                    trial_info->puts, trial_info->gets, trial_info->concurrent, trial_info->settle_time,
 308                    trial_info->num_rounds, trial_info->malicious_getters, trial_info->malicious_putters,
 309                    trial_info->malicious_droppers, trial_info->malicious_get_frequency, trial_info->malicious_put_frequency,
 310                    trial_info->stop_closest, trial_info->stop_found, trial_info->strict_kademlia, trial_info->gets_succeeded, trial_info->message);
 311
 312   if (ret < 0)
 313     return GNUNET_SYSERR;
 314   ret = fprintf(outfile, "execute insert_trial using "
 315                          "@date, @oid, @num, @topology, @t_p, @t_pr,"
 316                          " @bl, @connect, @c_t_o,"
 317                          "@c_t_o_m, @puts, @gets,"
 318                          "@concurrent, @settle, @rounds,"
 319                          "@m_gets, @m_puts, @m_drops,"
 320                          "@m_g_f, @m_p_f, @s_c, @s_f,"
 321                          "@s_k, @g_s, @message;\n");
 322   if (ret < 0)
 323     return GNUNET_SYSERR;
 324   ret = fprintf(outfile, "execute select_trial;\n");
 325
 326   if (ret >= 0)
 327     return GNUNET_OK;
 328   return GNUNET_SYSERR;
 329 }
 330
 331
 332 /*
 333  * Inserts the specified stats into the dhttests.generic_stats table
 334  *
 335  * @param peer the peer inserting the statistic
 336  * @param name the name of the statistic
 337  * @param section the section of the statistic
 338  * @param value the value of the statistic
 339  *
 340  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
 341  */
 342 int
 343 add_generic_stat (const struct GNUNET_PeerIdentity *peer,
 344                   const char *name,
 345                   const char *section, uint64_t value)
 346 {
 347   int ret;
 348   if (outfile == NULL)
 349     return GNUNET_SYSERR;
 350
 351   if (peer != NULL)
 352     ret = fprintf(outfile, "select nodeuid from nodes where trialuid = @temp_trial and nodeid = \"%s\" into @temp_node;\n", GNUNET_h2s_full(&peer->hashPubKey));
 353   else
 354     ret = fprintf(outfile, "set @temp_node = 0;\n");
 355
 356   if (ret < 0)
 357     return GNUNET_SYSERR;
 358
 359   ret = fprintf(outfile, "set @temp_section = \"%s\", @temp_stat = \"%s\", @temp_value = %llu;\n",
 360                          section, name, (unsigned long long)value);
 361
 362   if (ret < 0)
 363     return GNUNET_SYSERR;
 364
 365   ret = fprintf(outfile, "execute insert_generic_stat;\n");
 366
 367   if (ret < 0)
 368     return GNUNET_SYSERR;
 369   return GNUNET_OK;
 370 }
 371
 372
 373 /*
 374  * Inserts the specified stats into the dhttests.node_statistics table
 375  *
 376  * @param peer the peer inserting the statistic
 377  * @param route_requests route requests seen
 378  * @param route_forwards route requests forwarded
 379  * @param result_requests route result requests seen
 380  * @param client_requests client requests initiated
 381  * @param result_forwards route results forwarded
 382  * @param gets get requests handled
 383  * @param puts put requests handle
 384  * @param data_inserts data inserted at this node
 385  * @param find_peer_requests find peer requests seen
 386  * @param find_peers_started find peer requests initiated at this node
 387  * @param gets_started get requests initiated at this node
 388  * @param puts_started put requests initiated at this node
 389  * @param find_peer_responses_received find peer responses received locally
 390  * @param get_responses_received get responses received locally
 391  * @param find_peer_responses_sent find peer responses sent from this node
 392  * @param get_responses_sent get responses sent from this node
 393  *
 394  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
 395  */
 396 int
 397 add_stat (const struct GNUNET_PeerIdentity *peer, unsigned int route_requests,
 398           unsigned int route_forwards, unsigned int result_requests,
 399           unsigned int client_requests, unsigned int result_forwards,
 400           unsigned int gets, unsigned int puts,
 401           unsigned int data_inserts, unsigned int find_peer_requests,
 402           unsigned int find_peers_started, unsigned int gets_started,
 403           unsigned int puts_started, unsigned int find_peer_responses_received,
 404           unsigned int get_responses_received, unsigned int find_peer_responses_sent,
 405           unsigned int get_responses_sent)
 406 {
 407   int ret;
 408   if (outfile == NULL)
 409     return GNUNET_SYSERR;
 410
 411   if (peer != NULL)
 412     ret = fprintf(outfile, "select nodeuid from nodes where trialuid = @temp_trial and nodeid = \"%s\" into @temp_node;\n", GNUNET_h2s_full(&peer->hashPubKey));
 413   else
 414     ret = fprintf(outfile, "set @temp_node = 0;\n");
 415   if (ret < 0)
 416     return GNUNET_SYSERR;
 417
 418   ret = fprintf(outfile, "set @r_r = %u, @r_f = %u, @res_r = %u, @c_r = %u, "
 419                          "@res_f = %u, @gets = %u, @puts = %u, @d_i = %u, "
 420                          "@f_p_r = %u, @f_p_s = %u, @g_s = %u, @p_s = %u, "
 421                          "@f_p_r_r = %u, @g_r_r = %u, @f_p_r_s = %u, @g_r_s = %u;\n",
 422                          route_requests, route_forwards, result_requests,
 423                          client_requests, result_forwards, gets, puts,
 424                          data_inserts, find_peer_requests, find_peers_started,
 425                          gets_started, puts_started, find_peer_responses_received,
 426                          get_responses_received, find_peer_responses_sent,
 427                          get_responses_sent);
 428
 429   if (ret < 0)
 430     return GNUNET_SYSERR;
 431
 432   ret = fprintf(outfile, "execute insert_stat using "
 433                          "@temp_trial, @temp_node, @r_r, @r_f, @res_r, @c_r, "
 434                          "@res_f, @gets, @puts, @d_i, "
 435                          "@f_p_r, @f_p_s, @g_s, @p_s, "
 436                          "@f_p_r_r, @g_r_r, @f_p_r_s, @g_r_s;\n");
 437   if (ret < 0)
 438     return GNUNET_SYSERR;
 439   return GNUNET_OK;
 440 }
 441 /*
 442  * Inserts the specified dhtkey into the dhttests.dhtkeys table,
 443  * stores return value of dhttests.dhtkeys.dhtkeyuid into dhtkeyuid
 444  *
 445  * @param dhtkeyuid return value
 446  * @param dhtkey hashcode of key to insert
 447  *
 448  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
 449  */
 450 int
 451 add_dhtkey (unsigned long long *dhtkeyuid, const GNUNET_HashCode * dhtkey)
 452 {
 453   int ret;
 454   if (dhtkeyuid != NULL)
 455     *dhtkeyuid = 0;
 456
 457   if (outfile == NULL)
 458     return GNUNET_SYSERR;
 459
 460   if (dhtkey != NULL)
 461     ret = fprintf(outfile, "set @dhtkey = \"%s\";\n", GNUNET_h2s_full(dhtkey));
 462   else
 463     ret = fprintf(outfile, "set @dhtkey = XXXXX;\n");
 464
 465   if (ret < 0)
 466     return GNUNET_SYSERR;
 467   ret = fprintf(outfile, "execute insert_dhtkey using @dhtkey;\n");
 468
 469   if (ret >= 0)
 470     return GNUNET_OK;
 471   return GNUNET_SYSERR;
 472 }
 473
 474 /*
 475  * Inserts the specified node into the dhttests.nodes table
 476  *
 477  * @param nodeuid the inserted node uid
 478  * @param node the node to insert
 479  *
 480  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
 481  */
 482 int
 483 add_node (unsigned long long *nodeuid, struct GNUNET_PeerIdentity * node)
 484 {
 485   int ret;
 486
 487   if (node == NULL)
 488     return GNUNET_SYSERR;
 489
 490   if (outfile == NULL)
 491     return GNUNET_SYSERR;
 492
 493   ret = fprintf(outfile, "set @node = \"%s\";\n", GNUNET_h2s_full(&node->hashPubKey));
 494
 495   if (ret < 0)
 496     return GNUNET_SYSERR;
 497
 498   ret = fprintf(outfile, "execute insert_node using @node;\n");
 499
 500   if (ret >= 0)
 501     return GNUNET_OK;
 502   return GNUNET_SYSERR;
 503 }
 504
 505 /*
 506  * Update dhttests.trials table with current server time as end time
 507  *
 508  * @param gets_succeeded how many gets did the testcase report as successful
 509  *
 510  * @return GNUNET_OK on success, GNUNET_SYSERR on failure.
 511  */
 512 int
 513 update_trials (unsigned int gets_succeeded)
 514 {
 515   int ret;
 516
 517   if (outfile == NULL)
 518     return GNUNET_SYSERR;
 519
 520   ret = fprintf(outfile, "set @date = \"%s\", @g_s = %u;\n", get_sql_time(), gets_succeeded);
 521
 522   if (ret < 0)
 523     return GNUNET_SYSERR;
 524
 525   ret = fprintf(outfile, "execute update_trial using @date, @g_s;\n");
 526
 527   if (ret >= 0)
 528     return GNUNET_OK;
 529   else
 530     return GNUNET_SYSERR;
 531 }
 532
 533
 534 /*
 535  * Update dhttests.nodes table setting the identified
 536  * node as a malicious dropper.
 537  *
 538  * @param peer the peer that was set to be malicious
 539  *
 540  * @return GNUNET_OK on success, GNUNET_SYSERR on failure.
 541  */
 542 int
 543 set_malicious (struct GNUNET_PeerIdentity *peer)
 544 {
 545   int ret;
 546
 547   if (outfile == NULL)
 548     return GNUNET_SYSERR;
 549
 550   ret = fprintf(outfile, "set @temp_node = \"%s\";\n", GNUNET_h2s_full(&peer->hashPubKey));
 551
 552   if (ret < 0)
 553     return GNUNET_SYSERR;
 554
 555   ret = fprintf(outfile, "execute set_malicious;\n");
 556
 557   if (ret >= 0)
 558     return GNUNET_OK;
 559   else
 560     return GNUNET_SYSERR;
 561 }
 562
 563
 564 /*
 565  * Update dhttests.trials table with total connections information
 566  *
 567  * @param totalConnections the number of connections
 568  *
 569  * @return GNUNET_OK on success, GNUNET_SYSERR on failure.
 570  */
 571 int
 572 add_connections (unsigned int totalConnections)
 573 {
 574   int ret;
 575
 576   if (outfile == NULL)
 577     return GNUNET_SYSERR;
 578
 579   ret = fprintf(outfile, "set @conns = %u;\n", totalConnections);
 580
 581   if (ret < 0)
 582     return GNUNET_SYSERR;
 583
 584   ret = fprintf(outfile, "execute update_conn using @conns;\n");
 585
 586   if (ret >= 0)
 587     return GNUNET_OK;
 588   else
 589     return GNUNET_SYSERR;
 590 }
 591
 592
 593 /*
 594  * Update dhttests.topology table with total connections information
 595  *
 596  * @param totalConnections the number of connections
 597  *
 598  * @return GNUNET_OK on success, GNUNET_SYSERR on failure.
 599  */
 600 int
 601 update_topology (unsigned int connections)
 602 {
 603   int ret;
 604   if (outfile == NULL)
 605     return GNUNET_SYSERR;
 606
 607   ret = fprintf(outfile, "set @temp_conns = %u;\n", connections);
 608
 609   if (ret < 0)
 610     return GNUNET_SYSERR;
 611
 612   ret = fprintf(outfile, "execute update_topology using @temp_conns;\n");
 613
 614   if (ret >= 0)
 615     return GNUNET_OK;
 616   else
 617     return GNUNET_SYSERR;
 618 }
 619
 620 /*
 621  * Inserts the specified query into the dhttests.queries table
 622  *
 623  * @param sqlqueruid inserted query uid
 624  * @param queryid dht query id
 625  * @param type type of the query
 626  * @param hops number of hops query traveled
 627  * @param succeeded whether or not query was successful
 628  * @param node the node the query hit
 629  * @param key the key of the query
 630  *
 631  * @return GNUNET_OK on success, GNUNET_SYSERR on failure.
 632  */
 633 int
 634 add_query (unsigned long long *sqlqueryuid, unsigned long long queryid,
 635            unsigned int type, unsigned int hops, int succeeded,
 636            const struct GNUNET_PeerIdentity * node, const GNUNET_HashCode * key)
 637 {
 638   int ret;
 639
 640   if (outfile == NULL)
 641     return GNUNET_SYSERR;
 642
 643   if (sqlqueryuid != NULL)
 644     *sqlqueryuid = 0;
 645
 646   if (key != NULL)
 647     ret = fprintf(outfile, "select dhtkeyuid from dhtkeys where trialuid = @temp_trial and dhtkey = \"%s\" into @temp_dhtkey;\n", GNUNET_h2s_full(key));
 648   else
 649     ret = fprintf(outfile, "set @temp_dhtkey = 0;\n");
 650
 651   if (ret < 0)
 652     return GNUNET_SYSERR;
 653
 654   if (node != NULL)
 655     ret = fprintf(outfile, "select nodeuid from nodes where trialuid = @temp_trial and nodeid = \"%s\" into @temp_node;\n", GNUNET_h2s_full(&node->hashPubKey));
 656   else
 657     ret = fprintf(outfile, "set @temp_node = 0;\n");
 658
 659   if (ret < 0)
 660     return GNUNET_SYSERR;
 661
 662   ret = fprintf(outfile, "set @qid = %llu, @type = %u, @hops = %u, @succ = %d, @time = \"%s\";\n", queryid, type, hops, succeeded, get_sql_time());
 663
 664   if (ret < 0)
 665     return GNUNET_SYSERR;
 666
 667   ret = fprintf(outfile, "execute insert_query using @type, @hops, @temp_dhtkey, @qid, @succ, @temp_node, @time;\n");
 668
 669   if (ret >= 0)
 670     return GNUNET_OK;
 671   else
 672     return GNUNET_SYSERR;
 673 }
 674
 675 /*
 676  * Inserts the specified route information into the dhttests.routes table
 677  *
 678  * @param sqlqueruid inserted query uid
 679  * @param queryid dht query id
 680  * @param type type of the query
 681  * @param hops number of hops query traveled
 682  * @param succeeded whether or not query was successful
 683  * @param node the node the query hit
 684  * @param key the key of the query
 685  * @param from_node the node that sent the message to node
 686  * @param to_node next node to forward message to
 687  *
 688  * @return GNUNET_OK on success, GNUNET_SYSERR on failure.
 689  */
 690 int
 691 add_route (unsigned long long *sqlqueryuid, unsigned long long queryid,
 692            unsigned int type, unsigned int hops,
 693            int succeeded, const struct GNUNET_PeerIdentity * node,
 694            const GNUNET_HashCode * key, const struct GNUNET_PeerIdentity * from_node,
 695            const struct GNUNET_PeerIdentity * to_node)
 696 {
 697   int ret;
 698
 699   if (outfile == NULL)
 700     return GNUNET_SYSERR;
 701
 702   if (sqlqueryuid != NULL)
 703     *sqlqueryuid = 0;
 704
 705   if (key != NULL)
 706     ret = fprintf(outfile, "select dhtkeyuid from dhtkeys where trialuid = @temp_trial and dhtkey = \"%s\" into @temp_dhtkey;\n", GNUNET_h2s_full(key));
 707   else
 708     ret = fprintf(outfile, "set @temp_dhtkey = 0;\n");
 709
 710   if (ret < 0)
 711     return GNUNET_SYSERR;
 712
 713   if (node != NULL)
 714     ret = fprintf(outfile, "select nodeuid from nodes where trialuid = @temp_trial and nodeid = \"%s\" into @temp_node;\n", GNUNET_h2s_full(&node->hashPubKey));
 715   else
 716     ret = fprintf(outfile, "set @temp_node = 0;\n");
 717
 718   if (ret < 0)
 719     return GNUNET_SYSERR;
 720
 721   if (from_node != NULL)
 722     ret = fprintf(outfile, "select nodeuid from nodes where trialuid = @temp_trial and nodeid = \"%s\" into @temp_from_node;\n", GNUNET_h2s_full(&from_node->hashPubKey));
 723   else
 724     ret = fprintf(outfile, "set @temp_from_node = 0;\n");
 725
 726   if (ret < 0)
 727     return GNUNET_SYSERR;
 728
 729   if (to_node != NULL)
 730     ret = fprintf(outfile, "select nodeuid from nodes where trialuid = @temp_trial and nodeid = \"%s\" into @temp_to_node;\n", GNUNET_h2s_full(&to_node->hashPubKey));
 731   else
 732     ret = fprintf(outfile, "set @temp_to_node = 0;\n");
 733
 734   if (ret < 0)
 735     return GNUNET_SYSERR;
 736
 737   ret = fprintf(outfile, "set @qid = %llu, @type = %u, @hops = %u, @succ = %d;\n", queryid, type, hops, succeeded);
 738
 739   if (ret < 0)
 740     return GNUNET_SYSERR;
 741
 742   ret = fprintf(outfile, "execute insert_route using @type, @hops, @temp_dhtkey, @qid, @succ, @temp_node, @temp_from_node, @temp_to_node;\n");
 743
 744   if (ret >= 0)
 745     return GNUNET_OK;
 746   else
 747     return GNUNET_SYSERR;
 748 }
 749
 750 /*
 751  * Provides the dhtlog api
 752  *
 753  * @param c the configuration to use to connect to a server
 754  *
 755  * @return the handle to the server, or NULL on error
 756  */
 757 void *
 758 libgnunet_plugin_dhtlog_mysql_dump_init (void * cls)
 759 {
 760   struct GNUNET_DHTLOG_Plugin *plugin = cls;
 761   char *outfile_name;
 762   char *outfile_path;
 763   char *fn;
 764   int dirwarn;
 765
 766   cfg = plugin->cfg;
 767   max_varchar_len = 255;
 768
 769   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MySQL (DUMP) DHT Logger: initializing\n");
 770
 771   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (plugin->cfg,
 772                                                          "MYSQLDUMP", "PATH",
 773                                                          &outfile_path))
 774     {
 775       outfile_path = GNUNET_strdup("");
 776     }
 777
 778   GNUNET_asprintf (&outfile_name,
 779                    "%s%s-%d",
 780                    outfile_path,
 781                    "mysqldump",
 782                    getpid());
 783
 784   fn = GNUNET_STRINGS_filename_expand (outfile_name);
 785
 786   if (fn == NULL)
 787     {
 788       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("Failed to get full path for `%s'\n"), outfile_name);
 789       GNUNET_free(outfile_path);
 790       GNUNET_free(outfile_name);
 791       return NULL;
 792     }
 793
 794   dirwarn = (GNUNET_OK !=  GNUNET_DISK_directory_create_for_file (fn));
 795   outfile = FOPEN (fn, "w");
 796
 797   if (outfile == NULL)
 798     {
 799       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "fopen", fn);
 800       if (dirwarn)
 801         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 802                     _("Failed to create or access directory for log file `%s'\n"),
 803                     fn);
 804       GNUNET_free(outfile_path);
 805       GNUNET_free(outfile_name);
 806       GNUNET_free (fn);
 807       return NULL;
 808     }
 809
 810   GNUNET_free (outfile_path);
 811   GNUNET_free (outfile_name);
 812   GNUNET_free (fn);
 813
 814   if (iopen () != GNUNET_OK)
 815     {
 816       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 817                   _("Failed to create file for dhtlog.\n"));
 818       return NULL;
 819     }
 820   GNUNET_assert(plugin->dhtlog_api == NULL);
 821   plugin->dhtlog_api = GNUNET_malloc(sizeof(struct GNUNET_DHTLOG_Handle));
 822   plugin->dhtlog_api->insert_trial = &add_trial;
 823   plugin->dhtlog_api->insert_round = &add_round;
 824   plugin->dhtlog_api->insert_stat = &add_stat;
 825   plugin->dhtlog_api->insert_query = &add_query;
 826   plugin->dhtlog_api->update_trial = &update_trials;
 827   plugin->dhtlog_api->insert_route = &add_route;
 828   plugin->dhtlog_api->insert_node = &add_node;
 829   plugin->dhtlog_api->insert_dhtkey = &add_dhtkey;
 830   plugin->dhtlog_api->update_connections = &add_connections;
 831   plugin->dhtlog_api->insert_topology = &add_topology;
 832   plugin->dhtlog_api->insert_extended_topology = &add_extended_topology;
 833   plugin->dhtlog_api->update_topology = &update_topology;
 834   plugin->dhtlog_api->set_malicious = &set_malicious;
 835   plugin->dhtlog_api->add_generic_stat = &add_generic_stat;
 836
 837   return plugin;
 838 }
 839
 840 /**
 841  * Shutdown the plugin.
 842  */
 843 void *
 844 libgnunet_plugin_dhtlog_mysql_dump_done (void * cls)
 845 {
 846   struct GNUNET_DHTLOG_Handle *dhtlog_api = cls;
 847   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 848               "MySQL DHT Logger: database shutdown\n");
 849   GNUNET_assert(dhtlog_api != NULL);
 850
 851   GNUNET_free(dhtlog_api);
 852   return NULL;
 853 }
 854
 855 /* end of plugin_dhtlog_mysql.c */