void server_dump(dbase_server *root, int level)
{
int i;
if ((!root) && (!level)) root = servers;
if (root)
{
for (i = 0; i < level; i++) debug_out("| ");
debug_out("%s (%s) - %s\n", root->name, root->numeric, root->desc);
for (i = 0; i < root->children_count; i++)
server_dump(root->children[i], level+1);
}
}
/* dump servers */
static void m_dump_server(char *arg)
{
struct server *sptr = NULL;
if(arg)
{
if(chars_isdigit(*arg))
sptr = server_find_id(atoi(arg));
else
sptr = server_find_name(arg);
}
server_dump(sptr);
}
void dump_internal_state(void)
{
int dump_fd ;
const char *dump_file = DUMP_FILE ;
time_t current_time ;
int fd ;
unsigned u ;
const char *func = "dump_internal_state" ;
if ( debug.on )
msg( LOG_DEBUG, func, "Dumping State" ) ;
dump_fd = open( dump_file, O_WRONLY | O_CREAT | O_APPEND, DUMP_FILE_MODE);
if ( dump_fd == -1 )
{
msg( LOG_ERR, func, "failed to open %s: %m", dump_file ) ;
return ;
}
if (Sbuftype( dump_fd, SIO_LINEBUF ) == SIO_ERR )
{
/*
* If the above function failed, Sprint will most likely
* fail, too. Output a message for troubleshooting and quit.
*/
msg( LOG_ERR, func, "failed setting up sio buffering: %m" ) ;
return;
}
/*
* Print the program name, version, and timestamp.
* Note that the program_version variable contains the program name.
*/
(void) time( ¤t_time ) ;
Sprint( dump_fd, "INTERNAL STATE DUMP: %s\n", program_version ) ;
Sprint( dump_fd, "Current time: %s\n", ctime( ¤t_time ) ) ;
dump_services( dump_fd ) ;
/*
* Dump the server table
*/
Sprint( dump_fd, "Server table dump:\n" ) ;
for ( u = 0 ; u < pset_count( SERVERS( ps ) ) ; u++ )
server_dump( SERP( pset_pointer( SERVERS( ps ), u ) ), dump_fd ) ;
Sputchar( dump_fd, '\n' ) ;
/*
* Dump the retry_table
*/
Sprint( dump_fd, "Retry table dump:\n" ) ;
for ( u = 0 ; u < pset_count( RETRIES( ps ) ) ; u++ )
server_dump( SERP( pset_pointer( RETRIES( ps ), u ) ), dump_fd ) ;
Sputchar( dump_fd, '\n' ) ;
/*
* Dump the socket mask
*/
Sprint( dump_fd, "Socket mask:" ) ;
for ( fd = 0 ; fd < ps.ros.max_descriptors ; fd++ )
if ( FD_ISSET( fd, &ps.rws.socket_mask ) )
Sprint( dump_fd, " %d", fd ) ;
Sputchar( dump_fd, '\n' ) ;
Sprint( dump_fd, "mask_max = %d\n", ps.rws.mask_max ) ;
/*
* Dump the descriptors that are open and are *not* in the socket mask
*/
Sprint( dump_fd, "Open descriptors (not in socket mask):" ) ;
for ( fd = 0 ; fd < ps.ros.max_descriptors ; fd++ )
{
struct stat st ;
if ( FD_ISSET( fd, &ps.rws.socket_mask ) )
continue ;
if ( fstat( fd, &st ) == -1 )
continue ;
Sprint( dump_fd, " %d", fd ) ;
}
Sputchar( dump_fd, '\n' ) ;
Sputchar( dump_fd, '\n' ) ;
Sprint( dump_fd, "active_services = %d\n", ps.rws.active_services ) ;
Sprint( dump_fd, "available_services = %d\n", ps.rws.available_services ) ;
Sprint( dump_fd, "descriptors_free = %d\n", ps.rws.descriptors_free ) ;
Sprint( dump_fd, "running_servers = %d\n", pset_count( SERVERS( ps ) ) ) ;
Sprint( dump_fd, "Logging service = %s\n",
LOG_SERVICE( ps ) != NULL ? "enabled" : "not enabled" ) ;
Sputchar( dump_fd, '\n' ) ;
Sprint( dump_fd, "max_descriptors = %d\n", (int)ps.ros.max_descriptors ) ;
Sprint( dump_fd, "process_limit = %d\n", (int)ps.ros.process_limit ) ;
Sprint( dump_fd, "config_file = %s\n", ps.ros.config_file ) ;
if ( debug.on )
Sprint( dump_fd, "debug_fd = %d\n", debug.fd ) ;
Sputchar( dump_fd, '\n' ) ;
Sprint( dump_fd, "END OF DUMP\n\n" ) ;
Sclose( dump_fd );
msg( LOG_INFO, func, "generated state dump in file %s", dump_file ) ;
}
static int signal_hello(LassiConnection *lc, DBusMessage *m) {
const char *id, *address;
DBusError e;
GList *i;
dbus_bool_t b;
DBusMessage *n;
gint32 active_generation, order_generation, clipboard_generation;
dbus_error_init(&e);
if (lc->id) {
g_debug("Received duplicate HelloNode.");
return -1;
}
if (!(dbus_message_get_args(
m, &e,
DBUS_TYPE_STRING, &id,
DBUS_TYPE_STRING, &address,
DBUS_TYPE_INT32, &active_generation,
DBUS_TYPE_INT32, &order_generation,
DBUS_TYPE_INT32, &clipboard_generation,
DBUS_TYPE_INVALID))) {
g_warning("Received invalid message: %s", e.message);
dbus_error_free(&e);
return -1;
}
if (strcmp(id, lc->server->id) == 0) {
g_debug("Dropping looped back connection.");
return -1;
}
if (g_hash_table_lookup(lc->server->connections_by_id, id)) {
g_debug("Dropping duplicate connection.");
return -1;
}
lc->server->active_generation = MAX(lc->server->active_generation, active_generation);
lc->server->order_generation = MAX(lc->server->order_generation, order_generation);
lc->server->clipboard_generation = MAX(lc->server->clipboard_generation, clipboard_generation);
g_debug("Got welcome from %s (%s)", id, address);
lc->id = g_strdup(id);
lc->address = g_strdup(address);
g_hash_table_insert(lc->server->connections_by_id, lc->id, lc);
server_position_connection(lc->server, lc);
/* Notify all old nodes of the new one */
n = dbus_message_new_signal("/", LASSI_INTERFACE, "NodeAdded");
g_assert(n);
b = dbus_message_append_args(n, DBUS_TYPE_STRING, &id, DBUS_TYPE_STRING, &address, DBUS_TYPE_INVALID);
g_assert(b);
server_broadcast(lc->server, n, lc);
dbus_message_unref(n);
/* Notify new node about old nodes */
for (i = lc->server->connections; i; i = i->next) {
LassiConnection *k = i->data;
if (k == lc || !k->id)
continue;
n = dbus_message_new_signal("/", LASSI_INTERFACE, "NodeAdded");
g_assert(n);
b = dbus_message_append_args(n, DBUS_TYPE_STRING, &id, DBUS_TYPE_STRING, &address, DBUS_TYPE_INVALID);
g_assert(b);
b = dbus_connection_send(lc->dbus_connection, n, NULL);
g_assert(b);
dbus_message_unref(n);
}
if (lc->we_are_client) {
server_send_update_grab(lc->server, -1);
lassi_server_send_update_order(lc->server, NULL);
lc->delayed_welcome = FALSE;
show_welcome(lc, TRUE);
} else
lc->delayed_welcome = TRUE;
server_layout_changed(lc->server, -1);
lassi_prefs_update(&lc->server->prefs_info);
server_dump(lc->server);
return 0;
}
static void connection_unlink(LassiConnection *lc, gboolean remove_from_order) {
LassiServer *ls;
g_assert(lc);
g_debug("Unlinking %s (%s)", lc->id, lc->address);
ls = lc->server;
if (lc->id) {
DBusMessage *n;
dbus_bool_t b;
/* Tell everyone */
n = dbus_message_new_signal("/", LASSI_INTERFACE, "NodeRemoved");
g_assert(n);
b = dbus_message_append_args(n,
DBUS_TYPE_STRING, &lc->id,
DBUS_TYPE_STRING, &lc->address,
DBUS_TYPE_BOOLEAN, &remove_from_order,
DBUS_TYPE_INVALID);
g_assert(b);
server_broadcast(ls, n, NULL);
dbus_message_unref(n);
}
ls->connections = g_list_remove(ls->connections, lc);
ls->n_connections --;
if (lc->id) {
show_welcome(lc, FALSE);
g_hash_table_remove(ls->connections_by_id, lc->id);
ls->connections_left = g_list_remove(ls->connections_left, lc);
ls->connections_right = g_list_remove(ls->connections_right, lc);
if (ls->active_connection == lc)
server_pick_active_connection(ls);
if (ls->clipboard_connection == lc) {
ls->clipboard_connection = NULL;
ls->clipboard_empty = TRUE;
lassi_clipboard_clear(&lc->server->clipboard_info, FALSE);
}
if (ls->primary_connection == lc) {
ls->primary_connection = NULL;
ls->primary_empty = TRUE;
lassi_clipboard_clear(&lc->server->clipboard_info, TRUE);
}
if (remove_from_order) {
GList *i = g_list_find_custom(ls->order, lc->id, (GCompareFunc) strcmp);
if (i)
ls->order = g_list_delete_link(ls->order, i);
}
server_layout_changed(ls, -1);
lassi_prefs_update(&ls->prefs_info);
server_dump(ls);
}
lassi_tray_update(&ls->tray_info, ls->n_connections);
connection_destroy(lc);
}
