enlightenment/enlightenment
enlightenment
/
enlightenment
10
9
Fork 12
Code Issues 24 Pull Requests 2 Projects Releases Wiki Activity
enlightenment/src/bin/e_desklock.c

876 lines
23 KiB
C
Raw Blame History

/*
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
*/
#include "e.h"
#ifdef HAVE_PAM
# include <security/pam_appl.h>
# include <pwd.h>
# include <limits.h>
#endif
#define E_DESKLOCK_STATE_DEFAULT 0
#define E_DESKLOCK_STATE_CHECKING 1
#define E_DESKLOCK_STATE_INVALID 2
#define ELOCK_POPUP_LAYER 10000
#define PASSWD_LEN 256
/**************************** private data ******************************/
typedef struct _E_Desklock_Data E_Desklock_Data;
typedef struct _E_Desklock_Popup_Data E_Desklock_Popup_Data;
#ifdef HAVE_PAM
typedef struct _E_Desklock_Auth E_Desklock_Auth;
#endif
struct _E_Desklock_Popup_Data
{
E_Popup *popup_wnd;
Evas_Object *bg_object;
Evas_Object *login_box;
};
struct _E_Desklock_Data
{
Evas_List *elock_wnd_list;
Ecore_X_Window elock_wnd;
Evas_List *handlers;
Ecore_X_Window elock_grab_break_wnd;
char passwd[PASSWD_LEN];
int state;
};
#ifdef HAVE_PAM
struct _E_Desklock_Auth
{
struct {
struct pam_conv conv;
pam_handle_t *handle;
} pam;
char user[PATH_MAX];
char passwd[PATH_MAX];
};
#endif
static E_Desklock_Data *edd = NULL;
static E_Zone *last_active_zone = NULL;
#ifdef HAVE_PAM
static Ecore_Event_Handler *_e_desklock_exit_handler = NULL;
static pid_t _e_desklock_child_pid = -1;
#endif
static Ecore_Exe *_e_custom_desklock_exe = NULL;
static Ecore_Event_Handler *_e_custom_desklock_exe_handler = NULL;
static Ecore_Poller *_e_desklock_idle_poller = NULL;
static int _e_desklock_user_idle = 0;
/***********************************************************************/
static int _e_desklock_cb_key_down(void *data, int type, void *event);
static int _e_desklock_cb_mouse_down(void *data, int type, void *event);
static int _e_desklock_cb_mouse_up(void *data, int type, void *event);
static int _e_desklock_cb_mouse_wheel(void *data, int type, void *event);
static int _e_desklock_cb_mouse_move(void *data, int type, void *event);
static int _e_desklock_cb_custom_desklock_exit(void *data, int type, void *event);
static int _e_desklock_cb_idle_poller(void *data);
static void _e_desklock_passwd_update(void);
static void _e_desklock_backspace(void);
static void _e_desklock_delete(void);
static int _e_desklock_zone_num_get(void);
static int _e_desklock_check_auth(void);
static void _e_desklock_state_set(int state);
#ifdef HAVE_PAM
static int _e_desklock_cb_exit(void *data, int type, void *event);
static int _desklock_auth(char *passwd);
static int _desklock_pam_init(E_Desklock_Auth *da);
static int _desklock_auth_pam_conv(int num_msg, const struct pam_message **msg, struct pam_response **resp, void *appdata_ptr);
static char *_desklock_auth_get_current_user(void);
static char *_desklock_auth_get_current_host(void);
#endif
EAPI int E_EVENT_DESKLOCK = 0;
EAPI int
e_desklock_init(void)
{
/* A poller to tick every 256 ticks, watching for an idle user */
_e_desklock_idle_poller = ecore_poller_add(ECORE_POLLER_CORE, 256,
_e_desklock_cb_idle_poller, NULL);
if (e_config->desklock_background)
e_filereg_register(e_config->desklock_background);
E_EVENT_DESKLOCK = ecore_event_type_new();
return 1;
}
EAPI int
e_desklock_shutdown(void)
{
e_desklock_hide();
if (e_config->desklock_background)
e_filereg_deregister(e_config->desklock_background);
return 1;
}
EAPI int
e_desklock_show(void)
{
Evas_List *managers, *l, *l2, *l3;
E_Desklock_Popup_Data *edp;
Evas_Coord mw, mh;
E_Zone *current_zone;
int zone_counter;
int total_zone_num;
E_Event_Desklock *ev;
if (_e_custom_desklock_exe) return 0;
if (e_config->desklock_use_custom_desklock)
{
_e_custom_desklock_exe_handler = ecore_event_handler_add(ECORE_EXE_EVENT_DEL,
_e_desklock_cb_custom_desklock_exit,
NULL);
e_util_library_path_strip();
_e_custom_desklock_exe = ecore_exe_run(e_config->desklock_custom_desklock_cmd, NULL);
e_util_library_path_restore();
return 1;
}
#ifndef HAVE_PAM
e_util_dialog_show(_("Error - no PAM support"),
_("No PAM support was built into Enlightenment, so<br>"
"desk locking is disabled."));
return 0;
#endif
if (edd) return 0;
#ifdef HAVE_PAM
if (e_config->desklock_auth_method == 1)
{
#endif
if (!e_config->desklock_personal_passwd)
{
E_Zone *zone;
zone = e_util_zone_current_get(e_manager_current_get());
if (zone)
e_configure_registry_call("screen/screen_lock", zone->container, NULL);
return 0;
}
#ifdef HAVE_PAM
}
#endif
edd = E_NEW(E_Desklock_Data, 1);
if (!edd) return 0;
edd->elock_wnd = ecore_x_window_input_new(e_manager_current_get()->root,
0, 0, 1, 1);
ecore_x_window_show(edd->elock_wnd);
managers = e_manager_list();
if (!e_grabinput_get(edd->elock_wnd, 0, edd->elock_wnd))
{
for (l = managers; l; l = l->next)
{
E_Manager *man;
Ecore_X_Window *windows;
int wnum;
man = l->data;
windows = ecore_x_window_children_get(man->root, &wnum);
if (windows)
{
int i;
for (i = 0; i < wnum; i++)
{
Ecore_X_Window_Attributes att;
memset(&att, 0, sizeof(Ecore_X_Window_Attributes));
ecore_x_window_attributes_get(windows[i], &att);
if (att.visible)
{
ecore_x_window_hide(windows[i]);
if (e_grabinput_get(edd->elock_wnd, 0, edd->elock_wnd))
{
edd->elock_grab_break_wnd = windows[i];
free(windows);
goto works;
}
ecore_x_window_show(windows[i]);
}
}
free(windows);
}
}
/* everything failed - cant lock */
e_util_dialog_show(_("Lock Failed"),
_("Locking the desktop failed because some application<br>"
"has grabbed either the keyboard or the mouse or both<br>"
"and their grab is unable to be broken."));
ecore_x_window_del(edd->elock_wnd);
free(edd);
edd = NULL;
return 0;
}
works:
last_active_zone = current_zone =
e_zone_current_get(e_container_current_get(e_manager_current_get()));
zone_counter = 0;
total_zone_num = _e_desklock_zone_num_get();
for (l = managers; l; l = l->next)
{
E_Manager *man;
man = l->data;
for (l2 = man->containers; l2; l2 = l2->next)
{
E_Container *con;
con = l2->data;
for (l3 = con->zones; l3; l3 = l3->next)
{
E_Zone *zone;
zone = l3->data;
edp = E_NEW(E_Desklock_Popup_Data, 1);
if (edp)
{
edp->popup_wnd = e_popup_new(zone, 0, 0, zone->w, zone->h);
evas_event_feed_mouse_move(edp->popup_wnd->evas, -1000000, -1000000,
ecore_x_current_time_get(), NULL);
e_popup_layer_set(edp->popup_wnd, ELOCK_POPUP_LAYER);
ecore_evas_raise(edp->popup_wnd->ecore_evas);
evas_event_freeze(edp->popup_wnd->evas);
edp->bg_object = edje_object_add(edp->popup_wnd->evas);
if ((!e_config->desklock_background) ||
(!strcmp(e_config->desklock_background, "theme_desklock_background")))
{
e_theme_edje_object_set(edp->bg_object,
"base/theme/desklock",
"e/desklock/background");
}
else if (!strcmp(e_config->desklock_background, "theme_background"))
{
e_theme_edje_object_set(edp->bg_object,
"base/theme/backgrounds",
"e/desktop/background");
}
else
{
if (e_util_edje_collection_exists(e_config->desklock_background,
"e/desklock/background"))
{
edje_object_file_set(edp->bg_object, e_config->desklock_background,
"e/desklock/background");
}
else
{
if (!edje_object_file_set(edp->bg_object,
e_config->desklock_background,
"e/desktop/background"))
{
edje_object_file_set(edp->bg_object,
e_theme_edje_file_get("base/theme/desklock",
"e/desklock/background"),
"e/desklock/background");
}
}
}
evas_object_move(edp->bg_object, 0, 0);
evas_object_resize(edp->bg_object, zone->w, zone->h);
evas_object_show(edp->bg_object);
edp->login_box = edje_object_add(edp->popup_wnd->evas);
e_theme_edje_object_set(edp->login_box,
"base/theme/desklock",
"e/desklock/login_box");
edje_object_part_text_set(edp->login_box, "e.text.title",
_("Please enter your unlock password"));
edje_object_part_swallow(edp->bg_object, "e.swallow.login_box", edp->login_box);
edje_object_size_min_calc(edp->login_box, &mw, &mh);
evas_object_move(edp->login_box, (int)((zone->w - mw)/2),
(int)((zone->h - mh)/2));
if (total_zone_num > 1)
{
if (e_config->desklock_login_box_zone == -1)
evas_object_show(edp->login_box);
else if (e_config->desklock_login_box_zone == -2 && zone == current_zone)
evas_object_show(edp->login_box);
else if (e_config->desklock_login_box_zone == zone_counter )
evas_object_show(edp->login_box);
}
else
evas_object_show(edp->login_box);
/**/
e_popup_edje_bg_object_set(edp->popup_wnd, edp->bg_object);
evas_event_thaw(edp->popup_wnd->evas);
e_popup_show(edp->popup_wnd);
edd->elock_wnd_list = evas_list_append(edd->elock_wnd_list, edp);
}
zone_counter++;
}
}
}
/* handlers */
edd->handlers = evas_list_append(edd->handlers,
ecore_event_handler_add(ECORE_X_EVENT_KEY_DOWN,
_e_desklock_cb_key_down, NULL));
edd->handlers = evas_list_append(edd->handlers,
ecore_event_handler_add(ECORE_X_EVENT_MOUSE_BUTTON_DOWN,
_e_desklock_cb_mouse_down, NULL));
edd->handlers = evas_list_append(edd->handlers,
ecore_event_handler_add(ECORE_X_EVENT_MOUSE_BUTTON_UP,
_e_desklock_cb_mouse_up, NULL));
edd->handlers = evas_list_append(edd->handlers,
ecore_event_handler_add(ECORE_X_EVENT_MOUSE_WHEEL,
_e_desklock_cb_mouse_wheel,
NULL));
if ((total_zone_num > 1) && (e_config->desklock_login_box_zone == -2))
edd->handlers = evas_list_append(edd->handlers,
ecore_event_handler_add(ECORE_X_EVENT_MOUSE_MOVE,
_e_desklock_cb_mouse_move,
NULL));
_e_desklock_passwd_update();
ev = E_NEW(E_Event_Desklock, 1);
ev->on = 1;
ecore_event_add(E_EVENT_DESKLOCK, ev, NULL, NULL);
return 1;
}
EAPI void
e_desklock_hide(void)
{
E_Desklock_Popup_Data *edp;
E_Event_Desklock *ev;
if ((!edd) && (!_e_custom_desklock_exe)) return;
if (e_config->desklock_use_custom_desklock)
{
_e_custom_desklock_exe = NULL;
return;
}
if (edd->elock_grab_break_wnd)
ecore_x_window_show(edd->elock_grab_break_wnd);
while (edd->elock_wnd_list)
{
edp = edd->elock_wnd_list->data;
if (edp)
{
e_popup_hide(edp->popup_wnd);
evas_event_freeze(edp->popup_wnd->evas);
evas_object_del(edp->bg_object);
evas_object_del(edp->login_box);
evas_event_thaw(edp->popup_wnd->evas);
e_util_defer_object_del(E_OBJECT(edp->popup_wnd));
E_FREE(edp);
}
edd->elock_wnd_list = evas_list_remove_list(edd->elock_wnd_list, edd->elock_wnd_list);
}
while (edd->handlers)
{
ecore_event_handler_del(edd->handlers->data);
edd->handlers = evas_list_remove_list(edd->handlers, edd->handlers);
}
e_grabinput_release(edd->elock_wnd, edd->elock_wnd);
ecore_x_window_del(edd->elock_wnd);
E_FREE(edd);
edd = NULL;
ev = E_NEW(E_Event_Desklock, 1);
ev->on = 0;
ecore_event_add(E_EVENT_DESKLOCK, ev, NULL, NULL);
}
static int
_e_desklock_cb_key_down(void *data, int type, void *event)
{
Ecore_X_Event_Key_Down *ev;
ev = event;
if (ev->win != edd->elock_wnd || edd->state == E_DESKLOCK_STATE_CHECKING) return 1;
if (!strcmp(ev->keysymbol, "Escape"))
;
else if (!strcmp(ev->keysymbol, "KP_Enter"))
_e_desklock_check_auth();
else if (!strcmp(ev->keysymbol, "Return"))
_e_desklock_check_auth();
else if (!strcmp(ev->keysymbol, "BackSpace"))
_e_desklock_backspace();
else if (!strcmp(ev->keysymbol, "Delete"))
_e_desklock_delete();
else
{
/* here we have to grab a password */
if (ev->key_compose)
{
if ((strlen(edd->passwd) < (PASSWD_LEN - strlen(ev->key_compose))))
{
strcat(edd->passwd, ev->key_compose);
_e_desklock_passwd_update();
}
}
}
return 1;
}
static int
_e_desklock_cb_mouse_down(void *data, int type, void *event)
{
return 1;
}
static int
_e_desklock_cb_mouse_up(void *data, int type, void *event)
{
return 1;
}
static int
_e_desklock_cb_mouse_wheel(void *data, int type, void *event)
{
return 1;
}
static int
_e_desklock_cb_mouse_move(void *data, int type, void *event)
{
E_Desklock_Popup_Data *edp;
E_Zone *current_zone;
Evas_List *l;
current_zone = e_zone_current_get(e_container_current_get(e_manager_current_get()));
if (current_zone == last_active_zone)
return 1;
for (l = edd->elock_wnd_list; l; l = l->next)
{
edp = l->data;
if (!edp) continue;
if (edp->popup_wnd->zone == last_active_zone)
evas_object_hide(edp->login_box);
else if (edp->popup_wnd->zone == current_zone)
evas_object_show(edp->login_box);
}
last_active_zone = current_zone;
return 1;
}
static void
_e_desklock_passwd_update(void)
{
char passwd_hidden[PASSWD_LEN] = "", *p, *pp;
E_Desklock_Popup_Data *edp;
Evas_List *l;
if (!edd) return;
for (p = edd->passwd, pp = passwd_hidden; *p; p++, pp++)
*pp = '*';
*pp = 0;
for (l = edd->elock_wnd_list; l; l = l->next)
{
edp = l->data;
edje_object_part_text_set(edp->login_box, "e.text.password",
passwd_hidden);
}
}
static void
_e_desklock_backspace(void)
{
int len, val, pos;
if (!edd) return;
len = strlen(edd->passwd);
if (len > 0)
{
pos = evas_string_char_prev_get(edd->passwd, len, &val);
if ((pos < len) && (pos >= 0))
{
edd->passwd[pos] = 0;
_e_desklock_passwd_update();
}
}
}
static void
_e_desklock_delete(void)
{
_e_desklock_backspace();
}
static int
_e_desklock_zone_num_get(void)
{
int num;
Evas_List *l, *l2;
num = 0;
for (l = e_manager_list(); l; l = l->next)
{
E_Manager *man = l->data;
for (l2 = man->containers; l2; l2 = l2->next)
{
E_Container *con = l2->data;
num += evas_list_count(con->zones);
}
}
return num;
}
static int
_e_desklock_check_auth(void)
{
if (!edd) return 0;
#ifdef HAVE_PAM
if (e_config->desklock_auth_method == 0)
return _desklock_auth(edd->passwd);
else if (e_config->desklock_auth_method == 1)
{
#endif
if ((e_config->desklock_personal_passwd) &&
(!strcmp(edd->passwd == NULL ? "" : edd->passwd,
e_config->desklock_personal_passwd == NULL ? "" :
e_config->desklock_personal_passwd)))
{
/* password ok */
/* security - null out passwd string once we are done with it */
memset(edd->passwd, 0, sizeof(char) * PASSWD_LEN);
e_desklock_hide();
return 1;
}
#ifdef HAVE_PAM
}
#endif
/* password is definitely wrong */
_e_desklock_state_set(E_DESKLOCK_STATE_INVALID);
memset(edd->passwd, 0, sizeof(char) * PASSWD_LEN);
_e_desklock_passwd_update();
return 0;
}
static void
_e_desklock_state_set(int state)
{
Evas_List *l;
const char *signal, *text;
if (!edd) return;
edd->state = state;
if (state == E_DESKLOCK_STATE_CHECKING)
{
signal = "e,state,checking";
text = "Authenticating...";
}
else if (state == E_DESKLOCK_STATE_INVALID)
{
signal = "e,state,invalid";
text = "The password you entered is invalid. Try again.";
}
for (l = edd->elock_wnd_list; l; l = l->next)
{
E_Desklock_Popup_Data *edp;
edp = l->data;
edje_object_signal_emit(edp->login_box, signal, "e.desklock");
edje_object_signal_emit(edp->bg_object, signal, "e.desklock");
edje_object_part_text_set(edp->login_box, "e.text.title", text);
}
}
#ifdef HAVE_PAM
static int
_e_desklock_cb_exit(void *data, int type, void *event)
{
Ecore_Exe_Event_Del *ev;
ev = event;
if (ev->pid == _e_desklock_child_pid)
{
_e_desklock_child_pid = -1;
/* ok */
if (ev->exit_code == 0)
{
/* security - null out passwd string once we are done with it */
memset(edd->passwd, 0, sizeof(char) * PASSWD_LEN);
e_desklock_hide();
}
/* error */
else if (ev->exit_code < 128)
{
/* security - null out passwd string once we are done with it */
memset(edd->passwd, 0, sizeof(char) * PASSWD_LEN);
e_desklock_hide();
e_util_dialog_show(_("Authentication System Error"),
_("Authentication via PAM had errors setting up the<br>"
"authentication session. The error code was <hilight>%i</hilight>.<br>"
"This is bad and should not be happening. Please report this bug.")
, ev->exit_code);
}
/* failed auth */
else
{
_e_desklock_state_set(E_DESKLOCK_STATE_INVALID);
/* security - null out passwd string once we are done with it */
memset(edd->passwd, 0, sizeof(char) * PASSWD_LEN);
_e_desklock_passwd_update();
}
ecore_event_handler_del(_e_desklock_exit_handler);
_e_desklock_exit_handler = NULL;
}
return 1;
}
static int
_desklock_auth(char *passwd)
{
_e_desklock_state_set(E_DESKLOCK_STATE_CHECKING);
if ((_e_desklock_child_pid = fork()))
{
/* parent */
_e_desklock_exit_handler =
ecore_event_handler_add(ECORE_EXE_EVENT_DEL, _e_desklock_cb_exit,
NULL);
}
else
{
/* child */
int pamerr;
E_Desklock_Auth da;
char *current_user, *p;
struct sigaction action;
action.sa_handler = SIG_DFL;
action.sa_flags = SA_ONSTACK | SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
sigemptyset(&action.sa_mask);
sigaction(SIGSEGV, &action, NULL);
sigaction(SIGILL, &action, NULL);
sigaction(SIGFPE, &action, NULL);
sigaction(SIGBUS, &action, NULL);
sigaction(SIGABRT, &action, NULL);
current_user = _desklock_auth_get_current_user();
strncpy(da.user, current_user, PATH_MAX);
strncpy(da.passwd, passwd, PATH_MAX);
/* security - null out passwd string once we are done with it */
for (p = passwd; *p; p++) *p = 0;
da.pam.handle = NULL;
da.pam.conv.conv = NULL;
da.pam.conv.appdata_ptr = NULL;
pamerr = _desklock_pam_init(&da);
if (pamerr != PAM_SUCCESS)
{
free(current_user);
exit(pamerr);
}
pamerr = pam_authenticate(da.pam.handle, 0);
pam_end(da.pam.handle, pamerr);
/* security - null out passwd string once we are done with it */
memset(da.passwd, 0, sizeof(da.passwd));
if (pamerr == PAM_SUCCESS)
{
free(current_user);
exit(0);
}
free(current_user);
exit(-1);
}
return 1;
}
static char *
_desklock_auth_get_current_user(void)
{
char *user;
struct passwd *pwent = NULL;
pwent = getpwuid(getuid());
user = strdup(pwent->pw_name);
return user;
}
static int
_desklock_pam_init(E_Desklock_Auth *da)
{
int pamerr;
const char *pam_prof;
char *current_host;
char *current_user;
if (!da) return -1;
da->pam.conv.conv = _desklock_auth_pam_conv;
da->pam.conv.appdata_ptr = da;
da->pam.handle = NULL;
/* try other pam profiles - and system-auth (login for fbsd users) is a fallback */
pam_prof = "login";
if (ecore_file_exists("/etc/pam.d/enlightenment"))
pam_prof = "enlightenment";
else if (ecore_file_exists("/etc/pam.d/xscreensaver"))
pam_prof = "xscreensaver";
else if (ecore_file_exists("/etc/pam.d/kscreensaver"))
pam_prof = "kscreensaver";
else if (ecore_file_exists("/etc/pam.d/system-auth"))
pam_prof = "system-auth";
else if (ecore_file_exists("/etc/pam.d/system"))
pam_prof = "system";
if ((pamerr = pam_start(pam_prof, da->user, &(da->pam.conv),
&(da->pam.handle))) != PAM_SUCCESS)
return pamerr;
current_user = _desklock_auth_get_current_user();
if ((pamerr = pam_set_item(da->pam.handle, PAM_USER, current_user)) != PAM_SUCCESS)
{
free(current_user);
return pamerr;
}
current_host = _desklock_auth_get_current_host();
if ((pamerr = pam_set_item(da->pam.handle, PAM_RHOST, current_host)) != PAM_SUCCESS)
{
free(current_user);
free(current_host);
return pamerr;
}
free(current_user);
free(current_host);
return 0;
}
static int
_desklock_auth_pam_conv(int num_msg, const struct pam_message **msg, struct pam_response **resp, void *appdata_ptr)
{
int replies = 0;
E_Desklock_Auth *da = (E_Desklock_Auth *)appdata_ptr;
struct pam_response *reply = NULL;
reply = (struct pam_response *)malloc(sizeof(struct pam_response) *num_msg);
if (!reply)
return PAM_CONV_ERR;
for (replies = 0; replies < num_msg; replies++)
{
switch (msg[replies]->msg_style)
{
case PAM_PROMPT_ECHO_ON:
reply[replies].resp_retcode = PAM_SUCCESS;
reply[replies].resp = strdup(da->user);
break;
case PAM_PROMPT_ECHO_OFF:
reply[replies].resp_retcode = PAM_SUCCESS;
reply[replies].resp = strdup(da->passwd);
break;
case PAM_ERROR_MSG:
case PAM_TEXT_INFO:
reply[replies].resp_retcode = PAM_SUCCESS;
reply[replies].resp = NULL;
break;
default:
free(reply);
return PAM_CONV_ERR;
}
}
*resp = reply;
return PAM_SUCCESS;
}
static char *
_desklock_auth_get_current_host(void)
{
return strdup("localhost");
}
#endif
static int
_e_desklock_cb_custom_desklock_exit(void *data, int type, void *event)
{
Ecore_Exe_Event_Del *ev;
ev = event;
if (ev->exe != _e_custom_desklock_exe) return 1;
if (ev->exit_code != 0)
{
/* do something profound here... like notify someone */
}
e_desklock_hide();
return 0;
}
static int
_e_desklock_cb_idle_poller(void *data)
{
if (e_config->desklock_autolock_idle)
{
/* If a desklock is already up, bail */
if ((_e_custom_desklock_exe) || (edd)) return 1;
/* If we have exceeded our idle time... */
if (ecore_x_screensaver_idle_time_get() >= e_config->desklock_autolock_idle_timeout)
{
/*
* Unfortunately, not all "desklocks" stay up for as long as
* the user is idle or until it is unlocked.
*
* 'xscreensaver-command -lock' for example sends a command
* to xscreensaver and then terminates. So, we have another
* check (_e_desklock_user_idle) which lets us know that we
* have locked the screen due to idleness.
*/
if (!_e_desklock_user_idle)
{
_e_desklock_user_idle = 1;
e_desklock_show();
}
}
else
_e_desklock_user_idle = 0;
}
/* Make sure our poller persists. */
return 1;
}
Reference in New Issue View Git Blame Copy Permalink