/** * file_plugin_proxy_load: * @filename. A file name to load. * @mode: Run mode. * @error: Return location for a #GError (or %NULL). * @name: Plug-in name (i.e. file-loading function) to run. * * The plug-in proxy itself, runs file-loading plug-in @name to load @filename. * * Returns: A newly created data container with the contents of @filename, * or %NULL if it fails. **/ static GwyContainer* file_plugin_proxy_load(const gchar *filename, GwyRunType mode, GError **error, const gchar *name) { FilePluginInfo *info; GwyContainer *data = NULL; GObject *dfield; gchar *tmpname = NULL, *buffer = NULL; GError *err = NULL; gint exit_status; gsize size = 0; FILE *fh; gchar *args[] = { NULL, NULL, NULL, NULL, NULL }; gboolean ok; gwy_debug("called as %s with file `%s'", name, filename); if (mode != GWY_RUN_INTERACTIVE) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_INTERACTIVE, _("Plugin-proxy must be run as interactive.")); return NULL; } if (!(info = file_find_plugin(name, GWY_FILE_OPERATION_LOAD))) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_UNIMPLEMENTED, _("Plug-in `%s' does not implement file loading."), name); return NULL; } if (!(fh = open_temporary_file(&tmpname, error))) return NULL; args[0] = info->file; args[1] = g_strdup(gwy_enum_to_string(GWY_FILE_OPERATION_LOAD, file_op_names, -1)); args[2] = tmpname; args[3] = decode_glib_encoded_filename(filename); gwy_debug("%s %s %s %s", args[0], args[1], args[2], args[3]); ok = g_spawn_sync(NULL, args, NULL, 0, NULL, NULL, NULL, NULL, &exit_status, &err); if (ok) { ok = g_file_get_contents(tmpname, &buffer, &size, &err); if (!ok) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_IO, _("Cannot read temporary file: %s."), err->message); g_clear_error(&err); } } else { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_SPECIFIC, _("Cannot execute plug-in `%s': %s."), name, err->message); g_clear_error(&err); } g_unlink(tmpname); fclose(fh); gwy_debug("ok = %d, exit_status = %d, err = %p", ok, exit_status, err); if (ok && exit_status) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_SPECIFIC, _("Plug-in `%s' returned non-zero exit status: %d."), name, exit_status); ok = FALSE; } if (ok) { data = text_dump_import(buffer, size, error); if (!data) ok = FALSE; } if (ok && (!gwy_container_gis_object_by_name(data, "/0/data", &dfield) || !GWY_IS_DATA_FIELD(dfield))) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Plug-in `%s' did not return any meaningful data."), name); gwy_object_unref(data); } g_free(args[1]); g_free(args[3]); g_free(buffer); g_free(tmpname); return data; }
void mex_screensaver_inhibit (MexScreensaver *self) { MexScreensaverPrivate *priv = MEX_SCREENSAVER (self)->priv; GDBusProxy *proxy; GError *error = NULL; GVariant *variant; /* If we're already inhibited don't inhibit again */ if (priv->cookie > 0) return; if (priv->gnome_version == -1) return; proxy = connect_gnome_screensaverd (self); if (!proxy) return; /* gnome_version will be 0 if the current version has not been determined */ if (priv->gnome_version == 0 || priv->gnome_version == 2) { if ((variant = g_dbus_proxy_call_sync (proxy, "Inhibit", g_variant_new ("(ss)", "Media Explorer", "Playing media"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error))) { priv->gnome_version = 2; g_variant_get (variant, "(u)", &priv->cookie); g_object_unref (proxy); g_variant_unref (variant); } else { if (error->domain == G_DBUS_ERROR && error->code == G_DBUS_ERROR_UNKNOWN_METHOD) { g_clear_error (&error); priv->gnome_version = 3; /* the current proxy is useless to us */ g_object_unref (proxy); proxy = NULL; } } } /* The code path may originate from the bail out on G_DBUS_ERROR_UNKNOWN_METHOD * or if the version has been set by a previous call of the inhibit function * which has worked out the version. */ if (priv->gnome_version == 3) { /* proxy maybe null if the proxy was a gnome 2 proxy */ if (!proxy) proxy = connect_gnome_screensaverd (self); /* 8 = GSM_INHIBITOR_FLAG_IDLE */ if ((variant = g_dbus_proxy_call_sync (proxy, "Inhibit", g_variant_new ("(susu)", "MediaExplorer", 0, "Playing media", 8), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error))) { priv->gnome_version = 3; g_variant_get (variant, "(u)", &priv->cookie); g_object_unref (proxy); g_variant_unref (variant); } else { if (error->domain == G_DBUS_ERROR && error->code == G_DBUS_ERROR_UNKNOWN_METHOD) { g_clear_error (&error); priv->gnome_version = -1; g_object_unref (proxy); proxy = NULL; } } } if (error) { g_warning ("Problem inhibiting screensaver: %s", error->message); g_error_free (error); } }
static gboolean notification_libnotify_add_msg(MsgInfo *msginfo, NotificationFolderType nftype) { gchar *summary; gchar *text; gboolean retval; NotificationPopup *ppopup; GdkPixbuf *pixbuf; ppopup = &(popup[nftype]); if(!ppopup->notification) return notification_libnotify_create(msginfo,nftype); ppopup->count++; if(ppopup->msg_path) { g_free(ppopup->msg_path); ppopup->msg_path = NULL; } /* make sure we show a logo on many msg arrival */ pixbuf = notification_pixbuf_get(NOTIFICATION_CM_LOGO_64x64); if(pixbuf) notify_notification_set_icon_from_pixbuf(ppopup->notification, pixbuf); switch(nftype) { case F_TYPE_MAIL: summary = _("Mail message"); text = g_strdup_printf(ngettext("%d new message arrived", "%d new messages arrived", ppopup->count), ppopup->count); break; case F_TYPE_NEWS: summary = _("News message"); text = g_strdup_printf(ngettext("%d new message arrived", "%d new messages arrived", ppopup->count), ppopup->count); break; case F_TYPE_CALENDAR: summary = _("Calendar message"); text = g_strdup_printf(ngettext("%d new calendar message arrived", "%d new calendar messages arrived", ppopup->count), ppopup->count); break; case F_TYPE_RSS: summary = _("RSS news feed"); text = g_strdup_printf(ngettext("%d new article in a RSS feed arrived", "%d new articles in a RSS feed arrived", ppopup->count), ppopup->count); break; default: /* Should not happen */ debug_print("Notification Plugin: Unknown folder type ignored\n"); return FALSE; } retval = notify_notification_update(ppopup->notification, summary, text, NULL); g_free(text); if(!retval) { debug_print("Notification Plugin: Failed to update notification.\n"); return FALSE; } /* Show the popup */ notify_notification_set_hint_string(ppopup->notification, "desktop-entry", "claws-mail"); if(!notify_notification_show(ppopup->notification, &(ppopup->error))) { debug_print("Notification Plugin: Failed to send updated notification: " "%s\n", ppopup->error->message); g_clear_error(&(ppopup->error)); return FALSE; } debug_print("Notification Plugin: Popup successfully modified " "with libnotify.\n"); return TRUE; }
int rpmostree_compose_builtin_tree (int argc, char **argv, GCancellable *cancellable, GError **error) { int exit_status = EXIT_FAILURE; GError *temp_error = NULL; GOptionContext *context = g_option_context_new ("TREEFILE - Run yum and commit the result to an OSTree repository"); RpmOstreeTreeComposeContext selfdata = { NULL, }; RpmOstreeTreeComposeContext *self = &selfdata; JsonNode *treefile_rootval = NULL; JsonObject *treefile = NULL; g_autofree char *cachekey = NULL; g_autofree char *new_inputhash = NULL; g_autoptr(GFile) previous_root = NULL; g_autofree char *previous_checksum = NULL; g_autoptr(GFile) yumroot = NULL; g_autoptr(GFile) yumroot_varcache = NULL; glnx_fd_close int rootfs_fd = -1; glnx_unref_object OstreeRepo *repo = NULL; g_autoptr(GPtrArray) bootstrap_packages = NULL; g_autoptr(GPtrArray) packages = NULL; g_autoptr(GFile) treefile_path = NULL; g_autoptr(GFile) treefile_dirpath = NULL; g_autoptr(GFile) repo_path = NULL; glnx_unref_object JsonParser *treefile_parser = NULL; gs_unref_variant_builder GVariantBuilder *metadata_builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); g_autoptr(RpmOstreeContext) corectx = NULL; g_autoptr(GHashTable) varsubsts = NULL; gboolean workdir_is_tmp = FALSE; g_autofree char *next_version = NULL; self->treefile_context_dirs = g_ptr_array_new_with_free_func ((GDestroyNotify)g_object_unref); if (!rpmostree_option_context_parse (context, option_entries, &argc, &argv, RPM_OSTREE_BUILTIN_FLAG_LOCAL_CMD, cancellable, NULL, error)) goto out; if (argc < 2) { rpmostree_usage_error (context, "TREEFILE must be specified", error); goto out; } if (!opt_repo) { rpmostree_usage_error (context, "--repo must be specified", error); goto out; } if (getuid () != 0) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "compose tree must presently be run as uid 0 (root)"); goto out; } /* Test whether or not bwrap is going to work - we will fail inside e.g. a Docker * container without --privileged or userns exposed. */ if (!rpmostree_bwrap_selftest (error)) goto out; repo_path = g_file_new_for_path (opt_repo); repo = self->repo = ostree_repo_new (repo_path); if (!ostree_repo_open (repo, cancellable, error)) goto out; treefile_path = g_file_new_for_path (argv[1]); if (opt_workdir) { self->workdir = g_file_new_for_path (opt_workdir); } else { g_autofree char *tmpd = NULL; if (!rpmostree_mkdtemp ("/var/tmp/rpm-ostree.XXXXXX", &tmpd, NULL, error)) goto out; self->workdir = g_file_new_for_path (tmpd); workdir_is_tmp = TRUE; if (opt_workdir_tmpfs) { if (mount ("tmpfs", tmpd, "tmpfs", 0, (const void*)"mode=755") != 0) { _rpmostree_set_prefix_error_from_errno (error, errno, "mount(tmpfs): "); goto out; } } } if (!glnx_opendirat (AT_FDCWD, gs_file_get_path_cached (self->workdir), FALSE, &self->workdir_dfd, error)) goto out; if (opt_cachedir) { if (!glnx_opendirat (AT_FDCWD, opt_cachedir, TRUE, &self->cachedir_dfd, error)) { g_prefix_error (error, "Opening cachedir '%s': ", opt_cachedir); goto out; } } else { self->cachedir_dfd = fcntl (self->workdir_dfd, F_DUPFD_CLOEXEC, 3); if (self->cachedir_dfd < 0) { glnx_set_error_from_errno (error); goto out; } } if (opt_metadata_strings) { if (!parse_keyvalue_strings (opt_metadata_strings, metadata_builder, error)) goto out; } if (fchdir (self->workdir_dfd) != 0) { glnx_set_error_from_errno (error); goto out; } corectx = rpmostree_context_new_compose (self->cachedir_dfd, cancellable, error); if (!corectx) goto out; varsubsts = rpmostree_context_get_varsubsts (corectx); treefile_parser = json_parser_new (); if (!json_parser_load_from_file (treefile_parser, gs_file_get_path_cached (treefile_path), error)) goto out; treefile_rootval = json_parser_get_root (treefile_parser); if (!JSON_NODE_HOLDS_OBJECT (treefile_rootval)) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Treefile root is not an object"); goto out; } treefile = json_node_get_object (treefile_rootval); if (!process_includes (self, treefile_path, 0, treefile, cancellable, error)) goto out; if (opt_print_only) { glnx_unref_object JsonGenerator *generator = json_generator_new (); g_autoptr(GOutputStream) stdout = g_unix_output_stream_new (1, FALSE); json_generator_set_pretty (generator, TRUE); json_generator_set_root (generator, treefile_rootval); (void) json_generator_to_stream (generator, stdout, NULL, NULL); exit_status = EXIT_SUCCESS; goto out; } { const char *input_ref = _rpmostree_jsonutil_object_require_string_member (treefile, "ref", error); if (!input_ref) goto out; self->ref = _rpmostree_varsubst_string (input_ref, varsubsts, error); if (!self->ref) goto out; } if (!ostree_repo_read_commit (repo, self->ref, &previous_root, &previous_checksum, cancellable, &temp_error)) { if (g_error_matches (temp_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) { g_clear_error (&temp_error); g_print ("No previous commit for %s\n", self->ref); } else { g_propagate_error (error, temp_error); goto out; } } else g_print ("Previous commit: %s\n", previous_checksum); self->previous_checksum = previous_checksum; yumroot = g_file_get_child (self->workdir, "rootfs.tmp"); if (!glnx_shutil_rm_rf_at (self->workdir_dfd, "rootfs.tmp", cancellable, error)) goto out; if (json_object_has_member (treefile, "automatic_version_prefix") && !compose_strv_contains_prefix (opt_metadata_strings, "version=")) { g_autoptr(GVariant) variant = NULL; g_autofree char *last_version = NULL; const char *ver_prefix; ver_prefix = _rpmostree_jsonutil_object_require_string_member (treefile, "automatic_version_prefix", error); if (!ver_prefix) goto out; if (previous_checksum) { if (!ostree_repo_load_variant (repo, OSTREE_OBJECT_TYPE_COMMIT, previous_checksum, &variant, error)) goto out; last_version = checksum_version (variant); } next_version = _rpmostree_util_next_version (ver_prefix, last_version); g_variant_builder_add (metadata_builder, "{sv}", "version", g_variant_new_string (next_version)); } bootstrap_packages = g_ptr_array_new (); packages = g_ptr_array_new (); if (json_object_has_member (treefile, "bootstrap_packages")) { if (!_rpmostree_jsonutil_append_string_array_to (treefile, "bootstrap_packages", packages, error)) goto out; } if (!_rpmostree_jsonutil_append_string_array_to (treefile, "packages", packages, error)) goto out; { g_autofree char *thisarch_packages = g_strconcat ("packages-", dnf_context_get_base_arch (rpmostree_context_get_hif (corectx)), NULL); if (json_object_has_member (treefile, thisarch_packages)) { if (!_rpmostree_jsonutil_append_string_array_to (treefile, thisarch_packages, packages, error)) goto out; } } g_ptr_array_add (packages, NULL); { glnx_unref_object JsonGenerator *generator = json_generator_new (); char *treefile_buf = NULL; gsize len; json_generator_set_root (generator, treefile_rootval); json_generator_set_pretty (generator, TRUE); treefile_buf = json_generator_to_data (generator, &len); self->serialized_treefile = g_bytes_new_take (treefile_buf, len); } treefile_dirpath = g_file_get_parent (treefile_path); if (TRUE) { gboolean generate_from_previous = TRUE; if (!_rpmostree_jsonutil_object_get_optional_boolean_member (treefile, "preserve-passwd", &generate_from_previous, error)) goto out; if (generate_from_previous) { if (!rpmostree_generate_passwd_from_previous (repo, yumroot, treefile_dirpath, previous_root, treefile, cancellable, error)) goto out; } } { gboolean unmodified = FALSE; if (!install_packages_in_root (self, corectx, treefile, yumroot, (char**)packages->pdata, opt_force_nocache ? NULL : &unmodified, &new_inputhash, cancellable, error)) goto out; if (unmodified) { g_print ("No apparent changes since previous commit; use --force-nocache to override\n"); exit_status = EXIT_SUCCESS; goto out; } else if (opt_dry_run) { g_print ("--dry-run complete, exiting\n"); exit_status = EXIT_SUCCESS; goto out; } } if (g_strcmp0 (g_getenv ("RPM_OSTREE_BREAK"), "post-yum") == 0) goto out; if (!glnx_opendirat (AT_FDCWD, gs_file_get_path_cached (yumroot), TRUE, &rootfs_fd, error)) goto out; if (!rpmostree_treefile_postprocessing (rootfs_fd, self->treefile_context_dirs->pdata[0], self->serialized_treefile, treefile, next_version, cancellable, error)) goto out; if (!rpmostree_prepare_rootfs_for_commit (yumroot, treefile, cancellable, error)) goto out; /* Reopen since the prepare renamed */ (void) close (rootfs_fd); if (!glnx_opendirat (AT_FDCWD, gs_file_get_path_cached (yumroot), TRUE, &rootfs_fd, error)) goto out; if (!rpmostree_copy_additional_files (yumroot, self->treefile_context_dirs->pdata[0], treefile, cancellable, error)) goto out; if (!rpmostree_check_passwd (repo, yumroot, treefile_dirpath, treefile, previous_checksum, cancellable, error)) goto out; if (!rpmostree_check_groups (repo, yumroot, treefile_dirpath, treefile, previous_checksum, cancellable, error)) goto out; { const char *gpgkey; gboolean selinux = TRUE; g_autoptr(GVariant) metadata = NULL; g_variant_builder_add (metadata_builder, "{sv}", "rpmostree.inputhash", g_variant_new_string (new_inputhash)); metadata = g_variant_ref_sink (g_variant_builder_end (metadata_builder)); if (!_rpmostree_jsonutil_object_get_optional_string_member (treefile, "gpg_key", &gpgkey, error)) goto out; if (!_rpmostree_jsonutil_object_get_optional_boolean_member (treefile, "selinux", &selinux, error)) goto out; { g_autofree char *new_revision = NULL; if (!rpmostree_commit (rootfs_fd, repo, self->ref, metadata, gpgkey, selinux, NULL, &new_revision, cancellable, error)) goto out; g_print ("%s => %s\n", self->ref, new_revision); } } if (opt_touch_if_changed) { gs_fd_close int fd = open (opt_touch_if_changed, O_CREAT|O_WRONLY|O_NOCTTY, 0644); if (fd == -1) { gs_set_error_from_errno (error, errno); g_prefix_error (error, "Updating '%s': ", opt_touch_if_changed); goto out; } if (futimens (fd, NULL) == -1) { gs_set_error_from_errno (error, errno); goto out; } } exit_status = EXIT_SUCCESS; out: /* Explicitly close this one now as it may have references to files * we delete below. */ g_clear_object (&corectx); /* Move back out of the workding directory to ensure unmount works */ (void )chdir ("/"); if (self->workdir_dfd != -1) (void) close (self->workdir_dfd); if (workdir_is_tmp) { if (opt_workdir_tmpfs) if (umount (gs_file_get_path_cached (self->workdir)) != 0) { fprintf (stderr, "warning: umount failed: %m\n"); } (void) gs_shutil_rm_rf (self->workdir, NULL, NULL); } if (self) { g_clear_object (&self->workdir); g_clear_pointer (&self->serialized_treefile, g_bytes_unref); g_ptr_array_unref (self->treefile_context_dirs); } return exit_status; }
gboolean ot_admin_builtin_status (int argc, char **argv, GCancellable *cancellable, GError **error) { GOptionContext *context; glnx_unref_object OstreeSysroot *sysroot = NULL; gboolean ret = FALSE; glnx_unref_object OstreeRepo *repo = NULL; OstreeDeployment *booted_deployment = NULL; g_autoptr(GPtrArray) deployments = NULL; guint i; context = g_option_context_new ("List deployments"); if (!ostree_admin_option_context_parse (context, options, &argc, &argv, OSTREE_ADMIN_BUILTIN_FLAG_NONE, &sysroot, cancellable, error)) goto out; if (!ostree_sysroot_load (sysroot, cancellable, error)) goto out; if (!ostree_sysroot_get_repo (sysroot, &repo, cancellable, error)) goto out; deployments = ostree_sysroot_get_deployments (sysroot); booted_deployment = ostree_sysroot_get_booted_deployment (sysroot); if (deployments->len == 0) { g_print ("No deployments.\n"); } else { for (i = 0; i < deployments->len; i++) { OstreeDeployment *deployment = deployments->pdata[i]; GKeyFile *origin; const char *ref = ostree_deployment_get_csum (deployment); g_autofree char *version = version_of_commit (repo, ref); glnx_unref_object OstreeGpgVerifyResult *result = NULL; GString *output_buffer; guint jj, n_signatures; GError *local_error = NULL; g_print ("%c %s %s.%d\n", deployment == booted_deployment ? '*' : ' ', ostree_deployment_get_osname (deployment), ostree_deployment_get_csum (deployment), ostree_deployment_get_deployserial (deployment)); if (version) g_print (" Version: %s\n", version); origin = ostree_deployment_get_origin (deployment); if (!origin) g_print (" origin: none\n"); else { g_autofree char *origin_refspec = g_key_file_get_string (origin, "origin", "refspec", NULL); if (!origin_refspec) g_print (" origin: <unknown origin type>\n"); else g_print (" origin refspec: %s\n", origin_refspec); } if (deployment_get_gpg_verify (deployment, repo)) { /* Print any digital signatures on this commit. */ result = ostree_repo_verify_commit_ext (repo, ref, NULL, NULL, cancellable, &local_error); /* G_IO_ERROR_NOT_FOUND just means the commit is not signed. */ if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) { g_clear_error (&local_error); continue; } else if (local_error != NULL) { g_propagate_error (error, local_error); goto out; } output_buffer = g_string_sized_new (256); n_signatures = ostree_gpg_verify_result_count_all (result); for (jj = 0; jj < n_signatures; jj++) { ostree_gpg_verify_result_describe (result, jj, output_buffer, " GPG: ", OSTREE_GPG_SIGNATURE_FORMAT_DEFAULT); } g_print ("%s", output_buffer->str); g_string_free (output_buffer, TRUE); } } } ret = TRUE; out: if (context) g_option_context_free (context); return ret; }
static gboolean cc_timezone_map_draw (GtkWidget *widget, cairo_t *cr) { CcTimezoneMapPrivate *priv = CC_TIMEZONE_MAP (widget)->priv; GdkPixbuf *hilight, *orig_hilight; GtkAllocation alloc; gchar *file; GError *err = NULL; gdouble pointx, pointy; char buf[16]; const char *fmt; gtk_widget_get_allocation (widget, &alloc); /* paint background */ gdk_cairo_set_source_pixbuf (cr, priv->background, 0, 0); cairo_paint (cr); /* paint hilight */ if (gtk_widget_is_sensitive (widget)) fmt = DATETIME_RESOURCE_PATH "/timezone_%s.png"; else fmt = DATETIME_RESOURCE_PATH "/timezone_%s_dim.png"; file = g_strdup_printf (fmt, g_ascii_formatd (buf, sizeof (buf), "%g", priv->selected_offset)); orig_hilight = gdk_pixbuf_new_from_resource (file, &err); g_free (file); file = NULL; if (!orig_hilight) { g_warning ("Could not load hilight: %s", (err) ? err->message : "Unknown Error"); if (err) g_clear_error (&err); } else { hilight = gdk_pixbuf_scale_simple (orig_hilight, alloc.width, alloc.height, GDK_INTERP_BILINEAR); gdk_cairo_set_source_pixbuf (cr, hilight, 0, 0); cairo_paint (cr); g_object_unref (hilight); g_object_unref (orig_hilight); } if (priv->location) { pointx = convert_longitude_to_x (priv->location->longitude, alloc.width); pointy = convert_latitude_to_y (priv->location->latitude, alloc.height); pointx = CLAMP (floor (pointx), 0, alloc.width); pointy = CLAMP (floor (pointy), 0, alloc.height); draw_text_bubble (cr, widget, pointx, pointy); if (priv->pin) { gdk_cairo_set_source_pixbuf (cr, priv->pin, pointx - PIN_HOT_POINT_X, pointy - PIN_HOT_POINT_Y); cairo_paint (cr); } } return TRUE; }
int main(int argc, char *argv[]) { signal_user_data_t *ud; GError *error = NULL; GOptionContext *context; hb_global_init(); #ifdef ENABLE_NLS bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR); bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); textdomain(GETTEXT_PACKAGE); #endif context = g_option_context_new(_("- Transcode media formats")); g_option_context_add_main_entries(context, entries, GETTEXT_PACKAGE); g_option_context_add_group(context, gtk_get_option_group(TRUE)); #if defined(_ENABLE_GST) g_option_context_add_group(context, gst_init_get_option_group()); #endif g_option_context_parse(context, &argc, &argv, &error); if (error != NULL) { g_warning("%s: %s", G_STRFUNC, error->message); g_clear_error(&error); } g_option_context_free(context); #if defined(_WIN32) if (win32_console) { // Enable console logging if(AttachConsole(ATTACH_PARENT_PROCESS) || AllocConsole()){ close(STDOUT_FILENO); freopen("CONOUT$", "w", stdout); close(STDERR_FILENO); freopen("CONOUT$", "w", stderr); } } else { // Non-console windows apps do not have a stderr->_file // assigned properly stderr->_file = STDERR_FILENO; stdout->_file = STDOUT_FILENO; } #endif if (argc > 1 && dvd_device == NULL && argv[1][0] != '-') { dvd_device = argv[1]; } gtk_init(&argc, &argv); GtkCssProvider *css = gtk_css_provider_new(); error = NULL; gtk_css_provider_load_from_data(css, MyCSS, -1, &error); if (error == NULL) { GdkScreen *ss = gdk_screen_get_default(); gtk_style_context_add_provider_for_screen(ss, GTK_STYLE_PROVIDER(css), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); } else { g_warning("%s: %s", G_STRFUNC, error->message); g_clear_error(&error); } #if !defined(_WIN32) notify_init("HandBrake"); #endif ghb_resource_init(); ghb_load_icons(); #if !defined(_WIN32) dbus_g_thread_init(); #endif ghb_udev_init(); ghb_write_pid_file(); ud = g_malloc0(sizeof(signal_user_data_t)); ud->debug = ghb_debug; g_log_set_handler(NULL, G_LOG_LEVEL_DEBUG, debug_log_handler, ud); g_log_set_handler("Gtk", G_LOG_LEVEL_WARNING, warn_log_handler, ud); //g_log_set_handler("Gtk", G_LOG_LEVEL_CRITICAL, warn_log_handler, ud); ud->globals = ghb_dict_new(); ud->prefs = ghb_dict_new(); ud->settings_array = ghb_array_new(); ud->settings = ghb_dict_new(); ghb_array_append(ud->settings_array, ud->settings); ud->builder = create_builder_or_die(BUILDER_NAME); // Enable events that alert us to media change events watch_volumes(ud); //GtkWidget *widget = GHB_WIDGET(ud->builder, "PictureDetelecineCustom"); //gtk_entry_set_inner_border(widget, 2); // Since GtkBuilder no longer assigns object ids to widget names // Assign a few that are necessary for style overrides to work GtkWidget *widget; #if defined(_NO_UPDATE_CHECK) widget = GHB_WIDGET(ud->builder, "check_updates_box"); gtk_widget_hide(widget); #endif // Must set the names of the widgets that I want to modify // style for. gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_hud"), "preview_hud"); gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_frame"), "preview_frame"); gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_preview_play"), "live_preview_play"); gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_preview_progress"), "live_preview_progress"); gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_encode_progress"), "live_encode_progress"); gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_duration"), "live_duration"); gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_show_crop"), "preview_show_crop"); gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_fullscreen"), "preview_fullscreen"); widget = GHB_WIDGET(ud->builder, "preview_hud"); gtk_widget_set_name(widget, "preview_hud"); widget = GHB_WIDGET(ud->builder, "preview_window"); gtk_widget_set_name(widget, "preview_window"); // Set up the "hud" control overlay for the preview window GtkWidget *preview_box, *draw, *hud, *blender; preview_box = GHB_WIDGET(ud->builder, "preview_window_box"); draw = GHB_WIDGET(ud->builder, "preview_image"); hud = GHB_WIDGET(ud->builder, "preview_hud"); #if 0 // GTK_CHECK_VERSION(3, 0, 0) // This uses the new GtkOverlay widget. // // Unfortunately, GtkOverlay is broken in a couple of ways. // // First, it doesn't respect gtk_widget_shape_combine_region() // on it's child overlays. It appears to just ignore the clip // mask of the child. // // Second, it doesn't respect window opacity. // // So for now, I'll just continue using my home-grown overlay // widget (GhbCompositor). blender = gtk_overlay_new(); gtk_container_add(GTK_CONTAINER(preview_box), blender); gtk_container_add(GTK_CONTAINER(blender), draw); gtk_widget_set_valign (hud, GTK_ALIGN_END); gtk_widget_set_halign (hud, GTK_ALIGN_CENTER); gtk_overlay_add_overlay(GTK_OVERLAY(blender), hud); g_signal_connect(G_OBJECT(blender), "get-child-position", G_CALLBACK(position_overlay_cb), ud); gtk_widget_show(blender); #else // Set up compositing for hud blender = ghb_compositor_new(); gtk_container_add(GTK_CONTAINER(preview_box), blender); ghb_compositor_zlist_insert(GHB_COMPOSITOR(blender), draw, 1, 1); ghb_compositor_zlist_insert(GHB_COMPOSITOR(blender), hud, 2, .85); gtk_widget_show(blender); #endif // Redirect stderr to the activity window ghb_preview_init(ud); IoRedirect(ud); ghb_log( "%s - %s - %s", HB_PROJECT_TITLE, HB_PROJECT_BUILD_TITLE, HB_PROJECT_URL_WEBSITE ); ghb_init_dep_map(); // Need to connect x264_options textview buffer to the changed signal // since it can't be done automatically GtkTextView *textview; GtkTextBuffer *buffer; textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "x264Option")); buffer = gtk_text_view_get_buffer(textview); g_signal_connect(buffer, "changed", (GCallback)x264_entry_changed_cb, ud); textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "VideoOptionExtra")); buffer = gtk_text_view_get_buffer(textview); g_signal_connect(buffer, "changed", (GCallback)video_option_changed_cb, ud); textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "MetaLongDescription")); buffer = gtk_text_view_get_buffer(textview); g_signal_connect(buffer, "changed", (GCallback)plot_changed_cb, ud); ghb_combo_init(ud); g_debug("ud %p\n", ud); g_debug("ud->builder %p\n", ud->builder); bind_audio_tree_model(ud); bind_subtitle_tree_model(ud); bind_presets_tree_model(ud); bind_queue_tree_model(ud); bind_chapter_tree_model(ud); // Connect up the signals to their callbacks // I wrote my own connector so that I could pass user data // to the callbacks. Builder's standard autoconnect doesn't all this. gtk_builder_connect_signals_full(ud->builder, MyConnect, ud); ghb_init_audio_defaults_ui(ud); ghb_init_subtitle_defaults_ui(ud); // Parsing x264 options "" initializes x264 widgets to proper defaults ghb_x264_init(ud); // Load prefs before presets. Some preset defaults may depend // on preference settings. // First load default values ghb_settings_init(ud->prefs, "Preferences"); ghb_settings_init(ud->globals, "Globals"); ghb_settings_init(ud->settings, "Initialization"); ghb_settings_init(ud->settings, "OneTimeInitialization"); // Load user preferences file ghb_prefs_load(ud); // Store user preferences into ud->prefs ghb_prefs_to_settings(ud->prefs); int logLevel = ghb_dict_get_int(ud->prefs, "LoggingLevel"); ghb_backend_init(logLevel); // Load the presets files ghb_presets_load(ud); // Note that ghb_preset_to_settings(ud->settings) is called when // the default preset is selected. ghb_settings_to_ui(ud, ud->globals); ghb_settings_to_ui(ud, ud->prefs); // Note that ghb_settings_to_ui(ud->settings) happens when initial // empty title is initialized. if (ghb_dict_get_bool(ud->prefs, "hbfd")) { ghb_hbfd(ud, TRUE); } const gchar *source = ghb_dict_get_string(ud->prefs, "default_source"); ghb_dvd_set_current(source, ud); // Populate the presets tree view ghb_presets_list_init(ud, NULL); // Get the first preset name if (arg_preset != NULL) { ghb_select_preset(ud->builder, arg_preset); } else { ghb_select_default_preset(ud->builder); } // Grey out widgets that are dependent on a disabled feature ghb_check_all_depencencies(ud); if (dvd_device != NULL) { // Source overridden from command line option ghb_dict_set_string(ud->globals, "scan_source", dvd_device); g_idle_add((GSourceFunc)ghb_idle_scan, ud); } else { GhbValue *gval = ghb_dict_get_value(ud->prefs, "default_source"); ghb_dict_set(ud->globals, "scan_source", ghb_value_dup(gval)); } // Reload and check status of the last saved queue g_idle_add((GSourceFunc)ghb_reload_queue, ud); // Start timer for monitoring libhb status, 500ms g_timeout_add(200, ghb_timer_cb, (gpointer)ud); // Add dvd devices to File menu ghb_volname_cache_init(); GHB_THREAD_NEW("Cache Volume Names", (GThreadFunc)ghb_cache_volnames, ud); GtkWidget *ghb_window = GHB_WIDGET(ud->builder, "hb_window"); gint window_width, window_height; GdkGeometry geo = { -1, -1, 1920, 768, -1, -1, 10, 10, 0, 0, GDK_GRAVITY_NORTH_WEST }; GdkWindowHints geo_mask; geo_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_BASE_SIZE; gtk_window_set_geometry_hints(GTK_WINDOW(ghb_window), ghb_window, &geo, geo_mask); window_width = ghb_dict_get_int(ud->prefs, "window_width"); window_height = ghb_dict_get_int(ud->prefs, "window_height"); /* * Filter objects in GtkBuilder xml * Unfortunately, GtkFilter is poorly supported by GtkBuilder, * so a lot of the setup must happen in code. SourceFilterAll SourceFilterVideo SourceFilterTS SourceFilterMPG SourceFilterEVO SourceFilterVOB SourceFilterMKV SourceFilterMP4 SourceFilterAVI SourceFilterMOV SourceFilterOGG SourceFilterFLV SourceFilterWMV */ // Add filters to source chooser GtkFileFilter *filter; GtkFileChooser *chooser; chooser = GTK_FILE_CHOOSER(GHB_WIDGET(ud->builder, "source_dialog")); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll")); gtk_file_filter_set_name(filter, _("All")); gtk_file_filter_add_pattern(filter, "*"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVideo")); gtk_file_filter_set_name(filter, _("Video")); gtk_file_filter_add_mime_type(filter, "video/*"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterTS")); gtk_file_filter_set_name(filter, "TS"); gtk_file_filter_add_pattern(filter, "*.ts"); gtk_file_filter_add_pattern(filter, "*.TS"); gtk_file_filter_add_pattern(filter, "*.m2ts"); gtk_file_filter_add_pattern(filter, "*.M2TS"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMPG")); gtk_file_filter_set_name(filter, "MPG"); gtk_file_filter_add_pattern(filter, "*.mpg"); gtk_file_filter_add_pattern(filter, "*.MPG"); gtk_file_filter_add_pattern(filter, "*.mepg"); gtk_file_filter_add_pattern(filter, "*.MEPG"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterEVO")); gtk_file_filter_set_name(filter, "EVO"); gtk_file_filter_add_pattern(filter, "*.evo"); gtk_file_filter_add_pattern(filter, "*.EVO"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVOB")); gtk_file_filter_set_name(filter, "VOB"); gtk_file_filter_add_pattern(filter, "*.vob"); gtk_file_filter_add_pattern(filter, "*.VOB"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMKV")); gtk_file_filter_set_name(filter, "MKV"); gtk_file_filter_add_pattern(filter, "*.mkv"); gtk_file_filter_add_pattern(filter, "*.MKV"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMP4")); gtk_file_filter_set_name(filter, "MP4"); gtk_file_filter_add_pattern(filter, "*.mp4"); gtk_file_filter_add_pattern(filter, "*.MP4"); gtk_file_filter_add_pattern(filter, "*.m4v"); gtk_file_filter_add_pattern(filter, "*.M4V"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMOV")); gtk_file_filter_set_name(filter, "MOV"); gtk_file_filter_add_pattern(filter, "*.mov"); gtk_file_filter_add_pattern(filter, "*.MOV"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAVI")); gtk_file_filter_set_name(filter, "AVI"); gtk_file_filter_add_pattern(filter, "*.avi"); gtk_file_filter_add_pattern(filter, "*.AVI"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterOGG")); gtk_file_filter_set_name(filter, "OGG"); gtk_file_filter_add_pattern(filter, "*.ogg"); gtk_file_filter_add_pattern(filter, "*.OGG"); gtk_file_filter_add_pattern(filter, "*.ogv"); gtk_file_filter_add_pattern(filter, "*.OGV"); gtk_file_filter_add_pattern(filter, "*.ogm"); gtk_file_filter_add_pattern(filter, "*.OGM"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterFLV")); gtk_file_filter_set_name(filter, "FLV"); gtk_file_filter_add_pattern(filter, "*.flv"); gtk_file_filter_add_pattern(filter, "*.FLV"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterWMV")); gtk_file_filter_set_name(filter, "WMV"); gtk_file_filter_add_pattern(filter, "*.wmv"); gtk_file_filter_add_pattern(filter, "*.WMV"); gtk_file_chooser_add_filter(chooser, filter); // Gtk has a really stupid bug. If the file chooser is showing // hidden files AND there is no filter set, it will not select // the filename when gtk_file_chooser_set_filename is called. // So add a completely unnessary filter to prevent this behavior. filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll")); gtk_file_chooser_set_filter(chooser, filter); PangoFontDescription *font_desc; font_desc = pango_font_description_from_string("monospace 10"); textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "activity_view")); gtk_widget_override_font(GTK_WIDGET(textview), font_desc); pango_font_description_free(font_desc); // Grrrr! Gtk developers !!!hard coded!!! the width of the // radio buttons in GtkStackSwitcher to 100!!! // // Thankfully, GtkStackSwitcher is a regular container object // and we can access the buttons to change their width. GList *stack_switcher_children, *link; GtkContainer * stack_switcher = GTK_CONTAINER( GHB_WIDGET(ud->builder, "SettingsStackSwitcher")); link = stack_switcher_children = gtk_container_get_children(stack_switcher); while (link != NULL) { GtkWidget *widget = link->data; gtk_widget_set_size_request(widget, -1, -1); gtk_widget_set_hexpand(widget, TRUE); gtk_widget_set_halign(widget, GTK_ALIGN_FILL); link = link->next; } g_list_free(stack_switcher_children); gtk_window_resize(GTK_WINDOW(ghb_window), window_width, window_height); gtk_widget_show(ghb_window); // Everything should be go-to-go. Lets rock! gtk_main(); ghb_backend_close(); ghb_value_free(&ud->queue); ghb_value_free(&ud->settings_array); ghb_value_free(&ud->prefs); ghb_value_free(&ud->globals); ghb_value_free(&ud->x264_priv); g_io_channel_unref(ud->activity_log); ghb_settings_close(); ghb_resource_free(); #if !defined(_WIN32) notify_uninit(); #endif g_object_unref(ud->builder); g_free(ud->current_dvd_device); g_free(ud); return 0; }
static gboolean gimp_unique_dbus_open (const gchar **filenames, gboolean as_new) { #ifndef GIMP_CONSOLE_COMPILATION /* for the DBus service names */ #include "gui/gimpdbusservice.h" GDBusConnection *connection; GError *error = NULL; connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error); if (connection) { gboolean success = TRUE; if (filenames) { const gchar *method = as_new ? "OpenAsNew" : "Open"; gchar *cwd = g_get_current_dir (); gint i; for (i = 0; filenames[i] && success; i++) { GError *error = NULL; gchar *uri = gimp_unique_filename_to_uri (filenames[i], cwd, &error); if (uri) { GVariant *result; result = g_dbus_connection_call_sync (connection, GIMP_DBUS_SERVICE_NAME, GIMP_DBUS_SERVICE_PATH, GIMP_DBUS_INTERFACE_NAME, method, g_variant_new ("(s)", uri), NULL, G_DBUS_CALL_FLAGS_NO_AUTO_START, -1, NULL, NULL); if (result) g_variant_unref (result); else success = FALSE; g_free (uri); } else { g_printerr ("conversion to uri failed: %s\n", error->message); g_clear_error (&error); } } g_free (cwd); } else { GVariant *result; result = g_dbus_connection_call_sync (connection, GIMP_DBUS_SERVICE_NAME, GIMP_DBUS_SERVICE_PATH, GIMP_DBUS_INTERFACE_NAME, "Activate", NULL, NULL, G_DBUS_CALL_FLAGS_NO_AUTO_START, -1, NULL, NULL); if (result) g_variant_unref (result); else success = FALSE; } g_object_unref (connection); return success; } else { g_printerr ("%s\n", error->message); g_clear_error (&error); } #endif return FALSE; }
int main (int argc, char **argv) { GstBus *bus; GOptionContext *ctx; GIOChannel *io_stdin; GError *err = NULL; gboolean res; GOptionEntry options[] = { {NULL} }; GThread *rthread; /* Clear application state */ memset (state, 0, sizeof (*state)); state->animate = TRUE; state->current_buffer = NULL; state->caps = NULL; #if !GLIB_CHECK_VERSION (2, 31, 0) /* must initialise the threading system before using any other GLib funtion */ if (!g_thread_supported ()) g_thread_init (NULL); #endif ctx = g_option_context_new ("[ADDITIONAL ARGUMENTS]"); g_option_context_add_main_entries (ctx, options, NULL); g_option_context_add_group (ctx, gst_init_get_option_group ()); if (!g_option_context_parse (ctx, &argc, &argv, &err)) { g_print ("Error initializing: %s\n", GST_STR_NULL (err->message)); g_option_context_free (ctx); g_clear_error (&err); exit (1); } g_option_context_free (ctx); if (argc != 2) { g_print ("Usage: %s <URI> or <PIPELINE-DESCRIPTION>\n", argv[0]); exit (1); } /* Initialize GStreamer */ gst_init (&argc, &argv); /* initialize inter thread comunnication */ init_intercom (state); TRACE_VC_MEMORY ("state 0"); if (!(rthread = g_thread_new ("render", (GThreadFunc) render_func, NULL))) { g_print ("Render thread create failed\n"); exit (1); } /* Initialize player */ if (gst_uri_is_valid (argv[1])) { res = init_playbin_player (state, argv[1]); } else { res = init_parse_launch_player (state, argv[1]); } if (!res) goto done; /* Create a GLib Main Loop and set it to run */ state->main_loop = g_main_loop_new (NULL, FALSE); /* Add a keyboard watch so we get notified of keystrokes */ io_stdin = g_io_channel_unix_new (fileno (stdin)); g_io_add_watch (io_stdin, G_IO_IN, (GIOFunc) handle_keyboard, state); g_io_channel_unref (io_stdin); /* *INDENT-OFF* */ g_print ("Available commands: \n" " a - Toggle animation \n" " p - Pause playback \n" " r - Resume playback \n" " l - Query position/duration\n" " f - Seek 30 seconds forward \n" " b - Seek 30 seconds backward \n" " q - Quit \n"); /* *INDENT-ON* */ /* Connect the bus handlers */ bus = gst_element_get_bus (state->pipeline); gst_bus_set_sync_handler (bus, (GstBusSyncHandler) bus_sync_handler, state, NULL); gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH); gst_bus_enable_sync_message_emission (bus); g_signal_connect (G_OBJECT (bus), "message::error", (GCallback) error_cb, state); g_signal_connect (G_OBJECT (bus), "message::buffering", (GCallback) buffering_cb, state); g_signal_connect (G_OBJECT (bus), "message::eos", (GCallback) eos_cb, state); g_signal_connect (G_OBJECT (bus), "message::qos", (GCallback) qos_cb, state); g_signal_connect (G_OBJECT (bus), "message::state-changed", (GCallback) state_changed_cb, state); gst_object_unref (bus); /* Make player start playing */ gst_element_set_state (state->pipeline, GST_STATE_PLAYING); /* Start the mainloop */ state->main_loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (state->main_loop); done: /* Release pipeline */ if (state->pipeline) { gst_element_set_state (state->pipeline, GST_STATE_NULL); if (state->vsink) { gst_object_unref (state->vsink); state->vsink = NULL; } gst_object_unref (state->pipeline); } /* Unref the mainloop */ if (state->main_loop) { g_main_loop_unref (state->main_loop); } /* Stop rendering thread */ state->running = FALSE; g_thread_join (rthread); if (state->caps) { gst_caps_unref (state->caps); state->caps = NULL; } terminate_intercom (state); TRACE_VC_MEMORY ("at exit"); return 0; }
void daemon_data_sqlite_data_LogMessageEvent (DaemonDataSqliteData* self, DaemonEventsMessageEvent* event, GError** error) { gchar* _tmp0_; gchar* commandText; sqlite3_stmt* statement = NULL; sqlite3_stmt* _tmp1_ = NULL; const gchar* _tmp2_ = NULL; gchar* _tmp3_; const gchar* _tmp4_ = NULL; gchar* _tmp5_; const gchar* _tmp6_ = NULL; gchar* _tmp7_; const gchar* _tmp8_ = NULL; gchar* _tmp9_; gint64 _tmp10_; gint _tmp11_; GError * _inner_error_ = NULL; g_return_if_fail (self != NULL); g_return_if_fail (event != NULL); _tmp0_ = g_strdup ("INSERT INTO Log (Username, Data, Channel, Server, Timestamp, Type) VAL" \ "UES (@1, @2, @3, @4, @5, @6)"); commandText = _tmp0_; sqlite3_prepare_v2 (self->priv->_database, commandText, -1, &_tmp1_, NULL); _sqlite3_finalize0 (statement); statement = _tmp1_; _tmp2_ = daemon_events_log_event_get_Username ((DaemonEventsLogEvent*) event); _tmp3_ = g_strdup (_tmp2_); sqlite3_bind_text (statement, 1, _tmp3_, -1, g_free); _tmp4_ = daemon_events_message_event_get_Message (event); _tmp5_ = g_strdup (_tmp4_); sqlite3_bind_text (statement, 2, _tmp5_, -1, g_free); _tmp6_ = daemon_events_log_event_get_Channel ((DaemonEventsLogEvent*) event); _tmp7_ = g_strdup (_tmp6_); sqlite3_bind_text (statement, 3, _tmp7_, -1, g_free); _tmp8_ = daemon_events_log_event_get_Server ((DaemonEventsLogEvent*) event); _tmp9_ = g_strdup (_tmp8_); sqlite3_bind_text (statement, 4, _tmp9_, -1, g_free); _tmp10_ = daemon_events_log_event_get_UnixTimestamp ((DaemonEventsLogEvent*) event); sqlite3_bind_int64 (statement, 5, _tmp10_); sqlite3_bind_int (statement, 6, (gint) DAEMON_DATA_EVENT_TYPES_Message); _tmp11_ = sqlite3_step (statement); if (_tmp11_ != SQLITE_DONE) { const gchar* _tmp12_ = NULL; GError* _tmp13_ = NULL; _tmp12_ = sqlite3_errmsg (self->priv->_database); _tmp13_ = g_error_new_literal (DAEMON_DATA_DATA_ACCESS_ERROR, DAEMON_DATA_DATA_ACCESS_ERROR_WriteError, _tmp12_); _inner_error_ = _tmp13_; if (_inner_error_->domain == DAEMON_DATA_DATA_ACCESS_ERROR) { g_propagate_error (error, _inner_error_); _sqlite3_finalize0 (statement); _g_free0 (commandText); return; } else { _sqlite3_finalize0 (statement); _g_free0 (commandText); g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); g_clear_error (&_inner_error_); return; } } _sqlite3_finalize0 (statement); _g_free0 (commandText); }
static GList* daemon_data_sqlite_data_real_GetLog (DaemonDataIDataAccess* base, const gchar* channel, const gchar* server, GError** error) { DaemonDataSqliteData * self; GList* result = NULL; gchar* _tmp0_; gchar* commandText; sqlite3_stmt* statement = NULL; sqlite3_stmt* _tmp1_ = NULL; gchar* _tmp2_; gchar* _tmp3_; gint _result_; GList* results; GError * _inner_error_ = NULL; self = (DaemonDataSqliteData*) base; g_return_val_if_fail (channel != NULL, NULL); g_return_val_if_fail (server != NULL, NULL); _tmp0_ = g_strdup ("SELECT * FROM Log WHERE Channel = @1 AND Server = @2 ORDER BY Timestam" \ "p DESC LIMIT 50"); commandText = _tmp0_; sqlite3_prepare_v2 (self->priv->_database, commandText, -1, &_tmp1_, NULL); _sqlite3_finalize0 (statement); statement = _tmp1_; _tmp2_ = g_strdup (channel); sqlite3_bind_text (statement, 1, _tmp2_, -1, g_free); _tmp3_ = g_strdup (server); sqlite3_bind_text (statement, 2, _tmp3_, -1, g_free); _result_ = 0; results = NULL; { gboolean _tmp4_; _tmp4_ = TRUE; while (TRUE) { gint _tmp5_; if (!_tmp4_) { if (!(_result_ == SQLITE_ROW)) { break; } } _tmp4_ = FALSE; _tmp5_ = sqlite3_step (statement); _result_ = _tmp5_; switch (_result_) { case SQLITE_DONE: { { break; } } case SQLITE_ROW: { { const gchar* _tmp6_ = NULL; gchar* _tmp7_; gchar* username; const gchar* _tmp8_ = NULL; gchar* _tmp9_; gchar* data; const gchar* _tmp10_ = NULL; gchar* _tmp11_; gchar* eventChannel; const gchar* _tmp12_ = NULL; gchar* _tmp13_; gchar* eventServer; gint64 _tmp14_; GDateTime* _tmp15_ = NULL; GDateTime* timestamp; gint _tmp16_; DaemonDataEventTypes type; DaemonEventsLogEvent* current; DaemonEventsLogEvent* _tmp21_; _tmp6_ = sqlite3_column_text (statement, 0); _tmp7_ = g_strdup (_tmp6_); username = _tmp7_; _tmp8_ = sqlite3_column_text (statement, 1); _tmp9_ = g_strdup (_tmp8_); data = _tmp9_; _tmp10_ = sqlite3_column_text (statement, 2); _tmp11_ = g_strdup (_tmp10_); eventChannel = _tmp11_; _tmp12_ = sqlite3_column_text (statement, 3); _tmp13_ = g_strdup (_tmp12_); eventServer = _tmp13_; _tmp14_ = sqlite3_column_int64 (statement, 4); _tmp15_ = daemon_helpers_date_time_converter_FromUnixTimestamp (_tmp14_); timestamp = _tmp15_; _tmp16_ = sqlite3_column_int (statement, 5); type = (DaemonDataEventTypes) _tmp16_; current = NULL; switch (type) { case DAEMON_DATA_EVENT_TYPES_Joined: { { DaemonEventsStatusEvent* _tmp17_ = NULL; _tmp17_ = daemon_events_status_event_new_WithTimestamp (username, DAEMON_EVENTS_STATUS_CHANGE_Join, eventChannel, eventServer, timestamp); _g_object_unref0 (current); current = (DaemonEventsLogEvent*) _tmp17_; break; } } case DAEMON_DATA_EVENT_TYPES_Left: { { DaemonEventsStatusEvent* _tmp18_ = NULL; _tmp18_ = daemon_events_status_event_new_WithTimestamp (username, DAEMON_EVENTS_STATUS_CHANGE_Leave, eventChannel, eventServer, timestamp); _g_object_unref0 (current); current = (DaemonEventsLogEvent*) _tmp18_; break; } } case DAEMON_DATA_EVENT_TYPES_ChangedName: { { DaemonEventsChangeNameEvent* _tmp19_ = NULL; _tmp19_ = daemon_events_change_name_event_new_WithTimestamp (username, data, eventChannel, eventServer, timestamp); _g_object_unref0 (current); current = (DaemonEventsLogEvent*) _tmp19_; break; } } case DAEMON_DATA_EVENT_TYPES_Message: { { DaemonEventsMessageEvent* _tmp20_ = NULL; _tmp20_ = daemon_events_message_event_new_WithTimestamp (username, data, eventChannel, eventServer, timestamp); _g_object_unref0 (current); current = (DaemonEventsLogEvent*) _tmp20_; break; } } default: break; } _tmp21_ = _g_object_ref0 (current); results = g_list_append (results, _tmp21_); _g_object_unref0 (current); _g_date_time_unref0 (timestamp); _g_free0 (eventServer); _g_free0 (eventChannel); _g_free0 (data); _g_free0 (username); break; } } default: { { const gchar* _tmp22_ = NULL; GError* _tmp23_ = NULL; _tmp22_ = sqlite3_errmsg (self->priv->_database); _tmp23_ = g_error_new_literal (DAEMON_DATA_DATA_ACCESS_ERROR, DAEMON_DATA_DATA_ACCESS_ERROR_ReadError, _tmp22_); _inner_error_ = _tmp23_; if (_inner_error_->domain == DAEMON_DATA_DATA_ACCESS_ERROR) { g_propagate_error (error, _inner_error_); __g_list_free__g_object_unref0_0 (results); _sqlite3_finalize0 (statement); _g_free0 (commandText); return NULL; } else { __g_list_free__g_object_unref0_0 (results); _sqlite3_finalize0 (statement); _g_free0 (commandText); g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); g_clear_error (&_inner_error_); return NULL; } } } } } } result = results; _sqlite3_finalize0 (statement); _g_free0 (commandText); return result; }
/* set up server */ static gboolean gst_tcp_server_src_start (GstBaseSrc * bsrc) { GstTCPServerSrc *src = GST_TCP_SERVER_SRC (bsrc); GError *err = NULL; GInetAddress *addr; GSocketAddress *saddr; GResolver *resolver; /* look up name if we need to */ addr = g_inet_address_new_from_string (src->host); if (!addr) { GList *results; resolver = g_resolver_get_default (); results = g_resolver_lookup_by_name (resolver, src->host, src->cancellable, &err); if (!results) goto name_resolve; addr = G_INET_ADDRESS (g_object_ref (results->data)); g_resolver_free_addresses (results); g_object_unref (resolver); } #ifndef GST_DISABLE_GST_DEBUG { gchar *ip = g_inet_address_to_string (addr); GST_DEBUG_OBJECT (src, "IP address for host %s is %s", src->host, ip); g_free (ip); } #endif saddr = g_inet_socket_address_new (addr, src->server_port); g_object_unref (addr); /* create the server listener socket */ src->server_socket = g_socket_new (g_socket_address_get_family (saddr), G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, &err); if (!src->server_socket) goto no_socket; GST_DEBUG_OBJECT (src, "opened receiving server socket"); /* bind it */ GST_DEBUG_OBJECT (src, "binding server socket to address"); if (!g_socket_bind (src->server_socket, saddr, TRUE, &err)) goto bind_failed; g_object_unref (saddr); GST_DEBUG_OBJECT (src, "listening on server socket"); g_socket_set_listen_backlog (src->server_socket, TCP_BACKLOG); if (!g_socket_listen (src->server_socket, &err)) goto listen_failed; GST_OBJECT_FLAG_SET (src, GST_TCP_SERVER_SRC_OPEN); return TRUE; /* ERRORS */ no_socket: { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Failed to create socket: %s", err->message)); g_clear_error (&err); g_object_unref (saddr); return FALSE; } name_resolve: { if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { GST_DEBUG_OBJECT (src, "Cancelled name resolval"); } else { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Failed to resolve host '%s': %s", src->host, err->message)); } g_clear_error (&err); g_object_unref (resolver); return FALSE; } bind_failed: { if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { GST_DEBUG_OBJECT (src, "Cancelled binding"); } else { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Failed to bind on host '%s:%d': %s", src->host, src->server_port, err->message)); } g_clear_error (&err); g_object_unref (saddr); gst_tcp_server_src_stop (GST_BASE_SRC (src)); return FALSE; } listen_failed: { if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { GST_DEBUG_OBJECT (src, "Cancelled listening"); } else { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Failed to listen on host '%s:%d': %s", src->host, src->server_port, err->message)); } g_clear_error (&err); gst_tcp_server_src_stop (GST_BASE_SRC (src)); return FALSE; } }
static GstFlowReturn gst_tcp_server_src_create (GstPushSrc * psrc, GstBuffer ** outbuf) { GstTCPServerSrc *src; GstFlowReturn ret = GST_FLOW_OK; gssize rret, avail; gsize read; GError *err = NULL; GstMapInfo map; src = GST_TCP_SERVER_SRC (psrc); if (!GST_OBJECT_FLAG_IS_SET (src, GST_TCP_SERVER_SRC_OPEN)) goto wrong_state; if (!src->client_socket) { /* wait on server socket for connections */ src->client_socket = g_socket_accept (src->server_socket, src->cancellable, &err); if (!src->client_socket) goto accept_error; /* now read from the socket. */ } /* if we have a client, wait for read */ GST_LOG_OBJECT (src, "asked for a buffer"); /* read the buffer header */ avail = g_socket_get_available_bytes (src->client_socket); if (avail < 0) { goto get_available_error; } else if (avail == 0) { GIOCondition condition; if (!g_socket_condition_wait (src->client_socket, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP, src->cancellable, &err)) goto select_error; condition = g_socket_condition_check (src->client_socket, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP); if ((condition & G_IO_ERR)) { GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Socket in error state")); *outbuf = NULL; ret = GST_FLOW_ERROR; goto done; } else if ((condition & G_IO_HUP)) { GST_DEBUG_OBJECT (src, "Connection closed"); *outbuf = NULL; ret = GST_FLOW_EOS; goto done; } avail = g_socket_get_available_bytes (src->client_socket); if (avail < 0) goto get_available_error; } if (avail > 0) { read = MIN (avail, MAX_READ_SIZE); *outbuf = gst_buffer_new_and_alloc (read); gst_buffer_map (*outbuf, &map, GST_MAP_READWRITE); rret = g_socket_receive (src->client_socket, (gchar *) map.data, read, src->cancellable, &err); } else { /* Connection closed */ rret = 0; *outbuf = NULL; read = 0; } if (rret == 0) { GST_DEBUG_OBJECT (src, "Connection closed"); ret = GST_FLOW_EOS; if (*outbuf) { gst_buffer_unmap (*outbuf, &map); gst_buffer_unref (*outbuf); } *outbuf = NULL; } else if (rret < 0) { if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { ret = GST_FLOW_FLUSHING; GST_DEBUG_OBJECT (src, "Cancelled reading from socket"); } else { ret = GST_FLOW_ERROR; GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Failed to read from socket: %s", err->message)); } gst_buffer_unmap (*outbuf, &map); gst_buffer_unref (*outbuf); *outbuf = NULL; } else { ret = GST_FLOW_OK; gst_buffer_unmap (*outbuf, &map); gst_buffer_resize (*outbuf, 0, rret); GST_LOG_OBJECT (src, "Returning buffer from _get of size %" G_GSIZE_FORMAT ", ts %" GST_TIME_FORMAT ", dur %" GST_TIME_FORMAT ", offset %" G_GINT64_FORMAT ", offset_end %" G_GINT64_FORMAT, gst_buffer_get_size (*outbuf), GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (*outbuf)), GST_TIME_ARGS (GST_BUFFER_DURATION (*outbuf)), GST_BUFFER_OFFSET (*outbuf), GST_BUFFER_OFFSET_END (*outbuf)); } g_clear_error (&err); done: return ret; wrong_state: { GST_DEBUG_OBJECT (src, "connection to closed, cannot read data"); return GST_FLOW_FLUSHING; } accept_error: { if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { GST_DEBUG_OBJECT (src, "Cancelled accepting of client"); } else { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Failed to accept client: %s", err->message)); } g_clear_error (&err); return GST_FLOW_ERROR; } select_error: { GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Select failed: %s", err->message)); g_clear_error (&err); return GST_FLOW_ERROR; } get_available_error: { GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Failed to get available bytes from socket")); return GST_FLOW_ERROR; } }
/** * file_plugin_proxy_export: * @data: A data container to save. * @filename: A file name to save @data to. * @mode: Run mode. * @error: Return location for a #GError (or %NULL). * @name: Plug-in name (i.e. file-saving function) to run. * * The plug-in proxy itself, runs file-saving plug-in @name to save @filename. * * Returns: Whether it succeeded saving the data. **/ static gboolean file_plugin_proxy_export(GwyContainer *data, const gchar *filename, GwyRunType mode, GError **error, const gchar *name) { FilePluginInfo *info; gchar *tmpname = NULL; GError *err = NULL; gint exit_status; FILE *fh; gchar *args[] = { NULL, NULL, NULL, NULL, NULL }; GQuark dquark, mquark; gboolean ok; gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD_KEY, &dquark, GWY_APP_MASK_FIELD_KEY, &mquark, 0); gwy_debug("called as %s with file `%s'", name, filename); if (mode != GWY_RUN_INTERACTIVE) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_INTERACTIVE, _("Plugin-proxy must be run as interactive.")); return FALSE; } if (!(info = file_find_plugin(name, GWY_FILE_OPERATION_EXPORT))) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_UNIMPLEMENTED, _("Plug-in `%s' does not implement file saving."), name); return FALSE; } fh = text_dump_export(data, dquark, mquark, &tmpname, error); if (!fh) return FALSE; args[0] = info->file; args[1] = g_strdup(gwy_enum_to_string(GWY_FILE_OPERATION_EXPORT, file_op_names, -1)); args[2] = tmpname; args[3] = decode_glib_encoded_filename(filename); gwy_debug("%s %s %s %s", args[0], args[1], args[2], args[3]); ok = g_spawn_sync(NULL, args, NULL, 0, NULL, NULL, NULL, NULL, &exit_status, &err); if (!ok) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_SPECIFIC, _("Cannot execute plug-in `%s': %s."), name, err->message); g_clear_error(&err); } g_unlink(tmpname); fclose(fh); gwy_debug("ok = %d, exit_status = %d, err = %p", ok, exit_status, err); if (ok && exit_status) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_SPECIFIC, _("Plug-in `%s' returned non-zero exit status: %d."), name, exit_status); ok = FALSE; } g_free(args[1]); g_free(args[3]); g_free(tmpname); return ok; }
static void stroke_dialog_response (GtkWidget *widget, gint response_id, GtkWidget *dialog) { GimpStrokeOptions *options; GimpItem *item; GimpImage *image; GimpContext *context; GtkWidget *combo; item = g_object_get_data (G_OBJECT (dialog), "gimp-item"); options = g_object_get_data (G_OBJECT (dialog), "gimp-stroke-options"); combo = g_object_get_data (G_OBJECT (dialog), "gimp-tool-menu"); image = gimp_item_get_image (item); context = GIMP_VIEWABLE_DIALOG (dialog)->context; switch (response_id) { case RESPONSE_RESET: { GimpToolInfo *tool_info = gimp_context_get_tool (context); gimp_config_reset (GIMP_CONFIG (options)); gimp_container_view_select_item (GIMP_CONTAINER_VIEW (combo), GIMP_VIEWABLE (tool_info->paint_info)); } break; case GTK_RESPONSE_OK: { GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpStrokeOptions *saved_options; GError *error = NULL; if (! drawable) { gimp_message_literal (context->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING, _("There is no active layer or channel " "to stroke to.")); return; } saved_options = g_object_get_data (G_OBJECT (context->gimp), "saved-stroke-options"); if (saved_options) g_object_ref (saved_options); else saved_options = gimp_stroke_options_new (context->gimp, context, TRUE); gimp_config_sync (G_OBJECT (options), G_OBJECT (saved_options), 0); g_object_set_data_full (G_OBJECT (context->gimp), "saved-stroke-options", saved_options, (GDestroyNotify) g_object_unref); if (! gimp_item_stroke (item, drawable, context, options, NULL, TRUE, NULL, &error)) { gimp_message_literal (context->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING, error ? error->message : "NULL"); g_clear_error (&error); return; } gimp_image_flush (image); } /* fallthrough */ default: gtk_widget_destroy (dialog); break; } }
static void load_httpserver_config (SeafileSession *session) { GError *error = NULL; char *host = NULL; int port = 0; int max_upload_size_mb; int max_download_dir_size_mb; host = g_key_file_get_string (session->config, "httpserver", "host", &error); if (!error) { bind_addr = host; } else { if (error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND && error->code != G_KEY_FILE_ERROR_GROUP_NOT_FOUND) { seaf_warning ("[conf] Error: failed to read the value of 'host'\n"); exit (1); } bind_addr = DEFAULT_BIND_HOST; g_clear_error (&error); } port = g_key_file_get_integer (session->config, "httpserver", "port", &error); if (!error) { bind_port = port; } else { if (error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND && error->code != G_KEY_FILE_ERROR_GROUP_NOT_FOUND) { seaf_warning ("[conf] Error: failed to read the value of 'port'\n"); exit (1); } bind_port = DEFAULT_BIND_PORT; g_clear_error (&error); } use_https = g_key_file_get_boolean (session->config, "httpserver", "https", &error); if (error) { if (error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND && error->code != G_KEY_FILE_ERROR_GROUP_NOT_FOUND) { seaf_warning ("[conf] Error: failed to read the value of 'https'\n"); exit (1); } /* There is no <https> field in seafile.conf, so we use http. */ g_clear_error (&error); } else if (use_https) { /* read https config */ pemfile = g_key_file_get_string (session->config, "httpserver", "pemfile", &error); if (error) { seaf_warning ("[conf] Error: https is true, " "but the value of pemfile is unknown\n"); exit (1); } privkey = g_key_file_get_string (session->config, "httpserver", "privkey", &error); if (error) { seaf_warning ("[conf] Error: https is true, " "but the value of privkey is unknown\n"); exit (1); } } max_upload_size_mb = g_key_file_get_integer (session->config, "httpserver", "max_upload_size", &error); if (error) { session->max_upload_size = -1; /* no limit */ g_clear_error (&error); } else { if (max_upload_size_mb <= 0) session->max_upload_size = -1; /* no limit */ else session->max_upload_size = max_upload_size_mb * ((gint64)1 << 20); } max_download_dir_size_mb = g_key_file_get_integer (session->config, "httpserver", "max_download_dir_size", &error); if (error) { session->max_download_dir_size = DEFAULT_MAX_DOWNLOAD_DIR_SIZE; g_clear_error (&error); } else { if (max_download_dir_size_mb <= 0) session->max_download_dir_size = DEFAULT_MAX_DOWNLOAD_DIR_SIZE; else session->max_download_dir_size = max_download_dir_size_mb * ((gint64)1 << 20); } }
static void cc_privacy_panel_init (CcPrivacyPanel *self) { GError *error; GtkWidget *widget; GtkWidget *frame; guint res; self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, CC_TYPE_PRIVACY_PANEL, CcPrivacyPanelPrivate); g_resources_register (cc_privacy_get_resource ()); self->priv->cancellable = g_cancellable_new (); self->priv->builder = gtk_builder_new (); error = NULL; res = gtk_builder_add_from_resource (self->priv->builder, "/org/gnome/control-center/privacy/privacy.ui", &error); if (res == 0) { g_warning ("Could not load interface file: %s", (error != NULL) ? error->message : "unknown error"); g_clear_error (&error); return; } self->priv->recent_dialog = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "recent_dialog")); self->priv->screen_lock_dialog = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "screen_lock_dialog")); self->priv->location_dialog = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "location_dialog")); self->priv->trash_dialog = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "trash_dialog")); self->priv->software_dialog = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "software_dialog")); self->priv->abrt_dialog = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "abrt_dialog")); frame = WID ("frame"); widget = gtk_list_box_new (); gtk_list_box_set_selection_mode (GTK_LIST_BOX (widget), GTK_SELECTION_NONE); gtk_container_add (GTK_CONTAINER (frame), widget); self->priv->list_box = widget; gtk_widget_show (widget); self->priv->location_apps_list_box = WID ("location_apps_list_box"); gtk_list_box_set_header_func (GTK_LIST_BOX (self->priv->location_apps_list_box), cc_list_box_update_header_func, NULL, NULL); self->priv->location_apps_frame = WID ("location_apps_frame"); self->priv->location_apps_label = WID ("location_apps_label"); self->priv->location_icon_size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH); g_signal_connect_swapped (widget, "row-activated", G_CALLBACK (activate_row), self); gtk_list_box_set_header_func (GTK_LIST_BOX (widget), cc_list_box_update_header_func, NULL, NULL); self->priv->lockdown_settings = g_settings_new ("org.gnome.desktop.lockdown"); self->priv->lock_settings = g_settings_new ("org.gnome.desktop.screensaver"); self->priv->privacy_settings = g_settings_new ("org.gnome.desktop.privacy"); self->priv->notification_settings = g_settings_new ("org.gnome.desktop.notifications"); self->priv->location_settings = g_settings_new ("org.gnome.system.location"); add_screen_lock (self); add_location (self); add_usage_history (self); add_trash_temp (self); add_software (self); add_abrt (self); g_signal_connect (self->priv->lockdown_settings, "changed", G_CALLBACK (on_lockdown_settings_changed), self); update_lock_screen_sensitivity (self); widget = WID ("privacy_vbox"); gtk_container_add (GTK_CONTAINER (self), widget); }
static gboolean clutter_backend_real_create_context (ClutterBackend *backend, GError **error) { GError *internal_error = NULL; const char *drivers_list; char **known_drivers; gboolean allow_any; int i; if (allowed_drivers == NULL) allowed_drivers = CLUTTER_DRIVERS; allow_any = strstr (allowed_drivers, "*") != NULL; drivers_list = g_getenv ("CLUTTER_DRIVER"); if (drivers_list == NULL) drivers_list = allowed_drivers; known_drivers = g_strsplit (drivers_list, ",", 0); for (i = 0; backend->cogl_context == NULL && known_drivers[i] != NULL; i++) { const char *driver_name = known_drivers[i]; gboolean is_any = g_str_equal (driver_name, "*"); int j; for (j = 0; j < G_N_ELEMENTS (all_known_drivers); j++) { if (!allow_any && !is_any && !strstr (driver_name, all_known_drivers[j].driver_name)) continue; if ((allow_any && is_any) || (is_any && strstr (allowed_drivers, all_known_drivers[j].driver_name)) || g_str_equal (all_known_drivers[j].driver_name, driver_name)) { CLUTTER_NOTE (BACKEND, "Checking for the %s driver", all_known_drivers[j].driver_desc); if (clutter_backend_do_real_create_context (backend, all_known_drivers[j].driver_id, &internal_error)) break; if (internal_error) { CLUTTER_NOTE (BACKEND, "Unable to use the %s driver: %s", all_known_drivers[j].driver_desc, internal_error->message); g_clear_error (&internal_error); } } } } g_strfreev (known_drivers); if (backend->cogl_context == NULL) { if (internal_error != NULL) g_propagate_error (error, internal_error); else g_set_error_literal (error, CLUTTER_INIT_ERROR, CLUTTER_INIT_ERROR_BACKEND, _("Unable to initialize the Clutter backend: no available drivers found.")); return FALSE; } backend->cogl_source = cogl_glib_source_new (backend->cogl_context, G_PRIORITY_DEFAULT); g_source_attach (backend->cogl_source, NULL); return TRUE; }
static void seahorse_generate_select_constructed (GObject *obj) { SeahorseGenerateSelect *self = SEAHORSE_GENERATE_SELECT (obj); gchar *text; GtkCellRenderer *pixcell; GtkTreeSelection *selection; GtkTreeIter iter; GList *actions; GList *l, *k; GIcon *icon; GtkBuilder *builder; const gchar *path; GError *error = NULL; const gchar *icon_name; GtkAction *action; G_OBJECT_CLASS (seahorse_generate_select_parent_class)->constructed (obj); self->store = gtk_list_store_new (COLUMN_N_COLUMNS, G_TYPE_ICON, G_TYPE_STRING, GTK_TYPE_ACTION); gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (self->store), on_list_sort, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING); self->action_groups = seahorse_registry_object_instances ("generator"); for (l = self->action_groups; l != NULL; l = g_list_next (l)) { actions = gtk_action_group_list_actions (l->data); for (k = actions; k != NULL; k = g_list_next (k)) { action = k->data; text = g_strdup_printf (TEMPLATE, gtk_action_get_label (action), gtk_action_get_tooltip (action)); icon = gtk_action_get_gicon (action); if (icon == NULL) { icon_name = gtk_action_get_icon_name (action); if (icon_name) icon = g_themed_icon_new (icon_name); gtk_action_get_stock_id (action); } else { g_object_ref (icon); } gtk_list_store_append (self->store, &iter); gtk_list_store_set (self->store, &iter, COLUMN_TEXT, text, COLUMN_ICON, icon, COLUMN_ACTION, k->data, -1); g_clear_object (&icon); } g_list_free (actions); } builder = gtk_builder_new (); path = "/org/gnome/Seahorse/seahorse-generate-select.xml"; gtk_builder_add_from_resource (builder, path, &error); if (error != NULL) { g_warning ("couldn't load ui file: %s", path); g_clear_error (&error); g_object_unref (builder); return; } /* Setup the dialog */ gtk_window_set_modal (GTK_WINDOW (self), TRUE); gtk_window_set_default_size (GTK_WINDOW (self), -1, 410); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), GTK_WIDGET (gtk_builder_get_object (builder, "generate-select")), TRUE, TRUE, 0); gtk_dialog_add_buttons (GTK_DIALOG (self), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("Continue"), GTK_RESPONSE_OK, NULL); /* Hook it into the view */ self->view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "keytype-tree")); g_object_unref (builder); pixcell = gtk_cell_renderer_pixbuf_new (); g_object_set (pixcell, "stock-size", GTK_ICON_SIZE_DND, NULL); gtk_tree_view_insert_column_with_attributes (self->view, -1, "", pixcell, "gicon", COLUMN_ICON, NULL); gtk_tree_view_insert_column_with_attributes (self->view, -1, "", gtk_cell_renderer_text_new (), "markup", COLUMN_TEXT, NULL); gtk_tree_view_set_model (self->view, GTK_TREE_MODEL (self->store)); /* Setup selection, select first item */ selection = gtk_tree_view_get_selection (self->view); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->store), &iter); gtk_tree_selection_select_iter (selection, &iter); g_signal_connect (self->view, "row-activated", G_CALLBACK (on_row_activated), self); g_object_set (self->view, "height-request", 410, NULL); g_signal_connect (self, "response", G_CALLBACK (on_response), self); }
/** * @test */ void test_file_permissions(void) { char filename[MAXPATHLEN] = "/tmp/permsXXXXXX"; int fd; int ret; GError *gerr = NULL; g_log_set_always_fatal(G_LOG_FATAL_MASK); /* 1st test: non-existent file */ g_assert_cmpint(chassis_filemode_check_full("/tmp/a_non_existent_file", CHASSIS_FILEMODE_SECURE_MASK, &gerr), ==, -1); g_assert_cmpint(gerr->code, ==, G_FILE_ERROR_NOENT); g_clear_error(&gerr); fd = mkstemp(filename); if (fd < 0) { g_critical("%s: mkstemp(%s) failed: %s (%d)", G_STRLOC, filename, g_strerror(errno), errno); } g_assert_cmpint(fd, >=, 0); /* 2nd test: too permissive */ ret = chmod(filename, TOO_OPEN); if (ret < 0) { g_critical("%s: chmod(%s) failed: %s (%d)", G_STRLOC, filename, g_strerror(errno), errno); } g_assert_cmpint(ret, ==, 0); g_assert_cmpint(chassis_filemode_check_full(filename, CHASSIS_FILEMODE_SECURE_MASK, &gerr), ==, 1); g_assert_cmpint(gerr->code, ==, G_FILE_ERROR_PERM); g_clear_error(&gerr); /* 3rd test: OK */ ret = chmod(filename, GOOD_PERMS); if (ret < 0) { g_critical("%s: chmod(%s) failed: %s (%d)", G_STRLOC, filename, g_strerror(errno), errno); } g_assert_cmpint(ret, ==, 0); g_assert_cmpint(chassis_filemode_check_full(filename, CHASSIS_FILEMODE_SECURE_MASK, &gerr), ==, 0); g_assert(gerr == NULL); /* 4th test: non-regular file */ close(fd); remove(filename); ret = mkdir(filename, GOOD_PERMS); if (ret < 0) { g_critical("%s: mkdir(%s) failed: %s (%d)", G_STRLOC, filename, g_strerror(errno), errno); } g_assert_cmpint(ret, ==, 0); g_assert_cmpint(chassis_filemode_check_full(filename, CHASSIS_FILEMODE_SECURE_MASK, &gerr), ==, -1); g_assert_cmpint(gerr->code, ==, G_FILE_ERROR_INVAL); g_clear_error(&gerr); /* clean up */ ret = rmdir(filename); if (ret < 0) { g_critical("%s: rmdir(%s) failed: %s (%d)", G_STRLOC, filename, g_strerror(errno), errno); } g_assert_cmpint(ret, ==, 0); }
// it will always return FALSE gboolean socket_fault(int type, GError *error, GIOChannel *channel, gboolean unref) { #ifdef DETAIL g_debug("! Launch socket_fault() to show the error message !"); #endif #ifdef UNIT_TEST # define G_WARNING g_message #else # define G_WARNING g_warning #endif switch (type) { case 1: G_WARNING("Error when create %s socket(%s): %s", PACKAGE, address.sun_path, g_strerror (errno)); break; case 2: g_message("Can NOT connect to a existing %s socket!", PACKAGE); break; case 3: G_WARNING("Can NOT bind on the socket!"); break; case 4: G_WARNING("Can NOT listen on the socket!"); break; case 5: G_WARNING("Can not watch on the socket!"); break; case 6: G_WARNING("Error when accepting client request via socket!"); break; case 7: G_WARNING("Error when reading the data client sent via socket!"); break; case 8: G_WARNING("Error when running fcntl command on socket!"); break; case 9: #ifdef SAFEMODE if (error) #endif G_WARNING("Error when setting the encoding of channel: %s", error->message); break; case 10: #ifdef SAFEMODE if (error) #endif G_WARNING("Error when shutdowning a channel: %s", error->message); break; case 11: #ifdef SAFEMODE if (error) #endif G_WARNING("Error when writing data to the channel: %s", error->message); break; case 12: G_WARNING("Can NOT create a channel for this socket"); break; case 13: #ifdef SAFEMODE if (error) #endif G_WARNING("Error when flushing the write buffer for the channel: %s", error->message); break; case 14: G_WARNING("Got a NULL string from the socket!"); break; default: #ifdef FATAL print_switch_out_of_range_error_dialog("socket_fault", "type", type); #endif break; } if (error) g_clear_error (&error); clear_channel(channel, unref); #ifdef UNIT_TEST # undef G_WARNING #endif return FALSE; }
gboolean ostree_create_temp_file_from_input (GFile *dir, const char *prefix, const char *suffix, GFileInfo *finfo, GVariant *xattrs, GInputStream *input, GFile **out_file, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; GError *temp_error = NULL; int i = 0; ot_lfree char *possible_name = NULL; ot_lobj GFile *possible_file = NULL; ot_lfree guchar *ret_csum = NULL; GString *tmp_name = NULL; tmp_name = create_tmp_string (ot_gfile_get_path_cached (dir), prefix, suffix); /* 128 attempts seems reasonable... */ for (i = 0; i < 128; i++) { if (g_cancellable_set_error_if_cancelled (cancellable, error)) goto out; g_free (possible_name); possible_name = subst_xxxxxx (tmp_name->str); g_clear_object (&possible_file); possible_file = g_file_get_child (dir, possible_name); if (!ostree_create_file_from_input (possible_file, finfo, xattrs, input, cancellable, &temp_error)) { if (g_error_matches (temp_error, G_IO_ERROR, G_IO_ERROR_EXISTS)) { g_clear_error (&temp_error); continue; } else { g_propagate_error (error, temp_error); goto out; } } else { break; } } if (i >= 128) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Exhausted 128 attempts to create a temporary file"); goto out; } ret = TRUE; ot_transfer_out_value(out_file, &possible_file); out: if (tmp_name) g_string_free (tmp_name, TRUE); return ret; }
GeeList* rygel_media_export_dynamic_container_get_uris (RygelMediaExportDynamicContainer* self) { #line 132 "rygel-media-export-dynamic-container.c" GeeList* result = NULL; GError * _inner_error_; GeeArrayList* _result_; #line 31 "rygel-media-export-dynamic-container.vala" g_return_val_if_fail (self != NULL, NULL); #line 138 "rygel-media-export-dynamic-container.c" _inner_error_ = NULL; #line 32 "rygel-media-export-dynamic-container.vala" _result_ = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL); #line 142 "rygel-media-export-dynamic-container.c" { GeeArrayList* children; #line 35 "rygel-media-export-dynamic-container.vala" children = rygel_media_export_media_cache_get_children (((RygelMediaExportDBContainer*) self)->media_db, ((RygelMediaObject*) self)->id, (glong) (-1), (glong) (-1), &_inner_error_); #line 147 "rygel-media-export-dynamic-container.c" if (_inner_error_ != NULL) { goto __catch15_g_error; } #line 36 "rygel-media-export-dynamic-container.vala" if (children != NULL) { #line 153 "rygel-media-export-dynamic-container.c" { GeeIterator* _child_it; _child_it = gee_abstract_collection_iterator ((GeeAbstractCollection*) children); #line 37 "rygel-media-export-dynamic-container.vala" while (TRUE) { #line 159 "rygel-media-export-dynamic-container.c" RygelMediaObject* child; #line 37 "rygel-media-export-dynamic-container.vala" if (!gee_iterator_next (_child_it)) { #line 37 "rygel-media-export-dynamic-container.vala" break; #line 165 "rygel-media-export-dynamic-container.c" } #line 37 "rygel-media-export-dynamic-container.vala" child = (RygelMediaObject*) gee_iterator_get (_child_it); #line 38 "rygel-media-export-dynamic-container.vala" gee_abstract_collection_add_all ((GeeAbstractCollection*) _result_, (GeeCollection*) child->uris); #line 171 "rygel-media-export-dynamic-container.c" _g_object_unref0 (child); } _g_object_unref0 (_child_it); } } _g_object_unref0 (children); } goto __finally15; __catch15_g_error: { GError * err; err = _inner_error_; _inner_error_ = NULL; { _g_error_free0 (err); } } __finally15: if (_inner_error_ != NULL) { _g_object_unref0 (_result_); g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); g_clear_error (&_inner_error_); return NULL; } result = (GeeList*) _result_; #line 43 "rygel-media-export-dynamic-container.vala" return result; #line 199 "rygel-media-export-dynamic-container.c" }
static gboolean spawn_x_server (State *state, gboolean allow_remote_connections, GCancellable *cancellable) { GPtrArray *arguments = NULL; GSubprocessLauncher *launcher = NULL; GSubprocess *subprocess = NULL; GInputStream *input_stream = NULL; GDataInputStream *data_stream = NULL; GError *error = NULL; char *auth_file; gboolean is_running = FALSE; int ret; int pipe_fds[2]; char *display_fd_string = NULL; char *vt_string = NULL; char *display_number; gsize display_number_size; auth_file = prepare_auth_file (); g_debug ("Running X server"); ret = g_unix_open_pipe (pipe_fds, FD_CLOEXEC, &error); if (!ret) { g_debug ("could not open pipe: %s", error->message); goto out; } arguments = g_ptr_array_new (); launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDIN_INHERIT); g_subprocess_launcher_setenv (launcher, "XORG_RUN_AS_USER_OK", "1", TRUE); g_subprocess_launcher_take_fd (launcher, pipe_fds[1], DISPLAY_FILENO); if (g_getenv ("XDG_VTNR") != NULL) { int vt; vt = atoi (g_getenv ("XDG_VTNR")); if (vt > 0 && vt < 64) { vt_string = g_strdup_printf ("vt%d", vt); } } display_fd_string = g_strdup_printf ("%d", DISPLAY_FILENO); g_ptr_array_add (arguments, X_SERVER); if (vt_string != NULL) { g_ptr_array_add (arguments, vt_string); } g_ptr_array_add (arguments, "-displayfd"); g_ptr_array_add (arguments, display_fd_string); g_ptr_array_add (arguments, "-auth"); g_ptr_array_add (arguments, auth_file); /* If we were compiled with Xserver >= 1.17 we need to specify * '-listen tcp' as the X server dosen't listen on tcp sockets * by default anymore. In older versions we need to pass * -nolisten tcp to disable listening on tcp sockets. */ #ifdef HAVE_XSERVER_THAT_DEFAULTS_TO_LOCAL_ONLY if (allow_remote_connections) { g_ptr_array_add (arguments, "-listen"); g_ptr_array_add (arguments, "tcp"); } #else if (!allow_remote_connections) { g_ptr_array_add (arguments, "-nolisten"); g_ptr_array_add (arguments, "tcp"); } #endif g_ptr_array_add (arguments, "-background"); g_ptr_array_add (arguments, "none"); g_ptr_array_add (arguments, "-noreset"); g_ptr_array_add (arguments, "-keeptty"); g_ptr_array_add (arguments, "-verbose"); if (state->debug_enabled) { g_ptr_array_add (arguments, "7"); } else { g_ptr_array_add (arguments, "3"); } if (state->debug_enabled) { g_ptr_array_add (arguments, "-core"); } g_ptr_array_add (arguments, NULL); subprocess = g_subprocess_launcher_spawnv (launcher, (const char * const *) arguments->pdata, &error); g_free (display_fd_string); g_clear_object (&launcher); g_ptr_array_free (arguments, TRUE); if (subprocess == NULL) { g_debug ("could not start X server: %s", error->message); goto out; } input_stream = g_unix_input_stream_new (pipe_fds[0], TRUE); data_stream = g_data_input_stream_new (input_stream); g_clear_object (&input_stream); display_number = g_data_input_stream_read_line (data_stream, &display_number_size, cancellable, &error); if (error != NULL) { g_debug ("could not read display string from X server: %s", error->message); goto out; } if (display_number == NULL) { g_debug ("X server did not write display string"); goto out; } state->display_name = g_strdup_printf (":%s", display_number); g_clear_pointer (&display_number, g_free); state->auth_file = g_strdup (auth_file); state->x_subprocess = g_object_ref (subprocess); g_subprocess_wait_async (state->x_subprocess, cancellable, (GAsyncReadyCallback) on_x_server_finished, state); is_running = TRUE; out: g_clear_pointer (&auth_file, g_free); g_clear_object (&data_stream); g_clear_object (&subprocess); g_clear_object (&launcher); g_clear_error (&error); return is_running; }
static void get_current_settings_ready (QmiClientWds *client, GAsyncResult *res, ConnectContext *ctx) { GError *error = NULL; QmiMessageWdsGetCurrentSettingsOutput *output; g_assert (ctx->running_ipv4 || ctx->running_ipv6); g_assert (!(ctx->running_ipv4 && ctx->running_ipv6)); output = qmi_client_wds_get_current_settings_finish (client, res, &error); if (!output || !qmi_message_wds_get_current_settings_output_get_result (output, &error)) { /* Never treat this as a hard connection error; not all devices support * "WDS Get Current Settings" */ mm_info ("error: couldn't get current settings: %s", error->message); g_error_free (error); } else { gboolean success; guint32 addr, mtu, i; GArray *array; guint8 prefix; if (ctx->running_ipv4) { mm_dbg ("QMI IPv4 Settings:"); /* IPv4 address */ success = qmi_message_wds_get_current_settings_output_get_ipv4_address (output, &addr, &error); print_address4 (success, "Address", addr, error); g_clear_error (&error); /* IPv4 gateway address */ success = qmi_message_wds_get_current_settings_output_get_ipv4_gateway_address (output, &addr, &error); print_address4 (success, "Gateway", addr, error); g_clear_error (&error); /* IPv4 subnet mask */ success = qmi_message_wds_get_current_settings_output_get_ipv4_gateway_subnet_mask (output, &addr, &error); print_address4 (success, "Netmask", addr, error); g_clear_error (&error); /* IPv4 DNS #1 */ success = qmi_message_wds_get_current_settings_output_get_primary_ipv4_dns_address (output, &addr, &error); print_address4 (success, " DNS #1", addr, error); g_clear_error (&error); /* IPv4 DNS #2 */ success = qmi_message_wds_get_current_settings_output_get_secondary_ipv4_dns_address (output, &addr, &error); print_address4 (success, " DNS #2", addr, error); g_clear_error (&error); } else { mm_dbg ("QMI IPv6 Settings:"); /* IPv6 address */ success = qmi_message_wds_get_current_settings_output_get_ipv6_address (output, &array, &prefix, &error); print_address6 (success, "Address", array, prefix, error); g_clear_error (&error); /* IPv6 gateway address */ success = qmi_message_wds_get_current_settings_output_get_ipv6_gateway_address (output, &array, &prefix, &error); print_address6 (success, "Gateway", array, prefix, error); g_clear_error (&error); /* IPv6 DNS #1 */ success = qmi_message_wds_get_current_settings_output_get_ipv6_primary_dns_address (output, &array, &error); print_address6 (success, " DNS #1", array, 0, error); g_clear_error (&error); /* IPv6 DNS #2 */ success = qmi_message_wds_get_current_settings_output_get_ipv6_secondary_dns_address (output, &array, &error); print_address6 (success, " DNS #2", array, 0, error); g_clear_error (&error); } /* Domain names */ if (qmi_message_wds_get_current_settings_output_get_domain_name_list (output, &array, &error)) { GString *s = g_string_sized_new (array ? (array->len * 20) : 1); for (i = 0; array && (i < array->len); i++) { if (s->len) g_string_append (s, ", "); g_string_append (s, g_array_index (array, const char *, i)); } mm_dbg (" Domains: %s", s->str); g_string_free (s, TRUE); } else { mm_dbg (" Domains: failed (%s)", error ? error->message : "unknown"); g_clear_error (&error); } if (qmi_message_wds_get_current_settings_output_get_mtu (output, &mtu, &error)) mm_dbg (" MTU: %d", mtu); else { mm_dbg (" MTU: failed (%s)", error ? error->message : "unknown"); g_clear_error (&error); } } if (output) qmi_message_wds_get_current_settings_output_unref (output); /* Keep on */ ctx->step++; connect_context_step (ctx); }
static gboolean spawn_bus (State *state, GCancellable *cancellable) { GDBusConnection *bus_connection = NULL; GPtrArray *arguments = NULL; GSubprocessLauncher *launcher = NULL; GSubprocess *subprocess = NULL; GInputStream *input_stream = NULL; GDataInputStream *data_stream = NULL; GError *error = NULL; char *bus_address_fd_string; char *bus_address = NULL; gsize bus_address_size; gboolean is_running = FALSE; int ret; int pipe_fds[2]; g_debug ("Running session message bus"); bus_connection = g_bus_get_sync (G_BUS_TYPE_SESSION, cancellable, NULL); if (bus_connection != NULL) { g_debug ("session message bus already running, not starting another one"); state->bus_connection = bus_connection; return TRUE; } ret = g_unix_open_pipe (pipe_fds, FD_CLOEXEC, &error); if (!ret) { g_debug ("could not open pipe: %s", error->message); goto out; } arguments = g_ptr_array_new (); launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_NONE); g_subprocess_launcher_take_fd (launcher, pipe_fds[1], BUS_ADDRESS_FILENO); bus_address_fd_string = g_strdup_printf ("%d", BUS_ADDRESS_FILENO); g_ptr_array_add (arguments, "dbus-daemon"); g_ptr_array_add (arguments, "--print-address"); g_ptr_array_add (arguments, bus_address_fd_string); g_ptr_array_add (arguments, "--session"); g_ptr_array_add (arguments, NULL); subprocess = g_subprocess_launcher_spawnv (launcher, (const char * const *) arguments->pdata, &error); g_free (bus_address_fd_string); g_clear_object (&launcher); g_ptr_array_free (arguments, TRUE); if (subprocess == NULL) { g_debug ("could not start dbus-daemon: %s", error->message); goto out; } input_stream = g_unix_input_stream_new (pipe_fds[0], TRUE); data_stream = g_data_input_stream_new (input_stream); g_clear_object (&input_stream); bus_address = g_data_input_stream_read_line (data_stream, &bus_address_size, cancellable, &error); if (error != NULL) { g_debug ("could not read address from session message bus: %s", error->message); goto out; } if (bus_address == NULL) { g_debug ("session message bus did not write address"); goto out; } state->bus_address = bus_address; state->bus_subprocess = g_object_ref (subprocess); g_subprocess_wait_async (state->bus_subprocess, cancellable, (GAsyncReadyCallback) on_bus_finished, state); bus_connection = g_dbus_connection_new_for_address_sync (state->bus_address, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT | G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION, NULL, cancellable, &error); if (bus_connection == NULL) { g_debug ("could not open connection to session bus: %s", error->message); goto out; } state->bus_connection = bus_connection; is_running = TRUE; out: g_clear_object (&data_stream); g_clear_object (&subprocess); g_clear_object (&launcher); g_clear_error (&error); return is_running; }
static gboolean notification_libnotify_create(MsgInfo *msginfo, NotificationFolderType nftype) { GdkPixbuf *pixbuf; NotificationPopup *ppopup; gchar *summary = NULL; gchar *text = NULL; gchar *utf8_str = NULL; gchar *subj = NULL; gchar *from = NULL; gchar *foldname = NULL; GList *caps = NULL; gboolean support_actions = FALSE; g_return_val_if_fail(msginfo, FALSE); ppopup = &(popup[nftype]); /* init libnotify if necessary */ if(!notify_is_initted()) { if(!notify_init("claws-mail")) { debug_print("Notification Plugin: Failed to initialize libnotify. " "No popup will be shown.\n"); return FALSE; } } switch(nftype) { case F_TYPE_MAIL: summary = _("New Mail message"); from = notification_libnotify_sanitize_str(msginfo->from ? msginfo->from : _("(No From)")); subj = notification_libnotify_sanitize_str(msginfo->subject ? msginfo->subject : _("(No Subject)")); if (notify_config.popup_display_folder_name) { foldname = notification_libnotify_sanitize_str(msginfo->folder->path); text = g_strconcat(from,"\n\n", subj, "\n\n", foldname, NULL); } else text = g_strconcat(from, "\n\n",subj, NULL); /* Make sure text is valid UTF8 */ utf8_str = notification_validate_utf8_str(text); g_free(text); if(from) g_free(from); if(subj) g_free(subj); if(foldname) g_free(foldname); break; case F_TYPE_NEWS: summary = _("New News post"); utf8_str = g_strdup(_("A new message arrived")); break; case F_TYPE_CALENDAR: summary = _("New Calendar message"); utf8_str = g_strdup(_("A new calendar message arrived")); break; case F_TYPE_RSS: summary = _("New RSS feed article"); utf8_str = g_strdup(_("A new article in a RSS feed arrived")); break; default: summary = _("New unknown message"); utf8_str = g_strdup(_("Unknown message type arrived")); break; } ppopup->notification = notify_notification_new(summary, utf8_str, NULL #if !NOTIFY_CHECK_VERSION(0, 7, 0) , NULL #endif ); g_free(utf8_str); if(ppopup->notification == NULL) { debug_print("Notification Plugin: Failed to create a new " "notification.\n"); return FALSE; } caps = notify_get_server_caps(); if(caps != NULL) { GList *c; for(c = caps; c != NULL; c = c->next) { if(strcmp((char*)c->data, "actions") == 0 ) { support_actions = TRUE; break; } } g_list_foreach(caps, (GFunc)g_free, NULL); g_list_free(caps); } /* Default action */ if (support_actions) notify_notification_add_action(ppopup->notification, "default", _("Present main window"), (NotifyActionCallback)default_action_cb, GINT_TO_POINTER(nftype), notification_libnotify_free_func); /* Icon */ pixbuf = NULL; #ifndef USE_ALT_ADDRBOOK if(msginfo && msginfo->from) { gchar *icon_path; icon_path = addrindex_get_picture_file(msginfo->from); if(is_file_exist(icon_path)) { GError *error = NULL; gint w, h; gdk_pixbuf_get_file_info(icon_path, &w, &h); if((w > 64) || (h > 64)) pixbuf = gdk_pixbuf_new_from_file_at_scale(icon_path, 64, 64, TRUE, &error); else pixbuf = gdk_pixbuf_new_from_file(icon_path, &error); if(!pixbuf) { debug_print("Could not load picture file: %s\n", error ? error->message : "no details"); g_error_free(error); } } else debug_print("Picture path does not exist: %s\n",icon_path); g_free(icon_path); } #endif if(!pixbuf) pixbuf = g_object_ref(notification_pixbuf_get(NOTIFICATION_CM_LOGO_64x64)); if(pixbuf) { notify_notification_set_icon_from_pixbuf(ppopup->notification, pixbuf); g_object_unref(pixbuf); } else /* This is not fatal */ debug_print("Notification plugin: Icon could not be loaded.\n"); /* timeout */ notify_notification_set_timeout(ppopup->notification, notify_config.popup_timeout); /* Category */ notify_notification_set_category(ppopup->notification, "email.arrived"); /* get notified on bubble close */ g_signal_connect(G_OBJECT(popup->notification), "closed", G_CALLBACK(popup_timeout_fun), NULL); /* Show the popup */ notify_notification_set_hint_string(ppopup->notification, "desktop-entry", "claws-mail"); if(!notify_notification_show(ppopup->notification, &(ppopup->error))) { debug_print("Notification Plugin: Failed to send notification: %s\n", ppopup->error->message); g_clear_error(&(ppopup->error)); g_object_unref(G_OBJECT(ppopup->notification)); ppopup->notification = NULL; return FALSE; } debug_print("Notification Plugin: Popup created with libnotify.\n"); ppopup->count = 1; /* Store path to message */ if(nftype == F_TYPE_MAIL) { if(msginfo && msginfo->folder) { gchar *ident; ident = folder_item_get_identifier(msginfo->folder); ppopup->msg_path = g_strdup_printf("%s%s%u", ident,G_DIR_SEPARATOR_S, msginfo->msgnum); g_free(ident); } else ppopup->msg_path = NULL; } return TRUE; }
static void theme_message_area_update (AppearanceData *data) { const MateThemeMetaInfo *theme; gboolean show_apply_background = FALSE; gboolean show_apply_font = FALSE; gboolean show_revert_font = FALSE; gboolean show_error; const gchar *message; gchar *font; GError *error = NULL; theme = theme_get_selected (GTK_ICON_VIEW (appearance_capplet_get_widget (data, "theme_list")), data); if (!theme) { if (data->theme_message_area != NULL) gtk_widget_hide (data->theme_message_area); return; } show_error = !mate_theme_meta_info_validate (theme, &error); if (!show_error) { if (theme->background_image != NULL) { gchar *background; background = g_settings_get_string (data->wp_settings, WP_FILE_KEY); show_apply_background = (!background || strcmp (theme->background_image, background) != 0); g_free (background); } if (theme->application_font) { font = g_settings_get_string (data->interface_settings, GTK_FONT_KEY); show_apply_font = (!font || strcmp (theme->application_font, font) != 0); g_free (font); } if (!show_apply_font && theme->documents_font) { font = g_settings_get_string (data->interface_settings, DOCUMENT_FONT_KEY); show_apply_font = (!font || strcmp (theme->application_font, font) != 0); g_free (font); } if (!show_apply_font && theme->desktop_font) { font = g_settings_get_string (data->caja_settings, DESKTOP_FONT_KEY); show_apply_font = (!font || strcmp (theme->application_font, font) != 0); g_free (font); } if (!show_apply_font && theme->windowtitle_font) { font = g_settings_get_string (data->marco_settings, WINDOW_TITLE_FONT_KEY); show_apply_font = (!font || strcmp (theme->application_font, font) != 0); g_free (font); } if (!show_apply_font && theme->monospace_font) { font = g_settings_get_string (data->interface_settings, MONOSPACE_FONT_KEY); show_apply_font = (!font || strcmp (theme->application_font, font) != 0); g_free (font); } show_revert_font = (data->revert_application_font != NULL || data->revert_documents_font != NULL || data->revert_desktop_font != NULL || data->revert_windowtitle_font != NULL || data->revert_monospace_font != NULL); } if (data->theme_message_area == NULL) { GtkWidget *hbox; GtkWidget *parent; GtkWidget *content; if (!show_apply_background && !show_revert_font && !show_apply_font && !show_error) return; data->theme_message_area = gtk_info_bar_new (); gtk_widget_set_no_show_all (data->theme_message_area, TRUE); g_signal_connect (data->theme_message_area, "response", (GCallback) theme_message_area_response_cb, data); data->apply_background_button = gtk_info_bar_add_button ( GTK_INFO_BAR (data->theme_message_area), _("Apply Background"), RESPONSE_APPLY_BG); data->apply_font_button = gtk_info_bar_add_button ( GTK_INFO_BAR (data->theme_message_area), _("Apply Font"), RESPONSE_APPLY_FONT); data->revert_font_button = gtk_info_bar_add_button ( GTK_INFO_BAR (data->theme_message_area), _("Revert Font"), RESPONSE_REVERT_FONT); data->install_button = gtk_info_bar_add_button ( GTK_INFO_BAR (data->theme_message_area), _("Install"), RESPONSE_INSTALL_ENGINE); data->theme_message_label = gtk_label_new (NULL); gtk_widget_show (data->theme_message_label); gtk_label_set_line_wrap (GTK_LABEL (data->theme_message_label), TRUE); gtk_misc_set_alignment (GTK_MISC (data->theme_message_label), 0.0, 0.5); hbox = gtk_hbox_new (FALSE, 9); gtk_widget_show (hbox); data->theme_info_icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG); data->theme_error_icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (data->theme_info_icon), 0.5, 0); gtk_misc_set_alignment (GTK_MISC (data->theme_error_icon), 0.5, 0); gtk_box_pack_start (GTK_BOX (hbox), data->theme_info_icon, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), data->theme_error_icon, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), data->theme_message_label, TRUE, TRUE, 0); content = gtk_info_bar_get_content_area (GTK_INFO_BAR (data->theme_message_area)); gtk_container_add (GTK_CONTAINER (content), hbox); parent = appearance_capplet_get_widget (data, "theme_list_vbox"); gtk_box_pack_start (GTK_BOX (parent), data->theme_message_area, FALSE, FALSE, 0); } if (show_error) message = error->message; else if (show_apply_background && show_apply_font && show_revert_font) message = _("The current theme suggests a background and a font. Also, the last applied font suggestion can be reverted."); else if (show_apply_background && show_revert_font) message = _("The current theme suggests a background. Also, the last applied font suggestion can be reverted."); else if (show_apply_background && show_apply_font) message = _("The current theme suggests a background and a font."); else if (show_apply_font && show_revert_font) message = _("The current theme suggests a font. Also, the last applied font suggestion can be reverted."); else if (show_apply_background) message = _("The current theme suggests a background."); else if (show_revert_font) message = _("The last applied font suggestion can be reverted."); else if (show_apply_font) message = _("The current theme suggests a font."); else message = NULL; if (show_apply_background) gtk_widget_show (data->apply_background_button); else gtk_widget_hide (data->apply_background_button); if (show_apply_font) gtk_widget_show (data->apply_font_button); else gtk_widget_hide (data->apply_font_button); if (show_revert_font) gtk_widget_show (data->revert_font_button); else gtk_widget_hide (data->revert_font_button); if (show_error && g_error_matches (error, MATE_THEME_ERROR, MATE_THEME_ERROR_GTK_ENGINE_NOT_AVAILABLE) && packagekit_available ()) gtk_widget_show (data->install_button); else gtk_widget_hide (data->install_button); if (show_error || show_apply_background || show_apply_font || show_revert_font) { gtk_widget_show (data->theme_message_area); gtk_widget_queue_draw (data->theme_message_area); if (show_error) { gtk_widget_show (data->theme_error_icon); gtk_widget_hide (data->theme_info_icon); } else { gtk_widget_show (data->theme_info_icon); gtk_widget_hide (data->theme_error_icon); } } else { gtk_widget_hide (data->theme_message_area); } gtk_label_set_text (GTK_LABEL (data->theme_message_label), message); g_clear_error (&error); }
static char* string_replace (const char* self, const char* old, const char* replacement) { #line 227 "source-spinner-item.c" char* result = NULL; GError * _inner_error_ = NULL; #line 1157 "glib-2.0.vapi" g_return_val_if_fail (self != NULL, NULL); #line 1157 "glib-2.0.vapi" g_return_val_if_fail (old != NULL, NULL); #line 1157 "glib-2.0.vapi" g_return_val_if_fail (replacement != NULL, NULL); #line 236 "source-spinner-item.c" { char* _tmp0_; GRegex* _tmp1_; GRegex* regex; char* _tmp2_; #line 1159 "glib-2.0.vapi" regex = (_tmp1_ = g_regex_new (_tmp0_ = g_regex_escape_string (old, -1), 0, 0, &_inner_error_), _g_free0 (_tmp0_), _tmp1_); #line 244 "source-spinner-item.c" if (_inner_error_ != NULL) { if (_inner_error_->domain == G_REGEX_ERROR) { goto __catch41_g_regex_error; } g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); g_clear_error (&_inner_error_); return NULL; } #line 1160 "glib-2.0.vapi" _tmp2_ = g_regex_replace_literal (regex, self, (gssize) (-1), 0, replacement, 0, &_inner_error_); #line 255 "source-spinner-item.c" if (_inner_error_ != NULL) { _g_regex_unref0 (regex); if (_inner_error_->domain == G_REGEX_ERROR) { goto __catch41_g_regex_error; } _g_regex_unref0 (regex); g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); g_clear_error (&_inner_error_); return NULL; } result = _tmp2_; _g_regex_unref0 (regex); #line 1160 "glib-2.0.vapi" return result; #line 270 "source-spinner-item.c" } goto __finally41; __catch41_g_regex_error: { GError * e; e = _inner_error_; _inner_error_ = NULL; { #line 1162 "glib-2.0.vapi" g_assert_not_reached (); #line 281 "source-spinner-item.c" _g_error_free0 (e); } } __finally41: if (_inner_error_ != NULL) { g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); g_clear_error (&_inner_error_); return NULL; } }
/** * proc_plugin_proxy_run: * @data: A data container. * @run: Run mode. * @name: Plug-in name (i.e. data processing function) to run. * * The plug-in proxy itself, runs plug-in @name on @data. * * Returns: Whether it succeeded running the plug-in. **/ static void proc_plugin_proxy_run(GwyContainer *data, GwyRunType run, const gchar *name) { ProcPluginInfo *info; GwyContainer *newdata; gchar *filename, *buffer = NULL; GError *err = NULL; gint exit_status, id, newid; gsize size = 0; FILE *fh; gchar *args[] = { NULL, "run", NULL, NULL, NULL }; GQuark dquark, mquark, squark; gboolean ok; gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD_KEY, &dquark, GWY_APP_MASK_FIELD_KEY, &mquark, GWY_APP_DATA_FIELD_ID, &id, 0); gwy_debug("called as %s with run mode %d", name, run); if (!(info = proc_find_plugin(name, run))) return; fh = text_dump_export(data, dquark, mquark, &filename, NULL); g_return_if_fail(fh); args[0] = info->file; args[2] = g_strdup(gwy_enum_to_string(run, run_mode_names, -1)); args[3] = decode_glib_encoded_filename(filename); gwy_debug("%s %s %s %s", args[0], args[1], args[2], args[3]); ok = g_spawn_sync(NULL, args, NULL, 0, NULL, NULL, NULL, NULL, &exit_status, &err); if (!err) ok &= g_file_get_contents(filename, &buffer, &size, &err); g_unlink(filename); fclose(fh); gwy_debug("ok = %d, exit_status = %d, err = %p", ok, exit_status, err); ok &= !exit_status; if (ok && (newdata = text_dump_import(buffer, size, NULL))) { GwyDataField *dfield; /* Merge data */ if (gwy_container_gis_object_by_name(newdata, "/0/data", &dfield)) g_object_ref(dfield); else { dfield = gwy_container_get_object(data, dquark); dfield = gwy_data_field_duplicate(dfield); } newid = gwy_app_data_browser_add_data_field(dfield, data, TRUE); /* Merge mask */ if (gwy_container_gis_object_by_name(newdata, "/0/mask", &dfield)) g_object_ref(dfield); else if (gwy_container_gis_object(data, mquark, &dfield)) dfield = gwy_data_field_duplicate(dfield); else dfield = NULL; if (dfield) { mquark = gwy_app_get_mask_key_for_id(newid); gwy_container_set_object(data, mquark, dfield); g_object_unref(dfield); } /* Merge presentation */ if (gwy_container_gis_object_by_name(newdata, "/0/show", &dfield)) { squark = gwy_app_get_show_key_for_id(newid); gwy_container_set_object(data, squark, dfield); } /* Merge stuff. XXX: This is brutal and incomplete. */ gwy_app_sync_data_items(data, data, id, newid, FALSE, GWY_DATA_ITEM_GRADIENT, GWY_DATA_ITEM_RANGE_TYPE, GWY_DATA_ITEM_MASK_COLOR, GWY_DATA_ITEM_REAL_SQUARE, 0); gwy_app_sync_data_items(newdata, data, 0, newid, FALSE, GWY_DATA_ITEM_GRADIENT, GWY_DATA_ITEM_RANGE_TYPE, 0); g_object_unref(newdata); } else { g_warning("Cannot run plug-in %s: %s", info->file, err ? err->message : "it returned garbage."); } g_free(args[3]); g_free(args[2]); g_clear_error(&err); g_free(buffer); g_free(filename); }