t_list *get_link(char *d_name, struct stat *f_stat, char *path)
{
t_ls content;
t_list *lst;
if (!f_stat || !d_name)
return (NULL);
errno = 0;
content.nb_hlink = (int)(f_stat->st_nlink);
content.size = (int)(f_stat->st_size);
content.nb_blk = (int)(f_stat->st_blocks);
time_asm(f_stat, &content);
if (!(content.name = ft_strdup(d_name))
|| !(content.u_name = get_uname(f_stat->st_uid))
|| !(content.g_name = get_gname(f_stat->st_gid))
|| !(content.rights = get_rights(f_stat, path))
|| !(content.type = get_type(f_stat)))
return (NULL);
content.link = f_readlink(content, path);
if (!(lst = ft_lstnew(&content, sizeof(content))))
{
free_content(&content, content.size);
return (NULL);
}
return (lst);
}
void bar_upd(int sig) {
static char barstr[750];
snprintf(barstr, 750, "%%{l}%s %s %s%%{c}%s%%{r}%s %s %s %s\n",
get_win((sig == -2 ? false : true)),
get_hname(),
get_xtitle((sig == -1 ? false : true)),
get_mpd(),
get_vol(),
get_load(),
get_uname(),
get_time());
fputs(barstr, barfp);
fflush(barfp);
}
static gboolean
update_failcount(xmlNode * event, const char *event_node_uuid, int rc, int target_rc, gboolean do_update)
{
int interval = 0;
char *task = NULL;
char *rsc_id = NULL;
char *attr_name = NULL;
const char *value = NULL;
const char *id = crm_element_value(event, XML_LRM_ATTR_TASK_KEY);
const char *on_uname = get_uname_from_event(event);
const char *origin = crm_element_value(event, XML_ATTR_ORIGIN);
if (rc == 99) {
/* this is an internal code for "we're busy, try again" */
return FALSE;
} else if (rc == target_rc) {
return FALSE;
}
if (safe_str_eq(origin, "build_active_RAs")) {
crm_debug("No update for %s (rc=%d) on %s: Old failure from lrm status refresh",
id, rc, on_uname);
return FALSE;
}
if (failed_stop_offset == NULL) {
failed_stop_offset = strdup(INFINITY_S);
}
if (failed_start_offset == NULL) {
failed_start_offset = strdup(INFINITY_S);
}
if (on_uname == NULL) {
/* uname not in event, check cache */
on_uname = get_uname(event_node_uuid);
CRM_CHECK(on_uname != NULL, return TRUE);
}
/* ========================================================================= */
struct per_user *collect_per_user(struct per_user *ulist, ipcinfo_shm_t *shmbuf)
{
struct per_user *the_user;
if ( NULL == shmbuf )
return(ulist);
if ( NULL == (the_user = find_user(ulist, shmbuf->shm_perm.uid)) )
{
if (NULL == (the_user = (struct per_user *)malloc(sizeof(struct per_user))))
{
/* This gives bad results - but is highly unlikely */
return(ulist);
}
the_user->uid = shmbuf->shm_perm.uid;
the_user->uname = get_uname(shmbuf->shm_perm.uid);
the_user->total_size = shmbuf->shm_segsz;
the_user->count = 1;
if ( shmbuf->shm_nattch = 0 )
the_user->no_attach_count = 1;
else
the_user->no_attach_count = 0;
the_user->next = ulist;
return(the_user);
}
else
{
the_user->total_size += shmbuf->shm_segsz;
the_user->count++;
if ( shmbuf->shm_nattch = 0 )
the_user->no_attach_count++;
return(ulist);
}
/* unreachable */
return(NULL);
}
static void
set_system_information(Enna_Buffer *b)
{
if (!b)
return;
enna_buffer_append(b, "<c>");
enna_buffer_append(b, _("System information"));
enna_buffer_append(b, "</c><br><br>");
get_distribution(b);
get_uname(b);
get_cpuinfos(b);
get_loadavg(b);
get_ram_usage(b);
#ifdef BUILD_LIBSVDRP
get_vdr(b);
#endif /* BUILD_LIBSVDRP */
#ifdef BUILD_LIBXRANDR
get_resolution(b);
#endif /* BUILD_LIBXRANDR */
get_network(b);
get_default_gw(b);
}
int main(int argc, char **argv) {
int only_root, auth = 0, chpid;
uid_t uid;
userinfo_t *as, root, user;
oldvt = oldsysrq = vt.nr = vt.fd = -1;
vt.ios = NULL;
root.name = "root";
parse_options(argc, argv);
if (geteuid() != 0) {
fprintf(stderr, "physlock: must be root!\n");
return 1;
}
setup_signal(SIGTERM, sa_handler_exit);
setup_signal(SIGQUIT, sa_handler_exit);
setup_signal(SIGHUP, SIG_IGN);
setup_signal(SIGINT, SIG_IGN);
setup_signal(SIGUSR1, SIG_IGN);
setup_signal(SIGUSR2, SIG_IGN);
vt_init();
get_current_vt(&oldvt);
if (options->only_lock) {
lock_vt_switch();
vt_destroy();
return 0;
} else if (options->only_unlock) {
unlock_vt_switch();
vt_destroy();
return 0;
}
if (options->disable_sysrq) {
oldsysrq = get_sysrq_state(SYSRQ_PATH);
if (oldsysrq > 0)
set_sysrq_state(SYSRQ_PATH, 0);
}
if (options->user) {
user.name = options->user;
} else {
uid = getuid();
get_uname(&user, uid);
}
get_pwhash(&root);
only_root = strcmp(user.name, root.name) == 0;
if (!only_root) {
get_pwhash(&user);
authenticate(&user, ""); /* test authentication */
}
acquire_new_vt(&vt);
lock_vt_switch();
secure_vt(&vt);
if (options->detach) {
chpid = fork();
if (chpid < 0)
die("could not spawn background process: %s", strerror(errno));
else if (chpid > 0)
return 0;
else
setsid();
}
if (options->cmd)
handle_cmd(1);
while (!auth) {
as = &root;
flush_vt(&vt);
if (!only_root) {
tty_echo_on(&vt);
while (1) {
prompt(vt.ios, "\nUnlock as [%s/%s]: ", user.name, root.name);
if (!*buf || !strcmp(buf, user.name)) {
as = &user;
break;
} else if (!strcmp(buf, root.name)) {
break;
}
}
tty_echo_off(&vt);
} else {
prompt(vt.ios, "\nPress [Enter] to unlock.\n");
}
prompt(vt.ios, "%s's password: "******"\nAuthentication failed\n");
sleep(AUTH_FAIL_TIMEOUT);
}
}
if (options->crypt)
add_passphrase(buf, options->fnek, vt.ios);
if (options->cmd)
handle_cmd(0);
sleep(1);
cleanup();
return 0;
}
void CrashDialog::show_details(void) {
if(trace_log->visible()) {
trace_log->hide();
save_as->hide();
details->label(_("@> Show details"));
size(DIALOG_W, DIALOG_H);
} else {
trace_log->show();
save_as->show();
details->label(_("@< Hide details"));
size(DIALOG_W_EXPANDED, DIALOG_H_EXPANDED);
if(!details_shown) {
trace_buff->remove(0, trace_buff->length());
edelib::String address = _("\nPlease report this at: ");
if(bugaddress)
address += bugaddress;
else
address += "http://bugs.equinox-project.org";
trace_buff->append(address.c_str());
trace_buff->append("\n\n");
trace_buff->append("---------- short summary ----------\n");
trace_buff->append("\nEDE version: " PACKAGE_VERSION);
trace_buff->append("\nSystem info: ");
trace_buff->append(get_uname().c_str());
trace_buff->append("\nProgram name: ");
if(appname)
trace_buff->append(appname);
else
trace_buff->append("(unknown)");
trace_buff->append("\nExecutable path: ");
if(apppath)
trace_buff->append(apppath);
else
trace_buff->append("(unknown)");
trace_buff->append("\nRunning PID: ");
if(pid)
trace_buff->append(pid);
else
trace_buff->append("(unknown)");
trace_buff->append("\nSignal received: ");
if(signal_num)
trace_buff->append(signal_num);
else
trace_buff->append("(unknown)");
/* try backtrace via gdb */
trace_buff->append("\n\n---------- backtrace ----------\n");
const char* core_file = "core";
const char* gdb_output = "/tmp/.gdb_output";
const char* gdb_script = "/tmp/.gdb_script";
if(!edelib::file_test(core_file, edelib::FILE_TEST_IS_REGULAR)) {
trace_buff->append("\nUnable to find 'core' file. Backtrace will not be done.");
details_shown = false;
return;
}
edelib::String gdb_path = edelib::file_path("gdb");
if(gdb_path.empty()) {
trace_buff->append("\nUnable to find gdb. Please install it first.");
/* set to false so next 'Show Details' click can try again with the debugger */
details_shown = false;
return;
}
/* TODO: these files should be unique per session */
if(spawn_backtrace(gdb_path.c_str(), cmd.c_str(), core_file, gdb_output, gdb_script) == -1) {
trace_buff->append("\nUnable to properly execute gdb");
details_shown = false;
return;
}
trace_buff->append("\n");
if(trace_buff->appendfile(gdb_output) != 0) {
trace_buff->append("Unable to read gdb output file");
details_shown = false;
return;
}
edelib::file_remove(gdb_output);
edelib::file_remove(gdb_script);
edelib::file_remove(core_file);
details_shown = true;
}
}
}
static gboolean
update_failcount(xmlNode * event, const char *event_node, int rc, int target_rc, gboolean do_update)
{
int interval = 0;
char *task = NULL;
char *rsc_id = NULL;
char *attr_name = NULL;
const char *value = NULL;
const char *id = crm_element_value(event, XML_LRM_ATTR_TASK_KEY);
const char *on_uname = get_uname(event_node);
if (rc == 99) {
/* this is an internal code for "we're busy, try again" */
return FALSE;
} else if (rc == target_rc) {
return FALSE;
}
if (failed_stop_offset == NULL) {
failed_stop_offset = crm_strdup(INFINITY_S);
}
if (failed_start_offset == NULL) {
failed_start_offset = crm_strdup(INFINITY_S);
}
CRM_CHECK(on_uname != NULL, return TRUE);
CRM_CHECK(parse_op_key(id, &rsc_id, &task, &interval), crm_err("Couldn't parse: %s", ID(event));
goto bail);
CRM_CHECK(task != NULL, goto bail);
CRM_CHECK(rsc_id != NULL, goto bail);
if (do_update || interval > 0) {
do_update = TRUE;
} else if (safe_str_eq(task, CRMD_ACTION_START)) {
do_update = TRUE;
value = failed_start_offset;
} else if (safe_str_eq(task, CRMD_ACTION_STOP)) {
do_update = TRUE;
value = failed_stop_offset;
} else if (safe_str_eq(task, CRMD_ACTION_STOP)) {
do_update = TRUE;
value = failed_stop_offset;
} else if (safe_str_eq(task, CRMD_ACTION_PROMOTE)) {
do_update = TRUE;
} else if (safe_str_eq(task, CRMD_ACTION_DEMOTE)) {
do_update = TRUE;
}
if (value == NULL || safe_str_neq(value, INFINITY_S)) {
value = XML_NVPAIR_ATTR_VALUE "++";
}
if (do_update) {
char *now = crm_itoa(time(NULL));
crm_warn("Updating failcount for %s on %s after failed %s:"
" rc=%d (update=%s, time=%s)", rsc_id, on_uname, task, rc, value, now);
attr_name = crm_concat("fail-count", rsc_id, '-');
update_attrd(on_uname, attr_name, value, NULL);
crm_free(attr_name);
attr_name = crm_concat("last-failure", rsc_id, '-');
update_attrd(on_uname, attr_name, now, NULL);
crm_free(attr_name);
crm_free(now);
}
bail:
crm_free(rsc_id);
crm_free(task);
return TRUE;
}
