GNUNET_CONFIGURATION_set_value_string (uc.ret, "statistics", "UNIXPATH",
"");
+ GNUNET_CONFIGURATION_set_value_string (uc.ret, "transport-tcp", "USE_LOCALADDR",
+ "YES");
+ GNUNET_CONFIGURATION_set_value_string (uc.ret, "transport-udp", "USE_LOCALADDR",
+ "YES");
GNUNET_free_non_null (control_host);
GNUNET_free (allowed_hosts);
}
hostname);
GNUNET_CONFIGURATION_set_value_string (uc.ret, "transport-tcp", "BINDTO",
hostname);
+ GNUNET_CONFIGURATION_set_value_string (uc.ret, "transport-tcp", "USE_LOCALADDR",
+ "YES");
+ GNUNET_CONFIGURATION_set_value_string (uc.ret, "transport-udp", "USE_LOCALADDR",
+ "YES");
GNUNET_CONFIGURATION_set_value_string (uc.ret, "arm", "ACCEPT_FROM",
allowed_hosts);
GNUNET_free (allowed_hosts);
"127.0.0.1");
GNUNET_CONFIGURATION_set_value_string (uc.ret, "transport-udp", "BINDTO",
"127.0.0.1");
+ GNUNET_CONFIGURATION_set_value_string (uc.ret, "transport-tcp", "USE_LOCALADDR",
+ "YES");
+ GNUNET_CONFIGURATION_set_value_string (uc.ret, "transport-udp", "USE_LOCALADDR",
+ "YES");
}
*port = (uint16_t) uc.nport;
copy_allowed(struct GNUNET_TESTING_PeerGroup *pg,
GNUNET_TESTING_ConnectionProcessor proc)
{
- struct UnblacklistContext un_ctx;
unsigned int count;
unsigned int total;
struct PeerConnection *iter;
+#if !OLD
+ struct UnblacklistContext un_ctx;
un_ctx.pg = pg;
+#endif
total = 0;
for (count = 0; count < pg->total - 1; count++)
{
- un_ctx.first_uid = count;
#if OLD
iter = pg->peers[count].allowed_peers_head;
while (iter != NULL)
iter = iter->next;
}
#else
- total += GNUNET_CONTAINER_multihashmap_iterate(pg->peers[count].allowed_peers, &unblacklist_iterator, &un_ctx);
+ un_ctx.first_uid = count;
+ total += GNUNET_CONTAINER_multihashmap_iterate(pg->peers[count].allowed_peers,
+ &unblacklist_iterator,
+ &un_ctx);
#endif
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Unblacklisted %u peers\n", total);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Unblacklisted %u peers\n",
+ total);
return total;
}
GNUNET_TESTING_ConnectionProcessor proc, enum PeerLists list)
{
unsigned int count;
- int connect_attempts;
+ unsigned int connect_attempts;
connect_attempts = 0;
-
/* Connect each peer to the next highest numbered peer */
for (count = 0; count < pg->total - 1; count++)
{
#if VERBOSE_TESTING
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Connecting peer %d to peer %d\n", count, count + 1);
+ "Connecting peer %d to peer %d\n",
+ count, count + 1);
#endif
connect_attempts += proc (pg, count, count + 1, list, GNUNET_YES);
}
int connect_attempts;
unsigned int first_peer_index;
unsigned int second_peer_index;
- connect_attempts = 0;
struct stat frstat;
int count;
char *data;
- char *buf;
+ const char *buf;
unsigned int total_peers;
-
enum States curr_state;
+ connect_attempts = 0;
if (GNUNET_OK != GNUNET_DISK_file_test (filename))
GNUNET_DISK_fn_write (filename, NULL, 0, GNUNET_DISK_PERM_USER_READ);
switch (curr_state)
{
- case NUM_PEERS:
- errno = 0;
- total_peers = strtoul(&buf[count], NULL, 10);
- if (errno != 0)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Failed to read number of peers from topology file!\n");
- GNUNET_free_non_null(data);
- return connect_attempts;
- }
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Read %u total peers in topology\n", total_peers);
- GNUNET_assert(total_peers == pg->total);
- curr_state = PEER_INDEX;
- while ((buf[count] != '\n') && (count < frstat.st_size - 1))
- count++;
- count++;
- break;
- case PEER_INDEX:
- errno = 0;
- first_peer_index = strtoul(&buf[count], NULL, 10);
- if (errno != 0)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Failed to read peer index from topology file!\n");
- GNUNET_free_non_null(data);
- return connect_attempts;
- }
- while ((buf[count] != ':') && (count < frstat.st_size - 1))
- count++;
- count++;
- curr_state = OTHER_PEER_INDEX;
- break;
- case COLON:
- if (1 == sscanf (&buf[count], ":"))
- curr_state = OTHER_PEER_INDEX;
- count++;
- break;
- case OTHER_PEER_INDEX:
- errno = 0;
- second_peer_index = strtoul(&buf[count], NULL, 10);
- if (errno != 0)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Failed to peer index from topology file!\n");
- GNUNET_free_non_null(data);
- return connect_attempts;
- }
- /* Assume file is written with first peer 1, but array index is 0 */
- connect_attempts += proc (pg, first_peer_index - 1, second_peer_index
- - 1, list, GNUNET_YES);
- while ((buf[count] != '\n') && (buf[count] != ',') && (count
- < frstat.st_size - 1))
- count++;
- if (buf[count] == '\n')
- {
- curr_state = PEER_INDEX;
- }
- else if (buf[count] != ',')
- {
- curr_state = OTHER_PEER_INDEX;
- }
- count++;
- break;
- default:
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Found bad data in topology file while in state %d!\n",
- curr_state);
- GNUNET_break(0);
- return connect_attempts;
+ case NUM_PEERS:
+ errno = 0;
+ total_peers = strtoul(&buf[count], NULL, 10);
+ if (errno != 0)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Failed to read number of peers from topology file!\n");
+ GNUNET_free (data);
+ return connect_attempts;
+ }
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Read %u total peers in topology\n", total_peers);
+ GNUNET_assert(total_peers == pg->total);
+ curr_state = PEER_INDEX;
+ while ((buf[count] != '\n') && (count < frstat.st_size - 1))
+ count++;
+ count++;
+ break;
+ case PEER_INDEX:
+ errno = 0;
+ first_peer_index = strtoul(&buf[count], NULL, 10);
+ if (errno != 0)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Failed to read peer index from topology file!\n");
+ GNUNET_free (data);
+ return connect_attempts;
+ }
+ while ((buf[count] != ':') && (count < frstat.st_size - 1))
+ count++;
+ count++;
+ curr_state = OTHER_PEER_INDEX;
+ break;
+ case COLON:
+ if (1 == sscanf (&buf[count], ":"))
+ curr_state = OTHER_PEER_INDEX;
+ count++;
+ break;
+ case OTHER_PEER_INDEX:
+ errno = 0;
+ second_peer_index = strtoul(&buf[count], NULL, 10);
+ if (errno != 0)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Failed to peer index from topology file!\n");
+ GNUNET_free (data);
+ return connect_attempts;
+ }
+ /* Assume file is written with first peer 1, but array index is 0 */
+ connect_attempts += proc (pg, first_peer_index - 1, second_peer_index
+ - 1, list, GNUNET_YES);
+ while ((buf[count] != '\n') && (buf[count] != ',') && (count
+ < frstat.st_size - 1))
+ count++;
+ if (buf[count] == '\n')
+ {
+ curr_state = PEER_INDEX;
+ }
+ else if (buf[count] != ',')
+ {
+ curr_state = OTHER_PEER_INDEX;
+ }
+ count++;
+ break;
+ default:
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Found bad data in topology file while in state %d!\n",
+ curr_state);
+ GNUNET_break(0);
+ GNUNET_free (data);
+ return connect_attempts;
}
-
}
+ GNUNET_free (data);
return connect_attempts;
}
while (conn != NULL)
{
GNUNET_CORE_peer_request_connect(send_hello_context->peer->daemon->server,
- GNUNET_TIME_relative_get_forever(),
&send_hello_context->pg->peers[conn->index].daemon->id,
NULL,
NULL);
{
struct SendHelloContext *send_hello_context = cls;
//unsigned int pg_iter;
- if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
+ if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
{
GNUNET_free(send_hello_context);
return;
struct SendHelloContext *send_hello_context = cls;
struct GNUNET_TESTING_PeerGroup *pg = send_hello_context->pg;
- if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
+ if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
{
GNUNET_free(send_hello_context);
return;
struct ConnectTopologyContext *ct_ctx = connect_ctx->ct_ctx;
struct GNUNET_TESTING_PeerGroup *pg = ct_ctx->pg;
struct PeerConnection *connection;
+
+ GNUNET_assert (0 < pg->outstanding_connects);
pg->outstanding_connects--;
/*
if (connection != NULL) /* Can safely remove! */
{
+ GNUNET_assert (0 < ct_ctx->remaining_connections);
ct_ctx->remaining_connections--;
if (pg->notify_connection != NULL) /* Notify of reverse connection */
pg->notify_connection (pg->notify_connection_cls, second, first,
if (ct_ctx->remaining_connections == 0)
{
if (ct_ctx->notify_connections_done != NULL)
- ct_ctx->notify_connections_done (ct_ctx->notify_cls, NULL);
+ {
+ ct_ctx->notify_connections_done (ct_ctx->notify_cls, NULL);
+ ct_ctx->notify_connections_done = NULL;
+ }
}
else
preschedule_connect (pg);
struct ConnectContext *connect_context = cls;
struct GNUNET_TESTING_PeerGroup *pg = connect_context->ct_ctx->pg;
- if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
+ if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
return;
if ((pg->outstanding_connects > pg->max_outstanding_connections)
choose_random_connections(struct GNUNET_TESTING_PeerGroup *pg,
double percentage)
{
- struct RandomContext random_ctx;
uint32_t pg_iter;
#if OLD
- struct PeerConnection *temp_peers;
struct PeerConnection *conn_iter;
double random_number;
+#else
+ struct RandomContext random_ctx;
#endif
for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
{
- random_ctx.first_uid = pg_iter;
- random_ctx.first = &pg->peers[pg_iter];
- random_ctx.percentage = percentage;
- random_ctx.pg = pg;
#if OLD
- temp_peers = NULL;
conn_iter = pg->peers[pg_iter].connect_peers_head;
while (conn_iter != NULL)
{
conn_iter = conn_iter->next;
}
#else
- pg->peers[pg_iter].connect_peers_working_set =
- GNUNET_CONTAINER_multihashmap_create (pg->total);
+ random_ctx.first_uid = pg_iter;
+ random_ctx.first = &pg->peers[pg_iter];
+ random_ctx.percentage = percentage;
+ random_ctx.pg = pg;
+ pg->peers[pg_iter].connect_peers_working_set
+ = GNUNET_CONTAINER_multihashmap_create (pg->total);
GNUNET_CONTAINER_multihashmap_iterate (pg->peers[pg_iter].connect_peers,
- &random_connect_iterator,
- &random_ctx);
+ &random_connect_iterator,
+ &random_ctx);
/* Now remove the old connections */
GNUNET_CONTAINER_multihashmap_destroy (pg->
- peers[pg_iter].connect_peers);
+ peers[pg_iter].connect_peers);
/* And replace with the random set */
- pg->peers[pg_iter].connect_peers =
- pg->peers[pg_iter].connect_peers_working_set;
+ pg->peers[pg_iter].connect_peers
+ = pg->peers[pg_iter].connect_peers_working_set;
#endif
}
struct CoreContext *core_context = cls;
struct TopologyIterateContext *topology_context =
(struct TopologyIterateContext *) core_context->iter_context;
- if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
+ if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
return;
if (topology_context->connected
struct StatsIterateContext *stats_context =
(struct StatsIterateContext *) core_context->iter_context;
- if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
+ if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
return;
if (stats_context->connected > stats_context->pg->max_outstanding_connections)
{
struct InternalStartContext *internal_context = cls;
- if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
+ if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
{
return;
}
{
struct InternalStartContext *internal_context = cls;
- if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
+ if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
{
return;
}
uint64_t total_hostkeys;
struct GNUNET_OS_Process *proc;
+ username = NULL;
if (0 == total)
{
GNUNET_break (0);
&hostkeys_file))
{
if (GNUNET_YES != GNUNET_DISK_file_test (hostkeys_file))
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Couldn't read hostkeys file!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Could not read hostkeys file!\n"));
else
{
/* Check hostkey file size, read entire thing into memory */
- fd = GNUNET_DISK_file_open (hostkeys_file, GNUNET_DISK_OPEN_READ,
+ fd = GNUNET_DISK_file_open (hostkeys_file,
+ GNUNET_DISK_OPEN_READ,
GNUNET_DISK_PERM_NONE);
if (NULL == fd)
{
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", hostkeys_file);
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
+ "open",
+ hostkeys_file);
+ GNUNET_free (hostkeys_file);
+ for (i=0;i<pg->num_hosts;i++)
+ {
+ GNUNET_free (pg->hosts[i].hostname);
+ GNUNET_free_non_null (pg->hosts[i].username);
+ }
+ GNUNET_free (pg->peers);
+ GNUNET_free (pg->hosts);
+ GNUNET_free (pg);
return NULL;
}
GNUNET_YES))
fs = 0;
- GNUNET_log (
- GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Found file size %llu for hostkeys, expect hostkeys to be size %d\n",
fs, HOSTKEYFILESIZE);
- if (fs % HOSTKEYFILESIZE != 0)
+ if (0 != (fs % HOSTKEYFILESIZE))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"File size %llu seems incorrect for hostkeys...\n",
{
total_hostkeys = fs / HOSTKEYFILESIZE;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Will read %llu hostkeys from file\n", total_hostkeys);
+ "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));
- GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fd));
}
+ GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fd));
}
GNUNET_free(hostkeys_file);
}
{
if (position < pg->total)
return pg->peers[position].daemon;
- else
- return NULL;
+ return NULL;
}
/*
sizeof(struct GNUNET_PeerIdentity)))
return pg->peers[i].daemon;
}
-
return NULL;
}
* @param d handle to the daemon that was restarted
* @param emsg NULL on success
*/
-void
+static void
restart_callback(void *cls, const struct GNUNET_PeerIdentity *id,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Daemon *d, const char *emsg)
* @param emsg NULL on success, non-NULL on failure
*
*/
-void
+static void
churn_stop_callback(void *cls, const char *emsg)
{
struct ShutdownContext *shutdown_ctx = cls;
}
}
+
/**
* Simulate churn by stopping some peers (and possibly
* re-starting others if churn is called multiple times). This
GNUNET_free_non_null (stopped_permute);
}
+
/**
* Restart all peers in the given group.
*
}
}
+
/**
* Start or stop an individual peer from the given group.
*
GNUNET_break (0);
}
+
/**
* Callback for shutting down peers in a peer group.
*
* @param cls closure (struct ShutdownContext)
* @param emsg NULL on success
*/
-void
+static void
internal_shutdown_callback(void *cls, const char *emsg)
{
struct PeerShutdownContext *peer_shutdown_ctx = cls;
GNUNET_free(peer_shutdown_ctx);
}
+
/**
* Task to rate limit the number of outstanding peer shutdown
* requests. This is necessary for making sure we don't do
}
+
/**
* Shutdown all peers started in the given group.
*
}
#else
if (pg->peers[off].allowed_peers != NULL)
- GNUNET_CONTAINER_multihashmap_destroy (pg->peers[off].allowed_peers);
+ GNUNET_CONTAINER_multihashmap_destroy (pg->peers[off].allowed_peers);
if (pg->peers[off].connect_peers != NULL)
- GNUNET_CONTAINER_multihashmap_destroy (pg->peers[off].connect_peers);
+ GNUNET_CONTAINER_multihashmap_destroy (pg->peers[off].connect_peers);
if (pg->peers[off].blacklisted_peers != NULL)
- GNUNET_CONTAINER_multihashmap_destroy (pg->
- peers[off].blacklisted_peers);
+ GNUNET_CONTAINER_multihashmap_destroy (pg->
+ peers[off].blacklisted_peers);
#endif
}
}
projects / oweals / gnunet.git / blobdiff