static void clear_stale_peers(void * x) {
PeerServer ** sp = &peers;
PeerServer * s;
time_t timenow = time(NULL);
int keep_timer = 0;
assert(is_dispatch_thread());
while ((s = *sp) != NULL) {
if (s->expiration_time <= timenow) {
/* Delete stale entry */
*sp = s->next;
notify_listeners(s, PS_EVENT_REMOVED);
s->listed = 0;
peer_server_free(s);
}
else {
keep_timer = 1;
sp = &s->next;
}
}
if (keep_timer) {
post_event_with_delay(clear_stale_peers, NULL, PEER_DATA_REFRESH_PERIOD * 1000000);
}
else {
stale_timer_active = 0;
}
}
void roadmap_skin_set_subskin (const char *sub_skin) {
const char *base_path = roadmap_path_preferred ("skin");
char path[1024];
char *skin_path = NULL;
char *subskin_path;
const char *cursor;
char *subskin_path2 = NULL;
CurrentSubSkin = sub_skin;
skin_path = roadmap_path_join (base_path, CurrentSkin);
subskin_path = roadmap_path_join (skin_path, CurrentSubSkin);
// offset = strlen(path);
if (!strcmp(CurrentSubSkin,"day")){
if (strlen(get_map_schema())> 0) {
subskin_path2 = roadmap_path_join (subskin_path, get_map_schema());
snprintf (path, sizeof(path), "%s", subskin_path2);
roadmap_path_free (subskin_path2);
}
else {
snprintf (path, sizeof(path), "%s", subskin_path);
}
}
else{
snprintf (path, sizeof(path), "%s", subskin_path);
}
for ( cursor = roadmap_path_first ("skin");
cursor != NULL;
cursor = roadmap_path_next ("skin", cursor))
{
if ( !((strstr(cursor,"day") || strstr(cursor,"night")))){
strcat(path, ",");
strcat(path, cursor);
}
}
roadmap_path_set ("skin", path);
roadmap_path_free (subskin_path);
roadmap_path_free (skin_path);
roadmap_config_reload ("schema");
notify_listeners ();
roadmap_screen_redraw ();
}
PeerServer * peer_server_add(PeerServer * n, unsigned int stale_delta) {
PeerServer ** sp = &peers;
PeerServer * s;
int type = PS_EVENT_ADDED;
assert(!n->listed);
assert(is_dispatch_thread());
while ((s = *sp) != NULL) {
if (strcmp(s->id, n->id) == 0) {
if (((s->flags & PS_FLAG_LOCAL) && !(n->flags & PS_FLAG_LOCAL)) || is_same(s, n)) {
/* Never replace local entries with discovered ones */
s->expiration_time = time(NULL) + stale_delta;
if (!(s->flags & PS_FLAG_LOCAL)) s->flags = n->flags;
peer_server_free(n);
notify_listeners(s, PS_EVENT_HEART_BEAT);
return s;
}
*sp = s->next;
s->listed = 0;
peer_server_free(s);
type = PS_EVENT_CHANGED;
break;
}
sp = &s->next;
}
n->listed = 1;
n->creation_time = time(NULL);
n->expiration_time = n->creation_time + stale_delta;
n->next = peers;
peers = n;
notify_listeners(n, type);
if (!stale_timer_active) {
stale_timer_active = 1;
post_event_with_delay(clear_stale_peers, NULL, PEER_DATA_REFRESH_PERIOD * 1000000);
}
return n;
}
void peer_server_remove(const char *id) {
PeerServer ** sp = &peers;
PeerServer * s;
assert(is_dispatch_thread());
while ((s = *sp) != NULL) {
if (strcmp(s->id, id) == 0) {
*sp = s->next;
notify_listeners(s, PS_EVENT_REMOVED);
s->listed = 0;
peer_server_free(s);
break;
}
sp = &s->next;
}
}
/**
* Handler for DELETE message from client, creates
* new identity.
*
* @param cls unused
* @param client who sent the message
* @param message the message received
*/
static void
handle_delete_message (void *cls,
const struct DeleteMessage *dm)
{
struct Ego *ego;
const char *name;
char *fn;
struct GNUNET_SERVICE_Client *client = cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received DELETE message from client\n");
name = (const char *) &dm[1];
for (ego = ego_head; NULL != ego; ego = ego->next)
{
if (0 == strcmp (ego->identifier,
name))
{
GNUNET_CONTAINER_DLL_remove (ego_head,
ego_tail,
ego);
GNUNET_CONFIGURATION_iterate_sections (subsystem_cfg,
&handle_ego_delete,
ego->identifier);
if (GNUNET_OK !=
GNUNET_CONFIGURATION_write (subsystem_cfg,
subsystem_cfg_file))
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to write subsystem default identifier map to `%s'.\n"),
subsystem_cfg_file);
fn = get_ego_filename (ego);
if (0 != UNLINK (fn))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
GNUNET_free (fn);
GNUNET_free (ego->identifier);
ego->identifier = NULL;
notify_listeners (ego);
GNUNET_free (ego->pk);
GNUNET_free (ego);
send_result_code (client, 0, NULL);
GNUNET_SERVICE_client_continue (client);
return;
}
}
send_result_code (client, 1, gettext_noop ("no matching ego found"));
GNUNET_SERVICE_client_continue (client);
}
static gboolean
spi_application_toolkit_event_listener (GSignalInvocationHint *signal_hint,
guint n_param_values,
const GValue *param_values,
gpointer data)
{
Accessibility_Event e;
AtkObject *aobject;
SpiAccessible *source;
GSignalQuery signal_query;
char *event_name;
g_return_val_if_fail (the_app != NULL, FALSE);
g_signal_query (signal_hint->signal_id, &signal_query);
/* TODO: move GTK reference out of app.c into bridge */
event_name = g_strdup_printf ("Gtk:%s:%s",
g_type_name (signal_query.itype),
signal_query.signal_name);
#ifdef SPI_DEBUG
fprintf (stderr, "Received signal %s\n", event_name);
#endif
aobject = get_atk_object_ref (g_value_get_object (param_values + 0));
source = spi_accessible_new (aobject);
e.type = CORBA_string_dup (event_name);
e.source = CORBA_OBJECT_NIL;
e.detail1 = 0;
e.detail2 = 0;
spi_init_any_nil (&e.any_data,
spi_accessible_new_return (atk_get_root (), FALSE, NULL),
Accessibility_ROLE_UNKNOWN,
"");
notify_listeners (the_app->toolkit_listeners, source, &e);
bonobo_object_unref (BONOBO_OBJECT (source));
g_object_unref (G_OBJECT (aobject));
g_free (event_name);
return TRUE;
}
/**
* Handler for CREATE message from client, creates
* new identity.
*
* @param cls unused
* @param client who sent the message
* @param message the message received
*/
static void
handle_create_message (void *cls,
const struct CreateRequestMessage *crm)
{
struct GNUNET_SERVICE_Client *client = cls;
struct Ego *ego;
const char *str;
char *fn;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received CREATE message from client\n");
str = (const char *) &crm[1];
for (ego = ego_head; NULL != ego; ego = ego->next)
{
if (0 == strcmp (ego->identifier,
str))
{
send_result_code (client, 1, gettext_noop ("identifier already in use for another ego"));
GNUNET_SERVICE_client_continue (client);
return;
}
}
ego = GNUNET_new (struct Ego);
ego->pk = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPrivateKey);
*ego->pk = crm->private_key;
ego->identifier = GNUNET_strdup (str);
GNUNET_CONTAINER_DLL_insert (ego_head,
ego_tail,
ego);
send_result_code (client, 0, NULL);
fn = get_ego_filename (ego);
(void) GNUNET_DISK_directory_create_for_file (fn);
if (sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey) !=
GNUNET_DISK_fn_write (fn,
&crm->private_key,
sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey),
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
"write", fn);
GNUNET_free (fn);
notify_listeners (ego);
GNUNET_SERVICE_client_continue (client);
}
void roadmap_skin_set_subskin (const char *sub_skin) {
const char *base_path = roadmap_path_preferred ("skin");
char path[255];
char *skin_path;
char *subskin_path;
CurrentSubSkin = sub_skin;
skin_path = roadmap_path_join (base_path, CurrentSkin);
subskin_path = roadmap_path_join (skin_path, CurrentSubSkin);
snprintf (path, sizeof(path), "%s,%s", subskin_path, skin_path);
roadmap_path_set ("skin", path);
roadmap_path_free (subskin_path);
roadmap_path_free (skin_path);
roadmap_config_reload ("schema");
notify_listeners ();
roadmap_screen_redraw ();
}
/**
* Handler for DELETE message from client, creates
* new identity.
*
* @param cls unused
* @param client who sent the message
* @param message the message received
*/
static void
handle_delete_message (void *cls, struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
const struct GNUNET_IDENTITY_DeleteMessage *dm;
uint16_t size;
uint16_t name_len;
struct Ego *ego;
const char *name;
char *fn;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received DELETE message from client\n");
size = ntohs (message->size);
if (size <= sizeof (struct GNUNET_IDENTITY_DeleteMessage))
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
dm = (const struct GNUNET_IDENTITY_DeleteMessage *) message;
name = (const char *) &dm[1];
name_len = ntohs (dm->name_len);
if ( (name_len + sizeof (struct GNUNET_IDENTITY_DeleteMessage) != size) ||
(0 != ntohs (dm->reserved)) ||
('\0' != name[name_len - 1]) )
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
for (ego = ego_head; NULL != ego; ego = ego->next)
{
if (0 == strcmp (ego->identifier,
name))
{
GNUNET_CONTAINER_DLL_remove (ego_head,
ego_tail,
ego);
GNUNET_CONFIGURATION_iterate_sections (subsystem_cfg,
&handle_ego_delete,
ego->identifier);
if (GNUNET_OK !=
GNUNET_CONFIGURATION_write (subsystem_cfg,
subsystem_cfg_file))
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to write subsystem default identifier map to `%s'.\n"),
subsystem_cfg_file);
fn = get_ego_filename (ego);
if (0 != UNLINK (fn))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
GNUNET_free (fn);
GNUNET_free (ego->identifier);
ego->identifier = NULL;
notify_listeners (ego);
GNUNET_free (ego->pk);
GNUNET_free (ego);
send_result_code (client, 0, NULL);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
}
send_result_code (client, 1, gettext_noop ("no matching ego found"));
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
/**
* Handler for RENAME message from client, creates
* new identity.
*
* @param cls unused
* @param client who sent the message
* @param message the message received
*/
static void
handle_rename_message (void *cls, struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
const struct GNUNET_IDENTITY_RenameMessage *rm;
uint16_t size;
uint16_t old_name_len;
uint16_t new_name_len;
struct Ego *ego;
const char *old_name;
const char *new_name;
struct RenameContext rename_ctx;
char *fn_old;
char *fn_new;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received RENAME message from client\n");
size = ntohs (message->size);
if (size <= sizeof (struct GNUNET_IDENTITY_RenameMessage))
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
rm = (const struct GNUNET_IDENTITY_RenameMessage *) message;
old_name_len = ntohs (rm->old_name_len);
new_name_len = ntohs (rm->new_name_len);
old_name = (const char *) &rm[1];
new_name = &old_name[old_name_len];
if ( (old_name_len + new_name_len + sizeof (struct GNUNET_IDENTITY_RenameMessage) != size) ||
('\0' != old_name[old_name_len - 1]) ||
('\0' != new_name[new_name_len - 1]) )
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
/* check if new name is already in use */
for (ego = ego_head; NULL != ego; ego = ego->next)
{
if (0 == strcmp (ego->identifier,
new_name))
{
send_result_code (client, 1, gettext_noop ("target name already exists"));
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
}
/* locate old name and, if found, perform rename */
for (ego = ego_head; NULL != ego; ego = ego->next)
{
if (0 == strcmp (ego->identifier,
old_name))
{
fn_old = get_ego_filename (ego);
GNUNET_free (ego->identifier);
rename_ctx.old_name = old_name;
rename_ctx.new_name = new_name;
GNUNET_CONFIGURATION_iterate_sections (subsystem_cfg,
&handle_ego_rename,
&rename_ctx);
if (GNUNET_OK !=
GNUNET_CONFIGURATION_write (subsystem_cfg,
subsystem_cfg_file))
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to write subsystem default identifier map to `%s'.\n"),
subsystem_cfg_file);
ego->identifier = GNUNET_strdup (new_name);
fn_new = get_ego_filename (ego);
if (0 != RENAME (fn_old, fn_new))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "rename", fn_old);
GNUNET_free (fn_old);
GNUNET_free (fn_new);
notify_listeners (ego);
send_result_code (client, 0, NULL);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
}
/* failed to locate old name */
send_result_code (client, 1, gettext_noop ("no matching ego found"));
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
/**
* Handler for CREATE message from client, creates
* new identity.
*
* @param cls unused
* @param client who sent the message
* @param message the message received
*/
static void
handle_create_message (void *cls, struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
const struct GNUNET_IDENTITY_CreateRequestMessage *crm;
uint16_t size;
uint16_t name_len;
struct Ego *ego;
const char *str;
char *fn;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received CREATE message from client\n");
size = ntohs (message->size);
if (size <= sizeof (struct GNUNET_IDENTITY_CreateRequestMessage))
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
crm = (const struct GNUNET_IDENTITY_CreateRequestMessage *) message;
name_len = ntohs (crm->name_len);
GNUNET_break (0 == ntohs (crm->reserved));
if (name_len + sizeof (struct GNUNET_IDENTITY_CreateRequestMessage) != size)
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
str = (const char *) &crm[1];
if ('\0' != str[name_len - 1])
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
for (ego = ego_head; NULL != ego; ego = ego->next)
{
if (0 == strcmp (ego->identifier,
str))
{
send_result_code (client, 1, gettext_noop ("identifier already in use for another ego"));
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
}
ego = GNUNET_new (struct Ego);
ego->pk = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPrivateKey);
*ego->pk = crm->private_key;
ego->identifier = GNUNET_strdup (str);
GNUNET_CONTAINER_DLL_insert (ego_head,
ego_tail,
ego);
send_result_code (client, 0, NULL);
fn = get_ego_filename (ego);
(void) GNUNET_DISK_directory_create_for_file (fn);
if (sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey) !=
GNUNET_DISK_fn_write (fn,
&crm->private_key,
sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey),
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
"write", fn);
GNUNET_free (fn);
notify_listeners (ego);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
void *target_handler(void *arg)
{
struct timeval tv;
fd_set readset;
int i, fd, ret, nfds;
char cmd;
unsigned char target_status;
debug("Target handler thread started!\n");
while(1)
{
// Set this each loop, it may be changed by the select() call
tv.tv_sec = 0;
tv.tv_usec = 250000; // 1/4 second timeout when polling
FD_ZERO(&readset);
nfds = 0;
pthread_mutex_lock(&pipes_mutex);
for(i = 0; i < num_monitor_connections; i++)
{
fd = connections[i].server_to_monitor_fds[0];
FD_SET(fd, &readset);
if(fd > nfds)
nfds = fd;
}
pthread_mutex_unlock(&pipes_mutex);
nfds++;
// We do not hold the pipes_mutex during the select(), so it is possible that some of
// the pipes in the readset will go away while we block. This is fine, as we re-take
// the lock below and iterate through the (changed) connections[] array, which will
// ignore any pipes which have closed, even if they are in the readset.
ret = select(nfds, &readset, NULL, NULL, &tv);
if(ret == -1) // error
{
// We may get an EBADF if a server un-registers its pipes while we're in the select()
// (very likely). So, ignore EBADF unless there's a problem that needs debugged.
if(errno != EBADF)
perror("select()");
else
{
debug("Monitor thread got EBADF in select(). Server unregistration, or real problem?");
}
}
else if(ret != 0) // fd ready (ret == 0 on timeout)
{
debug("Monitor thread got data\n");
pthread_mutex_lock(&pipes_mutex);
for(i = 0; i < num_monitor_connections; i++)
{
debug("Monitor checking incoming connection %i\n", i);
fd = connections[i].server_to_monitor_fds[0];
if(FD_ISSET(fd, &readset))
{
ret = read(fd, &cmd, 1);
debug("Target monitor thread got command \'%c\' (0x%X)\n", cmd, cmd);
if(ret == 1)
{
if(cmd == 'S')
{
if(target_is_running) stall_cpu(1);
notify_listeners("H", 1);
}
else if(cmd == 'U')
{
if(!target_is_running) stall_cpu(0);
notify_listeners("R", 1);
}
else
{
fprintf(stderr, "Target monitor thread got unknown command \'%c\' (0x%X)\n", cmd, cmd);
}
}
else
{
fprintf(stderr, "Monitor thread failed to read from ready descriptor!\n");
}
} // if FD_ISSET()
} // for i = 0 to num_monitor_connections
pthread_mutex_unlock(&pipes_mutex);
// We got a command. Either the target is now stalled and we don't need to poll,
// or the target just started and we should wait a bit before polling.
continue;
} // else if (ret != 0)
if(target_is_running)
{
debug("Monitor polling hardware!\n");
// Poll target hardware
ret = dbg_cpu0_read_ctrl(0, &target_status);
if(ret != APP_ERR_NONE)
fprintf(stderr, "ERROR 0x%X while polling target CPU status\n", ret);
else {
if(target_status & 0x01) // Did we get the stall bit? Bit 0 is STALL bit.
{
debug("Monitor poll found CPU stalled!\n");
target_is_running = 0;
pthread_mutex_lock(&pipes_mutex);
notify_listeners("H", 1);
pthread_mutex_unlock(&pipes_mutex);
}
}
} // if(target_is_running)
} // while(1), main loop
fprintf(stderr, "Target monitor thread exiting!!");
return arg;
}
