#define VERBOSE_TOPOLOGY GNUNET_NO
-#define DEBUG_CHURN GNUNET_NO
+#define DEBUG_CHURN GNUNET_EXTRA_LOGGING
#define USE_START_HELPER GNUNET_YES
* stagger hostkey generation and peer startup.
*/
struct InternalStartContext internal_context;
+
+ /**
+ * Task ID for the queued internal_continue_startup task
+ */
+ GNUNET_SCHEDULER_TaskIdentifier startup_task;
+
};
/**
{
if (meter->completed == 0)
{
- fprintf (stdout, "%sProgress: [0%%", meter->startup_string);
+ FPRINTF (stdout, "%sProgress: [0%%", meter->startup_string);
}
else
- fprintf (stdout, "%d%%",
+ FPRINTF (stdout, "%d%%",
(int) (((float) meter->completed / meter->total) * 100));
}
else if (meter->completed % meter->dotnum == 0)
- fprintf (stdout, ".");
+ FPRINTF (stdout, "%s", ".");
if (meter->completed + 1 == meter->total)
- fprintf (stdout, "%d%%]\n", 100);
+ FPRINTF (stdout, "%d%%]\n", 100);
fflush (stdout);
}
meter->completed++;
GNUNET_asprintf (&single_variable, "single_%s_per_host", section);
GNUNET_asprintf (&per_host_variable, "num_%s_per_host", section);
- if ((0 == strcmp (option, "PORT")) && (1 == sscanf (value, "%u", &ival)))
+ if ((0 == strcmp (option, "PORT")) && (1 == SSCANF (value, "%u", &ival)))
{
if ((ival != 0) &&
(GNUNET_YES !=
*
* @return new configuration, NULL on error
*/
-static struct GNUNET_CONFIGURATION_Handle *
-make_config (const struct GNUNET_CONFIGURATION_Handle *cfg, uint32_t off,
+struct GNUNET_CONFIGURATION_Handle *
+GNUNET_TESTING_create_cfg (const struct GNUNET_CONFIGURATION_Handle *cfg, uint32_t off,
uint16_t * port, uint32_t * upnum, const char *hostname,
uint32_t * fdnum)
{
}
else
{
+
GNUNET_CONFIGURATION_set_value_string (uc.ret, "transport-tcp",
"USE_LOCALADDR", "YES");
GNUNET_CONFIGURATION_set_value_string (uc.ret, "transport-udp",
"127.0.0.1");
GNUNET_CONFIGURATION_set_value_string (uc.ret, "nat", "EXTERNAL_ADDRESS",
"127.0.0.1");
- GNUNET_CONFIGURATION_set_value_string (uc.ret, "disablev6", "BINDTO",
+ GNUNET_CONFIGURATION_set_value_string (uc.ret, "nat", "disablev6",
"YES");
}
return removed;
}
-/*
+/**
* Add entries to the some list
*
* @param pg the peer group we are working with
GNUNET_CONFIGURATION_get_value_string (pg->cfg, "TESTING", "PERCENTAGE",
&p_string))
{
- if (sscanf (p_string, "%lf", &logNModifier) != 1)
+ if (SSCANF (p_string, "%lf", &logNModifier) != 1)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_
("Invalid value `%s' for option `%s' in section `%s': expected float\n"),
GNUNET_CONFIGURATION_get_value_string (pg->cfg, "TESTING", "PROBABILITY",
&p_string))
{
- if (sscanf (p_string, "%lf", &probability) != 1)
+ if (SSCANF (p_string, "%lf", &probability) != 1)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_
("Invalid value `%s' for option `%s' in section `%s': expected float\n"),
GNUNET_CONFIGURATION_get_value_string (pg->cfg, "TESTING", "PERCENTAGE",
&p_string))
{
- if (sscanf (p_string, "%lf", &nat_percentage) != 1)
+ if (SSCANF (p_string, "%lf", &nat_percentage) != 1)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_
("Invalid value `%s' for option `%s' in section `%s': expected float\n"),
GNUNET_CONFIGURATION_get_value_string (pg->cfg, "TESTING", "PERCENTAGE",
&p_string))
{
- if (sscanf (p_string, "%lf", &nat_percentage) != 1)
+ if (SSCANF (p_string, "%lf", &nat_percentage) != 1)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_
("Invalid value `%s' for option `%s' in section `%s': expected float\n"),
GNUNET_CONFIGURATION_get_value_string (pg->cfg, "TESTING", "PERCENTAGE",
&p_string))
{
- if (sscanf (p_string, "%lf", &percentage) != 1)
+ if (SSCANF (p_string, "%lf", &percentage) != 1)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_
("Invalid value `%s' for option `%s' in section `%s': expected float\n"),
GNUNET_CONFIGURATION_get_value_string (pg->cfg, "TESTING", "PROBABILITY",
&p_string))
{
- if (sscanf (p_string, "%lf", &probability) != 1)
+ if (SSCANF (p_string, "%lf", &probability) != 1)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_
("Invalid value `%s' for option `%s' in section `%s': expected float\n"),
GNUNET_CONFIGURATION_get_value_string (pg->cfg, "TESTING", "PROBABILITY",
&p_string))
{
- if (sscanf (p_string, "%lf", &probability) != 1)
+ if (SSCANF (p_string, "%lf", &probability) != 1)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_
("Invalid value `%s' for option `%s' in section `%s': expected float\n"),
GNUNET_free (data);
return connect_attempts;
}
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Read %u total peers in topology\n", total_peers);
+#if DEBUG_TESTING
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found %u total peers in topology\n",
+ total_peers);
+#endif
GNUNET_assert (total_peers == pg->total);
curr_state = PEER_INDEX;
while ((buf[count] != '\n') && (count < frstat.st_size - 1))
temppeer = &peer->id;
GNUNET_CRYPTO_hash_to_enc (&temppeer->hashPubKey, &peer_enc);
- fprintf (temp_friend_handle, "%s\n", (char *) &peer_enc);
+ FPRINTF (temp_friend_handle, "%s\n", (char *) &peer_enc);
return GNUNET_YES;
}
GNUNET_CRYPTO_hash_to_enc (&temppeer->hashPubKey, &peer_enc);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Writing entry %s:%s to file\n",
blacklist_ctx->transport, (char *) &peer_enc);
- fprintf (blacklist_ctx->temp_file_handle, "%s:%s\n", blacklist_ctx->transport,
+ FPRINTF (blacklist_ctx->temp_file_handle, "%s:%s\n", blacklist_ctx->transport,
(char *) &peer_enc);
return GNUNET_YES;
{
mytemp = GNUNET_DISK_mktemp ("friends");
GNUNET_assert (mytemp != NULL);
- temp_friend_handle = fopen (mytemp, "wt");
+ temp_friend_handle = FOPEN (mytemp, "wt");
GNUNET_assert (temp_friend_handle != NULL);
#if OLD
conn_iter = pg->peers[pg_iter].allowed_peers_head;
{
GNUNET_CRYPTO_hash_to_enc (&pg->peers[conn_iter->index].daemon->
id.hashPubKey, &peer_enc);
- fprintf (temp_friend_handle, "%s\n", (char *) &peer_enc);
+ FPRINTF (temp_friend_handle, "%s\n", (char *) &peer_enc);
conn_iter = conn_iter->next;
}
#else
&friend_file_iterator,
temp_friend_handle);
#endif
- fclose (temp_friend_handle);
+ FCLOSE (temp_friend_handle);
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (pg->peers[pg_iter].daemon->cfg,
if (pg->peers[pg_iter].daemon->hostname == NULL) /* Local, just copy the file */
{
GNUNET_asprintf (&arg, "%s/friends", temp_service_path);
- procarr[pg_iter] =
- GNUNET_OS_start_process (NULL, NULL, "mv", "mv", mytemp, arg, NULL);
- GNUNET_assert (procarr[pg_iter] != NULL);
#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Copying file with command cp %s %s\n", mytemp, arg);
+ "Copying file with RENAME(%s,%s)\n", mytemp, arg);
#endif
- ret = GNUNET_OS_process_wait (procarr[pg_iter]); /* FIXME: schedule this, throttle! */
- GNUNET_OS_process_close (procarr[pg_iter]);
+ RENAME (mytemp, arg);
+ procarr[pg_iter] = NULL;
GNUNET_free (arg);
}
else /* Remote, scp the file to the correct place */
pg->peers[pg_iter].daemon->hostname,
temp_service_path);
procarr[pg_iter] =
- GNUNET_OS_start_process (NULL, NULL, "scp", "scp", mytemp, arg, NULL);
+ GNUNET_OS_start_process (GNUNET_NO, NULL, NULL, "scp", "scp", mytemp, arg, NULL);
GNUNET_assert (procarr[pg_iter] != NULL);
ret = GNUNET_OS_process_wait (procarr[pg_iter]); /* FIXME: schedule this, throttle! */
GNUNET_OS_process_close (procarr[pg_iter]);
{
mytemp = GNUNET_DISK_mktemp ("blacklist");
GNUNET_assert (mytemp != NULL);
- temp_file_handle = fopen (mytemp, "wt");
+ temp_file_handle = FOPEN (mytemp, "wt");
GNUNET_assert (temp_file_handle != NULL);
temp_transports = GNUNET_strdup (transports);
#if !OLD
{
GNUNET_CRYPTO_hash_to_enc (&pg->peers[conn_iter->index].daemon->
id.hashPubKey, &peer_enc);
- fprintf (temp_file_handle, "%s:%s\n", pos, (char *) &peer_enc);
+ FPRINTF (temp_file_handle, "%s:%s\n", pos, (char *) &peer_enc);
conn_iter = conn_iter->next;
}
#else
}
GNUNET_free (temp_transports);
- fclose (temp_file_handle);
+ FCLOSE (temp_file_handle);
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (pg->peers[pg_iter].daemon->cfg,
if (pg->peers[pg_iter].daemon->hostname == NULL) /* Local, just copy the file */
{
GNUNET_asprintf (&arg, "%s/blacklist", temp_service_path);
- procarr[pg_iter] =
- GNUNET_OS_start_process (NULL, NULL, "mv", "mv", mytemp, arg, NULL);
+ RENAME (mytemp, arg);
+ procarr[pg_iter] = NULL;
#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- _("Copying file with command cp %s %s\n"), mytemp, arg);
+ _("Copying file with RENAME (%s,%s)\n"), mytemp, arg);
#endif
GNUNET_free (arg);
pg->peers[pg_iter].daemon->hostname,
temp_service_path);
procarr[pg_iter] =
- GNUNET_OS_start_process (NULL, NULL, "scp", "scp", mytemp, arg, NULL);
+ GNUNET_OS_start_process (GNUNET_NO, NULL, NULL, "scp", "scp", mytemp, arg, NULL);
GNUNET_assert (procarr[pg_iter] != NULL);
GNUNET_OS_process_wait (procarr[pg_iter]); /* FIXME: add scheduled blacklist file copy that parallelizes file copying! */
conn = send_hello_context->peer->connect_peers_head;
while (conn != NULL)
{
- GNUNET_CORE_peer_request_connect (send_hello_context->peer->
- daemon->server,
- &send_hello_context->pg->
- peers[conn->index].daemon->id, NULL,
- NULL);
+ GNUNET_TRANSPORT_try_connect (send_hello_context->peer->daemon->th,
+ &send_hello_context->pg->peers[conn->
+ index].daemon->
+ id);
conn = conn->next;
}
send_hello_context->core_connect_task =
*/
static void
core_connect_notify (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+ const struct GNUNET_ATS_Information *atsi)
{
struct SendHelloContext *send_hello_context = cls;
struct PeerConnection *connection;
struct PeerData *other_peer;
#endif
#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Connected peer %s to peer %s\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected peer %s to peer %s\n",
ctx->d1->shortname, GNUNET_i2s (peer));
#endif
if (connection == NULL)
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Connected peer %s to %s, not in list (no problem(?))\n",
GNUNET_i2s (peer), send_hello_context->peer->daemon->shortname);
}
* @param cls a struct SendHelloContext *
* @param server handle to the core service
* @param my_identity the peer identity of this peer
- * @param publicKey the public key of the peer
*/
void
core_init (void *cls, struct GNUNET_CORE_Handle *server,
- const struct GNUNET_PeerIdentity *my_identity,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey)
+ struct GNUNET_PeerIdentity *my_identity)
{
struct SendHelloContext *send_hello_context = cls;
send_hello_context->pg->remaining_hellos--;
#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Sent HELLO, have %d remaining!\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sent HELLO, have %d remaining!\n",
send_hello_context->pg->remaining_hellos);
#endif
if (send_hello_context->peer_pos == NULL) /* All HELLOs (for this peer!) have been transmitted! */
send_hello_context, NULL, NULL, NULL);
}
#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Offering Hello of peer %s to peer %s\n"),
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ _("Offering HELLO of peer %s to peer %s\n"),
send_hello_context->peer->daemon->shortname,
pg->peers[send_hello_context->peer_pos->index].
daemon->shortname);
(pg->stop_connects == GNUNET_YES))
{
#if VERBOSE_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_
("Delaying connect, we have too many outstanding connections!\n"));
#endif
return;
}
#if VERBOSE_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_
("Creating connection, outstanding_connections is %d (max %d)\n"),
pg->outstanding_connects, pg->max_outstanding_connections);
switch (topology)
{
case GNUNET_TESTING_TOPOLOGY_CLIQUE:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Creating clique topology\n"));
-#endif
num_connections = create_clique (pg, &add_connections, ALLOWED, GNUNET_NO);
break;
case GNUNET_TESTING_TOPOLOGY_SMALL_WORLD_RING:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Creating small world (ring) topology\n"));
-#endif
num_connections = create_small_world_ring (pg, &add_connections, ALLOWED);
break;
case GNUNET_TESTING_TOPOLOGY_SMALL_WORLD:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Creating small world (2d-torus) topology\n"));
-#endif
num_connections = create_small_world (pg, &add_connections, ALLOWED);
break;
case GNUNET_TESTING_TOPOLOGY_RING:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Creating ring topology\n"));
-#endif
num_connections = create_ring (pg, &add_connections, ALLOWED);
break;
case GNUNET_TESTING_TOPOLOGY_2D_TORUS:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Creating 2d torus topology\n"));
-#endif
num_connections = create_2d_torus (pg, &add_connections, ALLOWED);
break;
case GNUNET_TESTING_TOPOLOGY_ERDOS_RENYI:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Creating Erdos-Renyi topology\n"));
-#endif
num_connections = create_erdos_renyi (pg, &add_connections, ALLOWED);
break;
case GNUNET_TESTING_TOPOLOGY_INTERNAT:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Creating InterNAT topology\n"));
-#endif
num_connections = create_nated_internet (pg, &add_connections, ALLOWED);
break;
case GNUNET_TESTING_TOPOLOGY_SCALE_FREE:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Creating Scale Free topology\n"));
-#endif
num_connections = create_scale_free (pg, &add_connections, ALLOWED);
break;
case GNUNET_TESTING_TOPOLOGY_LINE:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Creating straight line topology\n"));
-#endif
num_connections = create_line (pg, &add_connections, ALLOWED);
break;
case GNUNET_TESTING_TOPOLOGY_FROM_FILE:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Creating topology from file!\n"));
-#endif
if (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_string (pg->cfg, "testing",
"topology_file", &filename))
}
break;
case GNUNET_TESTING_TOPOLOGY_NONE:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_
("Creating no allowed topology (all peers can connect at core level)\n"));
-#endif
num_connections = pg->total * pg->total; /* Clique is allowed! */
break;
default:
ret = create_and_copy_friend_files (pg);
if (ret != GNUNET_OK)
{
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Failed during friend file copying!\n"));
-#endif
return GNUNET_SYSERR;
}
else
{
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Friend files created/copied successfully!\n"));
-#endif
}
}
switch (restrict_topology)
{
case GNUNET_TESTING_TOPOLOGY_CLIQUE:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Blacklisting all but clique topology\n"));
-#endif
unblacklisted_connections =
create_clique (pg, &remove_connections, BLACKLIST, GNUNET_NO);
break;
case GNUNET_TESTING_TOPOLOGY_SMALL_WORLD_RING:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Blacklisting all but small world (ring) topology\n"));
-#endif
unblacklisted_connections =
create_small_world_ring (pg, &remove_connections, BLACKLIST);
break;
case GNUNET_TESTING_TOPOLOGY_SMALL_WORLD:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Blacklisting all but small world (2d-torus) topology\n"));
-#endif
unblacklisted_connections =
create_small_world (pg, &remove_connections, BLACKLIST);
break;
case GNUNET_TESTING_TOPOLOGY_RING:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Blacklisting all but ring topology\n"));
-#endif
unblacklisted_connections =
create_ring (pg, &remove_connections, BLACKLIST);
break;
case GNUNET_TESTING_TOPOLOGY_2D_TORUS:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Blacklisting all but 2d torus topology\n"));
-#endif
unblacklisted_connections =
create_2d_torus (pg, &remove_connections, BLACKLIST);
break;
case GNUNET_TESTING_TOPOLOGY_ERDOS_RENYI:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Blacklisting all but Erdos-Renyi topology\n"));
-#endif
unblacklisted_connections =
create_erdos_renyi (pg, &remove_connections, BLACKLIST);
break;
case GNUNET_TESTING_TOPOLOGY_INTERNAT:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Blacklisting all but InterNAT topology\n"));
-#endif
#if TOPOLOGY_HACK
for (off = 0; off < pg->total; off++)
break;
case GNUNET_TESTING_TOPOLOGY_SCALE_FREE:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Blacklisting all but Scale Free topology\n"));
-#endif
unblacklisted_connections =
create_scale_free (pg, &remove_connections, BLACKLIST);
break;
case GNUNET_TESTING_TOPOLOGY_LINE:
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Blacklisting all but straight line topology\n"));
-#endif
unblacklisted_connections =
create_line (pg, &remove_connections, BLACKLIST);
default:
if ((unblacklisted_connections > 0) && (restrict_transports != NULL))
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Creating blacklist with `%s'\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating blacklist with `%s'\n",
restrict_transports);
ret = create_and_copy_blacklist_files (pg, restrict_transports);
if (ret != GNUNET_OK)
{
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Failed during blacklist file copying!\n"));
-#endif
return 0;
}
else
{
-#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Blacklist files created/copied successfully!\n"));
-#endif
}
}
return num_connections;
*/
static void
internal_topology_callback (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+ const struct GNUNET_ATS_Information *atsi,
+ unsigned int atsi_count)
{
struct CoreContext *core_ctx = cls;
struct TopologyIterateContext *iter_ctx = core_ctx->iter_context;
&internal_topology_callback, core_context))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Topology iteration failed.\n");
- internal_topology_callback (core_context, NULL, NULL);
+ internal_topology_callback (core_context, NULL, NULL, 0);
}
}
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Retrieving stats from %u total instances.\n", total_count);
- stats_context->total = total_count;
+ if (0 != total_count)
+ stats_context->total = total_count;
+ else
+ GNUNET_free (stats_context);
if (stats_list != NULL)
{
pos = stats_list;
emsg);
}
+
+/**
+ * Calls GNUNET_TESTING_daemon_continue_startup to set the daemon's state
+ * from HOSTKEY_CREATED to TOPOLOGY_SETUP. Makes sure not to saturate a host
+ * with requests delaying them when needed.
+ *
+ * @param cls closure: internal context of the daemon.
+ * @param tc TaskContext
+ */
static void
internal_continue_startup (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct InternalStartContext *internal_context = cls;
+ internal_context->peer->startup_task = GNUNET_SCHEDULER_NO_TASK;
+
if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
{
return;
}
else
{
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
- (GNUNET_TIME_UNIT_MILLISECONDS, 100),
- &internal_continue_startup, internal_context);
+ internal_context->peer->startup_task =
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_MILLISECONDS, 100),
+ &internal_continue_startup,
+ internal_context);
}
}
/* FIXME: Doesn't support ssh_port option! */
helper->proc =
- GNUNET_OS_start_process (NULL, NULL, "ssh", "ssh", arg,
+ GNUNET_OS_start_process (GNUNET_NO, NULL, NULL, "ssh", "ssh", arg,
"peerStartHelper.pl", tempdir, NULL);
GNUNET_assert (helper->proc != NULL);
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "starting peers with cmd ssh %s %s %s\n", arg,
- "peerStartHelper.pl", tempdir);
+#if DEBUG_TESTING
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "starting peers with cmd ssh %s %s %s\n",
+ arg, "peerStartHelper.pl", tempdir);
+#endif
GNUNET_SCHEDULER_add_now (&check_peers_started, helper);
GNUNET_free (tempdir);
GNUNET_free (baseservicehome);
pg->starting = 0;
for (i = 0; i < pg->total; i++)
{
- GNUNET_SCHEDULER_add_now (&internal_continue_startup,
- &pg->peers[i].internal_context);
+ pg->peers[i].startup_task =
+ GNUNET_SCHEDULER_add_now (&internal_continue_startup,
+ &pg->peers[i].internal_context);
}
}
#else
pg->starting = 0;
for (i = 0; i < pg->total; i++)
{
- GNUNET_SCHEDULER_add_now (&internal_continue_startup,
- &pg->peers[i].internal_context);
+ pg->peers[i].startup_task =
+ GNUNET_SCHEDULER_add_now (&internal_continue_startup,
+ &pg->peers[i].internal_context);
}
#endif
}
{
GNUNET_asprintf (&ssh_port_str, "%d", pg->hosts[i].sshport);
proc =
- GNUNET_OS_start_process (NULL, NULL, "ssh", "ssh", "-P", ssh_port_str,
+ GNUNET_OS_start_process (GNUNET_NO, NULL, NULL, "ssh", "ssh", "-P", ssh_port_str,
#if !DEBUG_TESTING
"-q",
#endif
}
else
proc =
- GNUNET_OS_start_process (NULL, NULL, "ssh", "ssh", arg, "mkdir -p",
+ GNUNET_OS_start_process (GNUNET_NO, NULL, NULL, "ssh", "ssh", arg, "mkdir -p",
tmpdir, NULL);
GNUNET_assert (proc != NULL);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
if (GNUNET_YES != GNUNET_DISK_file_size (hostkeys_file, &fs, GNUNET_YES))
fs = 0;
-
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Found file size %llu for hostkeys, expect hostkeys to be size %d\n",
- fs, HOSTKEYFILESIZE);
-
+#if DEBUG_TESTING
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Found file size %llu for hostkeys\n", fs);
+#endif
if (0 != (fs % HOSTKEYFILESIZE))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
else
{
total_hostkeys = fs / HOSTKEYFILESIZE;
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Will read %llu hostkeys from file\n", total_hostkeys);
pg->hostkey_data = GNUNET_malloc_large (fs);
GNUNET_assert (fs == GNUNET_DISK_file_read (fd, pg->hostkey_data, fs));
username = pg->hosts[off % hostcnt].username;
sshport = pg->hosts[off % hostcnt].sshport;
pcfg =
- make_config (cfg, off, &pg->hosts[off % hostcnt].minport, &upnum,
+ GNUNET_TESTING_create_cfg (cfg, off, &pg->hosts[off % hostcnt].minport, &upnum,
hostname, &fdnum);
}
else
hostname = NULL;
username = NULL;
sshport = 0;
- pcfg = make_config (cfg, off, &minport, &upnum, hostname, &fdnum);
+ pcfg = GNUNET_TESTING_create_cfg (cfg, off, &minport, &upnum, hostname, &fdnum);
}
if (NULL == pcfg)
GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS", "SERVICEHOME",
&baseservicehome))
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "baseservice home is %s\n",
+#if DEBUG_TESTING
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "baseservice home is %s\n",
baseservicehome);
+#endif
if (hostname != NULL)
GNUNET_asprintf (&newservicehome, "%s/%s/", baseservicehome,
hostname);
/* FIXME: Doesn't support ssh_port option! */
proc =
- GNUNET_OS_start_process (NULL, NULL, "rsync", "rsync", "-r",
+ GNUNET_OS_start_process (GNUNET_NO, NULL, NULL, "rsync", "rsync", "-r",
newservicehome, arg, NULL);
-
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+#if DEBUG_TESTING
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"copying directory with command rsync -r %s %s\n",
newservicehome, arg);
+#endif
GNUNET_free (newservicehome);
GNUNET_free (arg);
if (NULL == proc)
*/
struct GNUNET_TESTING_Daemon *
GNUNET_TESTING_daemon_get_by_id (struct GNUNET_TESTING_PeerGroup *pg,
- struct GNUNET_PeerIdentity *peer_id)
+ const struct GNUNET_PeerIdentity *peer_id)
{
unsigned int i;
for (i = 0; i < voff; i++)
{
#if DEBUG_CHURN
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Stopping peer %d!\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peer %d!\n",
running_arr[running_permute[i]]);
#endif
GNUNET_assert (running_arr != NULL);
for (i = 0; i < von; i++)
{
#if DEBUG_CHURN
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Starting up peer %d!\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting up peer %d!\n",
stopped_arr[stopped_permute[i]]);
#endif
GNUNET_assert (stopped_arr != NULL);
for (i = 0; i < pg->total; i++)
{
#if DEBUG_START
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Starting up service %s on peer %d!\n", service,
- stopped_arr[stopped_permute[i]]);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting up service %s on peer %d!\n",
+ service, stopped_arr[stopped_permute[i]]);
#endif
peer_start_ctx = GNUNET_malloc (sizeof (struct PeerServiceStartContext));
peer_start_ctx->start_ctx = start_ctx;
struct PeerShutdownContext *peer_shutdown_ctx = cls;
struct ShutdownContext *shutdown_ctx = peer_shutdown_ctx->shutdown_ctx;
unsigned int off;
+ int i;
struct OutstandingSSH *ssh_pos;
shutdown_ctx->outstanding--;
else
shutdown_ctx->cb (shutdown_ctx->cb_cls, NULL);
+ for (i = 0; i < shutdown_ctx->pg->total; i++)
+ {
+ if (shutdown_ctx->pg->peers[i].startup_task != GNUNET_SCHEDULER_NO_TASK)
+ GNUNET_SCHEDULER_cancel (shutdown_ctx->pg->peers[i].startup_task);
+ }
GNUNET_free (shutdown_ctx->pg->peers);
GNUNET_free_non_null (shutdown_ctx->pg->hostkey_data);
for (off = 0; off < shutdown_ctx->pg->num_hosts; off++)
data[count] = '\0';
temphost = GNUNET_malloc (sizeof (struct GNUNET_TESTING_Host));
ret =
- sscanf (buf, "%a[a-zA-Z0-9_]@%a[a-zA-Z0-9.]:%hd",
+ SSCANF (buf, "%a[a-zA-Z0-9_]@%a[a-zA-Z0-9.]:%hd",
&temphost->username, &temphost->hostname, &temphost->port);
if (3 == ret)
{
pg->peers[off].cfg = NULL;
}
#if OLD
+// FIXME Do DLL remove for all pg->peers[off].LIST
conn_iter = pg->peers[off].allowed_peers_head;
while (conn_iter != NULL)
{
GNUNET_free (conn_iter);
conn_iter = temp_conn;
}
+ pg->peers[off].allowed_peers_head = NULL;
conn_iter = pg->peers[off].connect_peers_head;
while (conn_iter != NULL)
GNUNET_free (conn_iter);
conn_iter = temp_conn;
}
+ pg->peers[off].connect_peers_head = NULL;
conn_iter = pg->peers[off].blacklisted_peers_head;
while (conn_iter != NULL)
GNUNET_free (conn_iter);
conn_iter = temp_conn;
}
+ pg->peers[off].blacklisted_peers_head = NULL;
conn_iter = pg->peers[off].connect_peers_working_set_head;
while (conn_iter != NULL)
GNUNET_free (conn_iter);
conn_iter = temp_conn;
}
+ pg->peers[off].connect_peers_working_set_head = NULL;
#else
if (pg->peers[off].allowed_peers != NULL)
GNUNET_CONTAINER_multihashmap_destroy (pg->peers[off].allowed_peers);