int session_mgr_remove(session_mgr_t *mgr, int id)
{
if (mgr == NULL || id < 0) {
LOG_ERROR("Invalid session mgr or id");
return ZISS_ERROR;
}
if (mgr->session_list == NULL) {
LOG_ERROR("Invalid session list");
return ZISS_ERROR;
}
if (mgr->session_list->id == id) {
session_t *session_del = mgr->session_list;
mgr->session_list = mgr->session_list->next;
session_stop(session_del);
session_delete(session_del);
session_del = NULL;
return ZISS_OK;
}
session_t *s = mgr->session_list;
while (s->next != NULL) {
if (s->next->id == id) {
session_t *session_del = s->next;
s->next = s->next->next;
session_stop(session_del);
session_delete(session_del);
session_del = NULL;
return ZISS_OK;
} else {
s = s->next;
}
}
LOG_WARN("Session id not found");
return ZISS_OK;
}
static void
session_command_autoresume (EphySession *session,
guint32 user_time)
{
EphySessionPrivate *priv = session->priv;
GFile *saved_session_file;
char *saved_session_file_path;
gboolean crashed_session;
EphyPrefsRestoreSessionPolicy policy;
LOG ("ephy_session_autoresume");
saved_session_file = get_session_file (SESSION_STATE);
saved_session_file_path = g_file_get_path (saved_session_file);
g_object_unref (saved_session_file);
crashed_session = g_file_test (saved_session_file_path, G_FILE_TEST_EXISTS);
g_free (saved_session_file_path);
policy = g_settings_get_enum (EPHY_SETTINGS_MAIN,
EPHY_PREFS_RESTORE_SESSION_POLICY);
if (crashed_session == FALSE ||
policy == EPHY_PREFS_RESTORE_SESSION_POLICY_NEVER ||
priv->windows != NULL ||
priv->tool_windows != NULL)
{
/* If we are auto-resuming, and we never want to
* restore the session, clobber the session state
* file. */
if (policy == EPHY_PREFS_RESTORE_SESSION_POLICY_NEVER)
session_delete (session, SESSION_STATE);
ephy_session_queue_command (session,
EPHY_SESSION_CMD_MAYBE_OPEN_WINDOW,
NULL, NULL, user_time, FALSE);
return;
}
if (priv->resume_window)
{
gtk_window_present_with_time (GTK_WINDOW (priv->resume_window),
user_time);
return;
}
ephy_session_queue_command (session,
EPHY_SESSION_CMD_LOAD_SESSION,
SESSION_STATE, NULL, user_time, TRUE);
}
int session_mgr_check(session_mgr_t *mgr)
{
if (mgr == NULL) {
LOG_ERROR("Invalid session mgr");
return ZISS_ERROR;
}
if (mgr->session_list == NULL)
return ZISS_OK;
if (mgr->session_list->is_to_exit) { // TODO: lock here
session_t *session_del = mgr->session_list;
mgr->session_list = mgr->session_list->next;
session_stop(session_del);
session_delete(session_del);
session_del = NULL;
return ZISS_OK;
}
session_t *s = mgr->session_list;
while (s->next != NULL) {
if (s->next->is_to_exit) { // TODO: lock here
session_t *session_del = s->next;
s->next = s->next->next;
session_stop(session_del);
session_delete(session_del);
session_del = NULL;
return ZISS_OK;
} else {
s = s->next;
}
}
return ZISS_OK;
}
void sessions_do_events(sessions_t *sessions)
{
static NBBOOL recursion = FALSE;
/* sessions_print(sessions); */
if(recursion)
{
/*fprintf(stderr, "Skipping do_events to prevent infinite recursion.\n");*/
return;
}
/* Make sure this won't infinitely recurse. */
recursion = TRUE;
/* See if any sessions have timed out. */
sessions_expire(sessions);
/* Check for EOF. */
if(sessions->is_eof && !sessions_data_waiting(sessions))
{
fprintf(stderr, "EOF detected and buffers are empty; terminating.\n");
exit(0);
}
/* If we're in 'exec' mode, do housekeeping. */
if(sessions->exec)
{
/* Check if any terminated processes are finished. */
session_t *session = sessions->first_session;
while(session)
{
if(session->is_eof && !session_data_waiting(sessions, session->name))
{
fprintf(stderr, "Process is finished and data has been sent; closing session\n");
session_delete(sessions, session->name);
session = sessions->first_session;
}
else
{
session = (session_t*)session->next_session;
}
}
}
/* Infinite recursion is no longer an issue. */
recursion = FALSE;
}
int session_mgr_clear(session_mgr_t *mgr)
{
if (mgr == NULL) {
LOG_ERROR("Invalid session mgr");
return ZISS_ERROR;
}
while (mgr->session_list != NULL) {
session_t *temp = mgr->session_list;
mgr->session_list = mgr->session_list->next;
session_stop(temp);
session_delete(temp);
temp = NULL;
}
return ZISS_OK;
}
PUBLIC BOOL HTMuxSession_setClose (HTMuxChannel * muxch,
HTMuxSession * session, HTMuxClose close)
{
if (muxch && session) {
session->close |= close;
/*
** If both directions are closed down then we can put the session
** to sleep.
*/
if (session->close == MUX_S_END) {
HTTRACE(MUX_TRACE, "Mux Channel. Closing session %d on channel %p\n" _
session->sid _ muxch);
muxch->sessions[session->sid] = NULL;
session_delete(session);
}
return YES;
}
return NO;
}
void sessions_expire(sessions_t *sessions)
{
/* Start at the first session. */
session_t *session = sessions->first_session;
while(session)
{
/* Check if the session has timed out. */
if((time(NULL) - session->last_seen) > sessions->timeout)
{
/* If it has, delete the session and start over (we don't want to be in the middle of
* walking a list when we delete something from it). */
fprintf(stderr, "Session timed out: %s\n", session->name);
session_delete(sessions, session->name);
session = sessions->first_session;
}
else
{
session = (session_t*)session->next_session;
}
}
}
void
pannode_delete (struct pan_node *xq)
{
gint id;
acc_debug ("delete accxq: %p\n", xq);
if (xq->accxq && xq->accxq->panlist)
{
xq->accxq->panlist = g_list_remove (xq->accxq->panlist, xq);
}
if (GTK_IS_NOTEBOOK (xq->parent))
{
id = gtk_notebook_page_num (GTK_NOTEBOOK (xq->parent), xq->widget);
gtk_notebook_remove_page (GTK_NOTEBOOK (xq->parent), id);
}
if (xq->qipu)
{
qipu_destroy (xq->qipu);
}
g_list_free (xq->cur_moves);
xq->cur_moves = NULL;
if (xq->parterthread)
{
g_thread_join (xq->parterthread);
}
session_delete (xq->session);
if (xq->name)
{
g_free (xq->name);
}
free (xq);
}
