/* Handler for "clicked" signal on Switch User button. */
static void switch_user_clicked(GtkButton * button, HandlerContext * handler_context)
{
GError *err = NULL;
gtk_label_set_text(GTK_LABEL(handler_context->error_label), NULL);
lock_screen();
if (handler_context->switch_user_GDM)
g_spawn_command_line_sync("gdmflexiserver --startnew", NULL, NULL, NULL, NULL);
else if (handler_context->switch_user_KDM)
g_spawn_command_line_sync("kdmctl reserve", NULL, NULL, NULL, NULL);
else if (handler_context->switch_user_LIGHTDM)
dbus_Lightdm_SwitchToGreeter(&err);
else if(handler_context->switch_user_LXDM)
g_spawn_command_line_sync("lxdm-binary -c USER_SWITCH", NULL, NULL, NULL, NULL);
if (err)
{
gtk_label_set_text(GTK_LABEL(handler_context->error_label), err->message);
g_error_free (err);
}
else
{
gtk_main_quit();
}
}
static void on_session_stop(void *data,int pid, int status)
{
int level;
LXSession *s=data;
lxsession_stop(s);
level=get_run_level();
if(level=='0' || level=='6')
{
if(level=='0')
g_spawn_command_line_sync("/etc/lxdm/PreShutdown",0,0,0,0);
else
g_spawn_command_line_sync("/etc/lxdm/PreReboot",0,0,0,0);
g_message("run level %c\n",level);
lxdm_quit_self(0);
}
if(s!=lxsession_greeter())
{
lxsession_free(s);
}
else if(g_key_file_get_integer(config,"server","reset",NULL)==1)
{
lxsession_free(s);
lxsession_greeter();
}
gchar *argv[] = { "/etc/lxdm/PostLogout", NULL };
g_spawn_async(NULL, argv, s->env, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, NULL);
}
gboolean
timeout_func (gpointer user_data)
{
char ** argv = (char **)user_data;
g_usleep(500000);
g_debug("Initing");
gchar * command = g_strdup_printf("%s --dbus-name=org.dbusmenu.test --dbus-object=/org/test", argv[1]);
g_debug("Executing: %s", command);
gchar * output;
g_spawn_command_line_sync(command, &output, NULL, NULL, NULL);
GFile * ofile = g_file_new_for_commandline_arg(argv[2]);
if (ofile != NULL) {
g_file_replace_contents(ofile, output, g_utf8_strlen(output, -1), NULL, FALSE, 0, NULL, NULL, NULL);
}
g_spawn_command_line_sync("gdbus call --session --dest org.dbusmenu.test --object-path /org/test --method com.canonical.dbusmenu.Event 0 clicked \"<0>\" 0", NULL, NULL, NULL, NULL);
g_main_loop_quit(mainloop);
return TRUE;
}
int
main (int argc, char **argv)
{
gint result;
gchar *data_dir;
g_test_init (&argc, &argv, NULL);
data_dir = g_build_filename (g_get_current_dir (), "test-cache", NULL);
g_setenv ("XDG_DATA_HOME", data_dir, TRUE);
g_setenv ("XDG_CACHE_HOME", data_dir, TRUE);
g_setenv ("TRACKER_DB_ONTOLOGIES_DIR", TOP_SRCDIR "/data/ontologies/", TRUE);
/* add test cases */
g_test_add_func ("/libtracker-data/ontology-change", test_ontology_change);
/* run tests */
result = g_test_run ();
/* clean up */
g_print ("Removing temporary data\n");
g_spawn_command_line_sync ("rm -R tracker/", NULL, NULL, NULL, NULL);
g_spawn_command_line_sync ("rm -R test-cache/", NULL, NULL, NULL, NULL);
g_free (data_dir);
return result;
}
int has_efi_directory(PedPartition* part)
{
int is_busy = ped_partition_is_busy(part);
GError* error = NULL;
char* mount_point = NULL;
char *path = ped_partition_get_path(part);
if (!is_busy) {
mount_point = g_dir_make_tmp("efi_detectorXXXXXX", &error);
if (error != NULL) {
g_warning("[%s] create efi_detector failed :%s\n", __func__,
error->message);
g_error_free(error);
error = NULL;
}
char* cmd = g_strdup_printf ("mount -t vfat %s %s", path, mount_point);
g_spawn_command_line_sync (cmd, NULL, NULL, NULL, &error);
g_free(cmd);
if (error != NULL) {
g_warning("[%s] Can't detect whether is $ESP, cmd: %s, error: %s",
__func__, cmd, error->message);
g_error_free(error);
error = NULL;
return FALSE;
}
}
if (mount_point == NULL) {
mount_point = get_partition_mount_point(path);
}
g_free(path);
char* esp_path = g_build_filename(mount_point, "EFI", NULL);
int is_esp = g_file_test (esp_path, G_FILE_TEST_IS_DIR);
g_free(esp_path);
if (!is_busy) {
char* cmd = g_strdup_printf ("umount -l %s", mount_point);
g_spawn_command_line_sync (cmd, NULL, NULL, NULL, &error);
g_free(cmd);
if (error != NULL) {
g_warning("[%s] Can't detect whether is $ESP, cmd: %s, error: %s",
__func__, cmd, error->message);
g_error_free(error);
g_free(mount_point);
return is_esp;
}
//don't rm the dir if umount failed.
g_rmdir(mount_point);
g_free(mount_point);
}
return is_esp;
}
/* The following test function returns 1 only when the any one of the g_spawn_command_line_sync *
tests fails.For pass of all the test the function returns 0. */
int g_spawn_command_line_sync_tests()
{
GError *error = NULL;
int retVal = 0;
int exit_status;
gchar *standard_output, *standard_error;
if(g_spawn_command_line_sync("helloworld.exe 10 11 12",NULL,NULL,&exit_status,&error))
{
if(exit_status != 0)
{
g_log(NULL,G_LOG_LEVEL_CRITICAL,"Error in file %s: at line %d",__FILE__, __LINE__);
retVal = 1;
}
}
else
{
if(error)
{
g_log(NULL,G_LOG_LEVEL_CRITICAL,"file %s: line %d Error Message:%s",__FILE__, __LINE__, error->message);
g_error_free(error);
error = NULL;
}
else
{
g_log(NULL,G_LOG_LEVEL_CRITICAL,"Error in file %s: at line %d",__FILE__, __LINE__);
}
retVal = 1;
}
if(g_spawn_command_line_sync("helloworld.exe 10 11 12",&standard_output,&standard_error,&exit_status,&error))
{
if(exit_status != 0 || standard_output != NULL || standard_error != NULL)
{
g_log(NULL,G_LOG_LEVEL_CRITICAL,"Error in file %s: at line %d",__FILE__, __LINE__);
retVal = 1;
}
}
else
{
if(error)
{
g_log(NULL,G_LOG_LEVEL_CRITICAL,"file %s: line %d Error Message:%s",__FILE__, __LINE__, error->message);
g_error_free(error);
error = NULL;
}
else
{
g_log(NULL,G_LOG_LEVEL_CRITICAL,"Error in file %s: at line %d",__FILE__, __LINE__);
}
retVal = 1;
}
return retVal;
}
gboolean
xfce_volstatus_remove_drive(GHalDrive *drive)
{
GList *volumes, *l;
gboolean ret = TRUE;
GError *error = NULL;
gint exit_status = 0;
g_return_val_if_fail(GHAL_IS_DRIVE(drive), FALSE);
volumes = ghal_drive_list_volumes(drive);
for(l = volumes; l; l = l->next) {
GHalVolume *volume = l->data;
if(ghal_volume_is_mounted(volume)) {
gchar *udi_quoted = g_shell_quote(ghal_device_peek_udi(GHAL_DEVICE(volume)));
gchar *cmd = g_strdup_printf("exo-unmount -n -u -h %s", udi_quoted);
ret = g_spawn_command_line_sync(cmd, NULL, NULL, &exit_status,
&error);
g_free(udi_quoted);
g_free(cmd);
if(!ret || exit_status)
break;
}
}
g_list_foreach(volumes, (GFunc)g_object_unref, NULL);
g_list_free(volumes);
if(ghal_drive_requires_eject(drive)) {
gchar *udi_quoted = g_shell_quote(ghal_device_peek_udi(GHAL_DEVICE(drive)));
gchar *cmd = g_strdup_printf("exo-eject -n -e -h %s", udi_quoted);
ret = g_spawn_command_line_sync(cmd, NULL, NULL, &exit_status, &error);
g_free(udi_quoted);
g_free(cmd);
}
if(!ret) {
gchar *name = ghal_drive_get_display_name(drive);
gchar *primary = g_strdup_printf(_("Unable to remove \"%s\""), name);
xfce_message_dialog(NULL, _("Removal Failure"),
GTK_STOCK_DIALOG_WARNING, primary,
error ? error->message : _("Unknown error"),
GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT, NULL);
g_free(name);
g_free(primary);
if(error)
g_error_free(error);
}
return ret;
}
int
main (int argc, char *argv[])
{
int ret;
char *udi;
DBusError error;
LibHalContext *hal_ctx = NULL;
LibHalChangeSet *cs;
gboolean can_suspend = FALSE;
gboolean can_suspend_hybrid = FALSE;
gboolean can_hibernate = FALSE;
int exit_status;
ret = 1;
udi = getenv ("HAL_PROP_INFO_UDI");
if (udi == NULL)
goto out;
dbus_error_init (&error);
if ((hal_ctx = libhal_ctx_init_direct (&error)) == NULL) {
printf ("Cannot connect to hald\n");
if (dbus_error_is_set (&error)) {
dbus_error_free (&error);
}
goto out;
}
cs = libhal_device_new_changeset (udi);
if (cs == NULL) {
printf ("Cannot initialize changeset\n");
goto out;
}
g_spawn_command_line_sync ("/usr/bin/pm-is-supported --suspend", NULL, NULL, &exit_status, NULL);
can_suspend = (exit_status == 0);
g_spawn_command_line_sync ("/usr/bin/pm-is-supported --suspend-hybrid", NULL, NULL, &exit_status, NULL);
can_suspend_hybrid = (exit_status == 0);
g_spawn_command_line_sync ("/usr/bin/pm-is-supported --hibernate", NULL, NULL, &exit_status, NULL);
can_hibernate = (exit_status == 0);
libhal_changeset_set_property_bool (cs, "power_management.can_suspend", can_suspend);
libhal_changeset_set_property_bool (cs, "power_management.can_suspend_hybrid", can_suspend_hybrid);
libhal_changeset_set_property_bool (cs, "power_management.can_hibernate", can_hibernate);
libhal_device_commit_changeset (hal_ctx, cs, &error);
libhal_device_free_changeset (cs);
ret = 0;
out:
return ret;
}
gboolean
_set_using_ntp_fedora (DBusGMethodInvocation *context,
gboolean using_ntp)
{
GError *error;
int exit_status;
const char *ntp_client;
char *cmd;
error = NULL;
ntp_client = get_ntp_client ();
/* We omit --level 2345 so that systemd doesn't try to use the
* SysV init scripts */
cmd = g_strconcat ("/sbin/chkconfig ", ntp_client, " ", using_ntp ? "on" : "off", NULL);
if (!g_spawn_command_line_sync (cmd,
NULL, NULL, &exit_status, &error)) {
GError *error2;
error2 = g_error_new (GSD_DATETIME_MECHANISM_ERROR,
GSD_DATETIME_MECHANISM_ERROR_GENERAL,
"Error spawning '%s': %s", cmd, error->message);
g_error_free (error);
dbus_g_method_return_error (context, error2);
g_error_free (error2);
g_free (cmd);
return FALSE;
}
g_free (cmd);
cmd = g_strconcat ("/sbin/service ", ntp_client, " ", using_ntp ? "restart" : "stop", NULL);;
if (!g_spawn_command_line_sync (cmd,
NULL, NULL, &exit_status, &error)) {
GError *error2;
error2 = g_error_new (GSD_DATETIME_MECHANISM_ERROR,
GSD_DATETIME_MECHANISM_ERROR_GENERAL,
"Error spawning '%s': %s", cmd, error->message);
g_error_free (error);
dbus_g_method_return_error (context, error2);
g_error_free (error2);
g_free (cmd);
return FALSE;
}
g_free (cmd);
dbus_g_method_return (context);
return TRUE;
}
gchar *get_partition_mount_point (const gchar *path)
{
g_message("[%s], path: %s\n", __func__, path);
gchar *mp = NULL;
gchar *swap_cmd = NULL;
gchar *swap_output = NULL;
gchar *cmd = NULL;
GError *error = NULL;
if (path == NULL || !g_file_test (path, G_FILE_TEST_EXISTS)) {
g_warning("[%s]: invalid path %s\n", __func__, path);
return mp;
}
swap_cmd = g_strdup_printf(
"sh -c \"cat /proc/swaps |grep %s |awk '{print $1}'\"", path);
g_spawn_command_line_sync (swap_cmd, &swap_output, NULL, NULL, &error);
if (error != NULL) {
g_warning("[%s]: run swap cmd error->%s, cmd: %s\n", __func__, cmd,
error->message);
g_error_free (error);
error = NULL;
}
g_free (swap_cmd);
if (swap_output != NULL && g_strcmp0(g_strstrip(swap_output), path) == 0) {
return g_strdup ("swap");
}
cmd = g_strdup_printf ("findmnt -k -f -n -o TARGET -S %s", path);
g_spawn_command_line_sync (cmd, &mp, NULL, NULL, &error);
if (error != NULL) {
g_warning("[%s] run cmd failed, %s, error: %s\n", __func__, cmd,
error->message);
g_error_free (error);
error = NULL;
}
g_free (cmd);
if (mp != NULL) {
mp = g_strstrip (mp);
if (g_strcmp0 (mp, "") == 0) {
g_free (mp);
return NULL;
}
}
return mp;
}
static void
remove_packages ()
{
extern gboolean in_chroot;
if (!in_chroot) {
g_warning ("remove packages:not in chroot\n");
return ;
}
GError *error = NULL;
gchar *cmd = NULL;
gchar *contents = NULL;
gchar **strarray = NULL;
gchar *packages = NULL;
if (!g_file_test (PACKAGES_LIST_PATH, G_FILE_TEST_EXISTS)) {
g_warning ("remove packages:%s not exists\n", PACKAGES_LIST_PATH);
goto out;
}
g_file_get_contents (PACKAGES_LIST_PATH, &contents, NULL, &error);
if (error != NULL) {
g_warning ("remove packages:get packages list %s\n", error->message);
goto out;
}
if (contents == NULL) {
g_warning ("remove packages:contents NULL\n");
goto out;
}
strarray = g_strsplit (contents, "\n", -1);
if (strarray == NULL) {
g_warning ("remove packages:strarray NULL\n");
goto out;
}
packages = g_strjoinv (" ", strarray);
if (packages == NULL) {
g_warning ("remove packages:packages NULL\n");
goto out;
}
if (g_file_test ("/var/lib/apt/lock", G_FILE_TEST_EXISTS)) {
g_unlink ("/var/lib/apt/lock");
}
cmd = g_strdup_printf ("apt-get remove -y %s", packages);
g_spawn_command_line_sync (cmd, NULL, NULL, NULL, &error);
if (error != NULL) {
g_warning ("remove packages:%s\n", error->message);
}
goto out;
out:
g_free (cmd);
g_free (contents);
g_strfreev (strarray);
g_free (packages);
if (error != NULL) {
g_error_free (error);
error = NULL;
}
}
static int
get_mode (void)
{
GError *error = NULL;
char *standard_output;
char *standard_error;
int exit_status;
int retval;
if (!bm.has_bm) {
return NORMAL_MODE;
}
if (g_spawn_command_line_sync ("/usr/sbin/boot-mode --status",
&standard_output,
&standard_error,
&exit_status,
&error)) {
retval = STARTSWITH (standard_output, "update") ? UPDATE_MODE : NORMAL_MODE;
}
g_free (standard_output);
g_free (standard_error);
if (error) {
g_error_free (error);
}
return retval;
}
char *
execute_lsof(pid_t pid) {
char *output = NULL;
char *lsof;
char *command;
int exit_status;
lsof = g_find_program_in_path("lsof");
if (lsof == NULL)
return NULL;
command = g_strdup_printf("%s -n -P -Fftn -p %d", lsof, pid);
g_free(lsof);
if (g_spawn_command_line_sync (command, &output, NULL, &exit_status, NULL)) {
if (exit_status != 0) {
g_warning("Could not execute \"%s\" (%i)", command,
exit_status);
output = NULL;
}
}
g_free(command);
return output;
}
static gboolean
is_master_supported (FlowSshMaster *ssh_master)
{
FlowSshMasterPrivate *priv = ssh_master->priv;
gchar *std_out = NULL;
gchar *err_out = NULL;
if (priv->checked_master_is_supported)
return priv->master_is_supported;
priv->master_is_supported = FALSE;
if (g_spawn_command_line_sync ("ssh -V", &std_out, &err_out, NULL, NULL))
{
gint major, minor;
if (err_out && sscanf (err_out, "OpenSSH_%d.%d", &major, &minor) == 2)
{
/* Require first version supporting ControlPersist */
if ((major == 5 && minor >= 6) || major > 5)
priv->master_is_supported = TRUE;
}
}
priv->checked_master_is_supported = TRUE;
g_free (std_out);
g_free (err_out);
return priv->master_is_supported;
}
static gboolean
is_master_working (FlowSshMaster *ssh_master)
{
FlowSshMasterPrivate *priv = ssh_master->priv;
gint exit_status = 255;
gchar *command;
gchar *std_out = NULL;
gchar *err_out = NULL;
if (priv->checked_master_is_working)
return priv->master_is_supported;
priv->master_is_supported = FALSE;
command = g_strdup_printf ("ssh -o 'ControlPath %s' -O check 0", priv->control_path);
g_spawn_command_line_sync (command, &std_out, &err_out, &exit_status, NULL);
g_free (command);
if (WIFEXITED (exit_status) && !WEXITSTATUS (exit_status))
priv->master_is_supported = TRUE;
g_free (std_out);
g_free (err_out);
priv->checked_master_is_working = TRUE;
return priv->master_is_supported;
}
static G_GNUC_UNUSED GSList *
get_available_spell_languages (void)
{
#ifdef HAVE_GTKSPELL
GSList *rv = NULL;
gchar *prgm, *cmd;
gchar *prgm_err, *prgm_out;
gint exit_status, i;
GError *err = NULL;
eSpellLanguage *lang;
gchar **lang_arr;
if ((prgm = g_find_program_in_path ("aspell")) == NULL)
return NULL;
cmd = g_strdup_printf ("%s dump dicts", prgm);
g_spawn_command_line_sync (cmd, &prgm_out, &prgm_err, &exit_status, &err);
g_free (cmd);
g_free (prgm);
if (err)
{
g_warning ("Failed to get language list: %s", err->message);
g_error_free (err);
return NULL;
}
if (exit_status != 0)
{
g_warning ("Failed to get language list, program output was: %s", prgm_err);
g_free (prgm_out);
g_free (prgm_err);
return NULL;
}
lang_arr = g_strsplit (prgm_out, "\n", -1);
i = 0;
while (lang_arr[i])
{
g_strstrip (lang_arr[i]);
if (*(lang_arr[i]) != '\0')
{
lang = g_new0 (eSpellLanguage, 1);
/* For now, set realname == label */
lang->realname = g_strdup (lang_arr[i]);
lang->label = g_strdup (lang_arr[i]);
rv = g_slist_insert_sorted (rv, lang, (GCompareFunc) g_str_equal);
}
i++;
}
g_strfreev (lang_arr);
lang = g_new0 (eSpellLanguage, 1);
/* Context: Spell check dictionary */
lang->label = g_strdup (_("System default"));
lang->realname = g_strdup ("");
rv = g_slist_prepend (rv, lang);
return rv;
#else
return NULL;
#endif /* HAVE_GTKSPELL */
}
void mkimg(const char *file, const char *fmt, unsigned size_mb)
{
gchar *cli;
bool ret;
int rc;
GError *err = NULL;
char *qemu_img_path;
gchar *out, *out2;
char *qemu_img_abs_path;
qemu_img_path = getenv("QTEST_QEMU_IMG");
g_assert(qemu_img_path);
qemu_img_abs_path = realpath(qemu_img_path, NULL);
g_assert(qemu_img_abs_path);
cli = g_strdup_printf("%s create -f %s %s %uM", qemu_img_abs_path,
fmt, file, size_mb);
ret = g_spawn_command_line_sync(cli, &out, &out2, &rc, &err);
if (err || !g_spawn_check_exit_status(rc, &err)) {
fprintf(stderr, "%s\n", err->message);
g_error_free(err);
}
g_assert(ret && !err);
g_free(out);
g_free(out2);
g_free(cli);
free(qemu_img_abs_path);
}
void switch_user(struct passwd *pw, const char *run, char **env)
{
int fd;
setenv("USER",pw->pw_name,1);
setenv("LOGNAME",pw->pw_name,1);
setenv("SHELL",pw->pw_shell,1);
setenv("HOME",pw->pw_dir,1);
g_spawn_command_line_sync ("/etc/lxdm/PreLogin",NULL,NULL,NULL,NULL);
if( !pw || initgroups(pw->pw_name, pw->pw_gid) ||
setgid(pw->pw_gid) || setuid(pw->pw_uid)/* || setsid() == -1 */)
exit(EXIT_FAILURE);
chdir(pw->pw_dir);
fd=open(".xsession-errors",O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR);
if(fd!=-1)
{
dup2(fd,STDERR_FILENO);
close(fd);
}
/* reset signal */
signal(SIGCHLD, SIG_DFL);
signal(SIGTERM, SIG_DFL);
signal(SIGPIPE, SIG_DFL);
signal(SIGALRM, SIG_DFL);
signal(SIGHUP, SIG_DFL);
close_left_fds();
g_spawn_command_line_async ("/etc/lxdm/PostLogin",NULL);
execl("/etc/lxdm/Xsession","/etc/lxdm/Xsession",run,NULL);
perror("execle");
exit(EXIT_FAILURE);
}
gboolean remmina_public_get_xauth_cookie(const gchar *display, gchar **msg)
{
gchar buf[200];
gchar *out = NULL;
gchar *ptr;
GError *error = NULL;
gboolean ret;
if (!display)
display = gdk_get_display();
g_snprintf(buf, sizeof(buf), "xauth list %s", display);
ret = g_spawn_command_line_sync(buf, &out, NULL, NULL, &error);
if (ret)
{
if ((ptr = g_strrstr(out, "MIT-MAGIC-COOKIE-1")) == NULL)
{
*msg = g_strdup_printf("xauth returns %s", out);
ret = FALSE;
}
else
{
ptr += 19;
while (*ptr == ' ')
ptr++;
*msg = g_strndup(ptr, 32);
}
g_free(out);
}
else
{
*msg = g_strdup(error->message);
}
return ret;
}
static inline void cleanup(domid_t cloneID, int vlan) {
char *command = g_malloc0(snprintf(NULL, 0, CLEANUP_CMD, cleanup_script, cloneID, vlan) + 1);
sprintf(command, CLEANUP_CMD, cleanup_script, cloneID, vlan);
printf("** RUNNING COMMAND: %s\n", command);
g_spawn_command_line_sync(command, NULL, NULL, NULL, NULL);
g_free(command);
}
/* Spawns a command synchonously.
* \param L The Lua VM state.
* \return The number of elements pushed on stack (3).
*/
static gint
luaH_luakit_spawn_sync(lua_State *L)
{
GError *e = NULL;
gchar *_stdout = NULL;
gchar *_stderr = NULL;
gint rv;
struct sigaction sigact;
struct sigaction oldact;
const gchar *command = luaL_checkstring(L, 1);
/* Note: we have to temporarily clear the SIGCHLD handler. Otherwise
* g_spawn_sync wouldn't be able to read subprocess' return value. */
sigact.sa_handler=SIG_DFL;
sigemptyset (&sigact.sa_mask);
if (sigaction(SIGCHLD, &sigact, &oldact))
fatal("Can't clear SIGCHLD handler");
g_spawn_command_line_sync(command, &_stdout, &_stderr, &rv, &e);
if (sigaction(SIGCHLD, &oldact, NULL))
fatal("Can't restore SIGCHLD handler");
if(e)
{
lua_pushstring(L, e->message);
g_clear_error(&e);
lua_error(L);
}
lua_pushinteger(L, WEXITSTATUS(rv));
lua_pushstring(L, _stdout);
lua_pushstring(L, _stderr);
g_free(_stdout);
g_free(_stderr);
return 3;
}
void
on_sigsegv (
G_GNUC_UNUSED int signum
)
{
#ifdef CONFIG_HAVE_BACKTRACE
void* array[256];
char** names;
char cmd[1024];
int i, size;
gchar *out, *err;
gint exit_status;
fprintf (stderr, "\n======= Backtrace: =========\n");
size = backtrace (array, G_N_ELEMENTS(array));
names = backtrace_symbols (array, size);
for (i = 0; i < size; i++)
fprintf (stderr, "%s\n", names[i]);
free (names);
fflush (stderr);
sprintf (cmd, "gdb --ex 'attach %ld' --ex 'info threads' --ex 'thread apply all bt' --batch", (long)getpid ());
if ( g_spawn_command_line_sync (cmd, &out, &err, &exit_status, NULL) )
{
fprintf (stderr, "======= GDB Backtrace: =========\n");
fprintf (stderr, "%s\n", out);
}
#endif /* CONFIG_HAVE_BACKTRACE */
abort ();
}
void CloseLiveBrowser(CefRefPtr<CefBrowser> browser, CefRefPtr<CefProcessMessage> response)
{
const char *killall = "killall -9 %s";
gchar *cmdline;
gint exitstatus;
GError *gerror = NULL;
int error = NO_ERROR;
CefRefPtr<CefListValue> responseArgs = response->GetArgumentList();
// check for supported browsers (in PATH directories)
for (size_t i = 0; i < sizeof(browsers) / sizeof(browsers[0]); i++) {
cmdline = g_strdup_printf(killall, browsers[i].c_str());
// FIXME (jasonsanjose): use async
if (!g_spawn_command_line_sync(cmdline, NULL, NULL, &exitstatus, &gerror)) {
error = ConvertGnomeErrorCode(gerror);
g_error_free(gerror);
}
g_free(cmdline);
// browser is found in os; stop iterating
if (exitstatus == 0) {
error = NO_ERROR;
break;
}
}
responseArgs->SetInt(1, error);
browser->SendProcessMessage(PID_RENDERER, response);
}
static void start_prepare_conf()
{
g_message("[%s]\n", __func__);
extern char* auto_conf_path;
if (auto_conf_path != NULL) {
GError* error = NULL;
char* cmd = g_strdup_printf("sh -c '[ %s -ef %s ] || cp -f %s %s'",
auto_conf_path, CONF_PATH,
auto_conf_path, CONF_PATH);
g_warning("%s\n", cmd);
int exit_code = 0;
g_spawn_command_line_sync(cmd, NULL, NULL, &exit_code, &error);
g_free(cmd);
if (error != NULL) {
//TODO: report error
g_warning("[%s] auto install mode failed: %s, cmd: %s", __func__,
error->message, cmd);
g_clear_error(&error);
installer_terminate();
return;
}
if (exit_code != 0) {
installer_terminate();
return;
}
} else {
if (InstallerConf.simple_mode && InstallerConf.uefi) {
auto_handle_esp();
}
write_installer_conf(CONF_PATH);
}
start_run_installer();
}
static void
conf_ensure_migrated (const gchar *name)
{
gboolean needed = TRUE;
GKeyFile *kf;
gchar **list;
gsize i, n;
kf = g_key_file_new ();
g_key_file_load_from_data_dirs (kf, "gsettings-data-convert",
NULL, G_KEY_FILE_NONE, NULL);
list = g_key_file_get_string_list (kf, "State", "converted", &n, NULL);
if (list) {
for (i = 0; i < n; i++) {
if (strcmp (list[i], name) == 0) {
needed = FALSE;
break;
}
}
g_strfreev (list);
}
g_key_file_free (kf);
if (needed)
g_spawn_command_line_sync ("gsettings-data-convert",
NULL, NULL, NULL, NULL);
}
static usbd *usb_get_device_list_lsusb() {
gboolean spawned;
gchar *out, *err, *p, *next_nl;
usbd *head = NULL, *nd;
int bus, dev, vend, prod, ec;
spawned = g_spawn_command_line_sync("lsusb",
&out, &err, NULL, NULL);
if (spawned) {
p = out;
while(next_nl = strchr(p, '\n')) {
strend(p, '\n');
ec = sscanf(p, "Bus %d Device %d: ID %x:%x", &bus, &dev, &vend, &prod);
if (ec == 4) {
nd = usb_get_device(bus, dev);
if (head == NULL) {
head = nd;
} else {
usbd_list_append(head, nd);
}
}
p = next_nl + 1;
}
g_free(out);
g_free(err);
}
return head;
}
static gboolean
_sync_hwclock (DBusGMethodInvocation *context)
{
GError *error;
error = NULL;
if (g_file_test ("/sbin/hwclock",
G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR | G_FILE_TEST_IS_EXECUTABLE)) {
int exit_status;
if (!g_spawn_command_line_sync ("/sbin/hwclock --systohc", NULL, NULL, &exit_status, &error)) {
GError *error2;
error2 = g_error_new (GSD_DATETIME_MECHANISM_ERROR,
GSD_DATETIME_MECHANISM_ERROR_GENERAL,
"Error spawning /sbin/hwclock: %s", error->message);
g_error_free (error);
dbus_g_method_return_error (context, error2);
g_error_free (error2);
return FALSE;
}
if (WEXITSTATUS (exit_status) != 0) {
error = g_error_new (GSD_DATETIME_MECHANISM_ERROR,
GSD_DATETIME_MECHANISM_ERROR_GENERAL,
"/sbin/hwclock returned %d", exit_status);
dbus_g_method_return_error (context, error);
g_error_free (error);
return FALSE;
}
}
return TRUE;
}
void
get_hal_version(FormatDialog* dialog)
{
gint hal_version = 0;
gchar** split = NULL;
gchar *output, *err;
gint status;
/* FIXME: This is hardcoded. This is bad. */
if(!g_spawn_command_line_sync("/usr/sbin/hald --version", &output, &err, &status, NULL))
goto out;
if(!output)
goto out;
split = g_strsplit_set(output, " .", 0 /*All tokens*/);
if(!split || !split[0])
goto out;
/* FIXME: Make this check more thorough */
if(!split[3] || !split[4] || !split[5] || !split[6])
goto out;
hal_version = atoi(split[3])*1000 + atoi(split[4])*100 + atoi(split[5])*10 + atoi(split[6]);
out:
if(split)
g_strfreev(split);
dialog->hal_version = hal_version;
}
static bool assert_rule(const char *table_name, const char *rule)
{
char *cmd, *output, **lines;
GError **error = NULL;
int i;
cmd = g_strdup_printf(IPTABLES_SAVE " -t %s", table_name);
g_spawn_command_line_sync(cmd, &output, NULL, NULL, error);
g_free(cmd);
lines = g_strsplit(output, "\n", 0);
g_free(output);
for (i = 0; lines[i]; i++) {
DBG("lines[%02d]: %s\n", i, lines[i]);
if (g_strcmp0(lines[i], rule) == 0)
break;
}
g_strfreev(lines);
if (!lines[i])
return false;
return true;
}
void menu_pipe_execute(ObMenu *self)
{
gchar *output;
GError *err = NULL;
if (!self->execute)
return;
if (self->entries) /* the entries are already created and cached */
return;
if (!g_spawn_command_line_sync(self->execute, &output, NULL, NULL, &err)) {
g_message(_("Failed to execute command for pipe-menu \"%s\": %s"),
self->execute, err->message);
g_error_free(err);
return;
}
if (obt_xml_load_mem(menu_parse_inst, output, strlen(output),
"openbox_pipe_menu"))
{
menu_parse_state.pipe_creator = self;
menu_parse_state.parent = self;
obt_xml_tree_from_root(menu_parse_inst);
obt_xml_close(menu_parse_inst);
} else {
g_message(_("Invalid output from pipe-menu \"%s\""), self->execute);
}
g_free(output);
}
