static void ide_clang_completion_item_lazy_init (IdeClangCompletionItem *self) { CXCompletionResult *result; g_autoptr(IdeSourceSnippet) snippet = NULL; GdkPixbuf *icon = NULL; GString *markup = NULL; unsigned num_chunks; unsigned i; guint tab_stop = 0; g_assert (IDE_IS_CLANG_COMPLETION_ITEM (self)); if (G_LIKELY (self->initialized)) return; result = ide_clang_completion_item_get_result (self); num_chunks = clang_getNumCompletionChunks (result); snippet = ide_source_snippet_new (NULL, NULL); markup = g_string_new (NULL); g_assert (result); g_assert (num_chunks); g_assert (IDE_IS_SOURCE_SNIPPET (snippet)); g_assert (markup); /* * Try to determine the icon to use for this result. */ switch ((int)result->CursorKind) { case CXCursor_CXXMethod: case CXCursor_Constructor: case CXCursor_Destructor: case CXCursor_MemberRef: case CXCursor_MemberRefExpr: case CXCursor_ObjCClassMethodDecl: case CXCursor_ObjCInstanceMethodDecl: icon = get_icon ("lang-method-symbolic"); break; case CXCursor_ConversionFunction: case CXCursor_FunctionDecl: case CXCursor_FunctionTemplate: icon = get_icon ("lang-function-symbolic"); break; case CXCursor_FieldDecl: icon = get_icon ("struct-field-symbolic"); break; case CXCursor_VarDecl: /* local? */ case CXCursor_ParmDecl: case CXCursor_ObjCIvarDecl: case CXCursor_ObjCPropertyDecl: case CXCursor_ObjCSynthesizeDecl: case CXCursor_NonTypeTemplateParameter: case CXCursor_Namespace: case CXCursor_NamespaceAlias: case CXCursor_NamespaceRef: break; case CXCursor_StructDecl: icon = get_icon ("lang-struct-symbolic"); break; case CXCursor_UnionDecl: case CXCursor_ClassDecl: case CXCursor_TypeRef: case CXCursor_TemplateRef: case CXCursor_TypedefDecl: case CXCursor_ClassTemplate: case CXCursor_ClassTemplatePartialSpecialization: case CXCursor_ObjCClassRef: case CXCursor_ObjCInterfaceDecl: case CXCursor_ObjCImplementationDecl: case CXCursor_ObjCCategoryDecl: case CXCursor_ObjCCategoryImplDecl: case CXCursor_ObjCProtocolDecl: case CXCursor_ObjCProtocolRef: case CXCursor_TemplateTypeParameter: case CXCursor_TemplateTemplateParameter: icon = get_icon ("lang-class-symbolic"); break; case CXCursor_EnumConstantDecl: icon = get_icon ("lang-enum-value-symbolic"); break; case CXCursor_EnumDecl: icon = get_icon ("lang-enum-symbolic"); break; case CXCursor_NotImplemented: default: break; } /* * Walk the chunks, creating our snippet for insertion as well as our markup * for the row in the completion window. */ for (i = 0; i < num_chunks; i++) { enum CXCompletionChunkKind kind; IdeSourceSnippetChunk *chunk; const gchar *text; g_autofree gchar *escaped = NULL; CXString cxstr; kind = clang_getCompletionChunkKind (result->CompletionString, i); cxstr = clang_getCompletionChunkText (result->CompletionString, i); text = clang_getCString (cxstr); if (text) escaped = g_markup_escape_text (text, -1); else escaped = g_strdup (""); switch (kind) { case CXCompletionChunk_Optional: break; case CXCompletionChunk_TypedText: g_string_append_printf (markup, "<b>%s</b>", escaped); chunk = ide_source_snippet_chunk_new (); ide_source_snippet_chunk_set_text (chunk, text); ide_source_snippet_chunk_set_text_set (chunk, TRUE); ide_source_snippet_add_chunk (snippet, chunk); g_clear_object (&chunk); break; case CXCompletionChunk_Text: g_string_append (markup, escaped); chunk = ide_source_snippet_chunk_new (); ide_source_snippet_chunk_set_text (chunk, text); ide_source_snippet_chunk_set_text_set (chunk, TRUE); ide_source_snippet_add_chunk (snippet, chunk); g_clear_object (&chunk); break; case CXCompletionChunk_Placeholder: g_string_append (markup, escaped); chunk = ide_source_snippet_chunk_new (); ide_source_snippet_chunk_set_text (chunk, text); ide_source_snippet_chunk_set_text_set (chunk, TRUE); ide_source_snippet_chunk_set_tab_stop (chunk, ++tab_stop); ide_source_snippet_add_chunk (snippet, chunk); g_clear_object (&chunk); break; case CXCompletionChunk_Informative: if (0 == g_strcmp0 (text, "const ")) g_string_append (markup, text); break; case CXCompletionChunk_CurrentParameter: break; case CXCompletionChunk_LeftParen: g_string_append (markup, " "); chunk = ide_source_snippet_chunk_new (); ide_source_snippet_chunk_set_text (chunk, " "); ide_source_snippet_chunk_set_text_set (chunk, TRUE); ide_source_snippet_add_chunk (snippet, chunk); g_clear_object (&chunk); /* fall through */ case CXCompletionChunk_RightParen: case CXCompletionChunk_LeftBracket: case CXCompletionChunk_RightBracket: case CXCompletionChunk_LeftBrace: case CXCompletionChunk_RightBrace: case CXCompletionChunk_LeftAngle: case CXCompletionChunk_RightAngle: case CXCompletionChunk_Comma: case CXCompletionChunk_Colon: case CXCompletionChunk_SemiColon: case CXCompletionChunk_Equal: case CXCompletionChunk_HorizontalSpace: g_string_append (markup, escaped); chunk = ide_source_snippet_chunk_new (); ide_source_snippet_chunk_set_text (chunk, text); ide_source_snippet_chunk_set_text_set (chunk, TRUE); ide_source_snippet_add_chunk (snippet, chunk); g_clear_object (&chunk); break; case CXCompletionChunk_VerticalSpace: g_string_append (markup, escaped); /* insert the vertical space */ chunk = ide_source_snippet_chunk_new (); ide_source_snippet_chunk_set_text (chunk, text); ide_source_snippet_chunk_set_text_set (chunk, TRUE); ide_source_snippet_add_chunk (snippet, chunk); g_clear_object (&chunk); /* now perform indentation */ chunk = ide_source_snippet_chunk_new (); ide_source_snippet_chunk_set_text (chunk, "\t"); ide_source_snippet_chunk_set_text_set (chunk, TRUE); ide_source_snippet_add_chunk (snippet, chunk); g_clear_object (&chunk); break; case CXCompletionChunk_ResultType: g_string_append_printf (markup, "%s ", escaped); break; default: break; } } self->snippet = g_object_ref (snippet); self->markup = g_string_free (markup, FALSE); self->icon = icon ? g_object_ref (icon) : NULL; }
gboolean create_bundle(const gchar *bundlename, const gchar *contentdir, GError **error) { GError *ierror = NULL; GBytes *sig = NULL; GFile *bundlefile = NULL; GFileOutputStream *bundlestream = NULL; gboolean res = FALSE; guint64 offset; g_assert_nonnull(r_context()->certpath); g_assert_nonnull(r_context()->keypath); res = mksquashfs(bundlename, contentdir, &ierror); if (!res) { g_propagate_error(error, ierror); goto out; } sig = cms_sign_file(bundlename, r_context()->certpath, r_context()->keypath, &ierror); if (sig == NULL) { g_propagate_prefixed_error( error, ierror, "failed signing bundle: "); goto out; } bundlefile = g_file_new_for_path(bundlename); bundlestream = g_file_append_to(bundlefile, G_FILE_CREATE_NONE, NULL, &ierror); if (bundlestream == NULL) { g_propagate_prefixed_error( error, ierror, "failed to open bundle for appending: "); goto out; } res = g_seekable_seek(G_SEEKABLE(bundlestream), 0, G_SEEK_END, NULL, &ierror); if (!res) { g_propagate_prefixed_error( error, ierror, "failed to seek to end of bundle: "); goto out; } offset = g_seekable_tell((GSeekable *)bundlestream); res = output_stream_write_bytes_all((GOutputStream *)bundlestream, sig, NULL, &ierror); if (!res) { g_propagate_prefixed_error( error, ierror, "failed to append signature to bundle: "); goto out; } offset = g_seekable_tell((GSeekable *)bundlestream) - offset; res = output_stream_write_uint64_all((GOutputStream *)bundlestream, offset, NULL, &ierror); if (!res) { g_propagate_prefixed_error( error, ierror, "failed to append signature size to bundle: "); goto out; } res = TRUE; out: g_clear_object(&bundlestream); g_clear_object(&bundlefile); g_clear_pointer(&sig, g_bytes_unref); return res; }
static void picture_scaled (GObject *source_object, GAsyncResult *res, gpointer user_data) { BgPicturesSource *bg_source; CcBackgroundItem *item; GError *error = NULL; GdkPixbuf *pixbuf = NULL; const char *software; const char *uri; GtkTreeIter iter; GtkTreePath *path; GtkTreeRowReference *row_ref; GtkListStore *store; cairo_surface_t *surface = NULL; int scale_factor; item = g_object_get_data (source_object, "item"); pixbuf = gdk_pixbuf_new_from_stream_finish (res, &error); if (pixbuf == NULL) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_warning ("Failed to load image: %s", error->message); remove_placeholder (BG_PICTURES_SOURCE (user_data), item); } g_error_free (error); goto out; } /* since we were not cancelled, we can now cast user_data * back to BgPicturesSource. */ bg_source = BG_PICTURES_SOURCE (user_data); store = bg_source_get_liststore (BG_SOURCE (bg_source)); uri = cc_background_item_get_uri (item); if (uri == NULL) uri = cc_background_item_get_source_url (item); /* Ignore screenshots */ software = gdk_pixbuf_get_option (pixbuf, "tEXt::Software"); if (software != NULL && g_str_equal (software, "gnome-screenshot")) { g_debug ("Ignored URL '%s' as it's a screenshot from gnome-screenshot", uri); remove_placeholder (BG_PICTURES_SOURCE (user_data), item); goto out; } scale_factor = bg_source_get_scale_factor (BG_SOURCE (bg_source)); surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, scale_factor, NULL); cc_background_item_load (item, NULL); row_ref = g_object_get_data (G_OBJECT (item), "row-ref"); if (row_ref == NULL) { /* insert the item into the liststore if it did not exist */ gtk_list_store_insert_with_values (store, NULL, -1, 0, surface, 1, item, -1); } else { path = gtk_tree_row_reference_get_path (row_ref); if (gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path)) { /* otherwise update the thumbnail */ gtk_list_store_set (store, &iter, 0, surface, -1); } } g_hash_table_insert (bg_source->priv->known_items, bg_pictures_source_get_unique_filename (uri), GINT_TO_POINTER (TRUE)); out: g_clear_pointer (&surface, (GDestroyNotify) cairo_surface_destroy); g_clear_object (&pixbuf); }
/* * Block contact dialog */ gboolean empathy_block_individual_dialog_show (GtkWindow *parent, FolksIndividual *individual, GdkPixbuf *avatar, gboolean *abusive) { GtkWidget *dialog; GtkWidget *abusive_check = NULL; GeeSet *personas; GeeIterator *iter; GString *text = g_string_new (""); GString *blocked_str = g_string_new (""); GString *notblocked_str = g_string_new (""); guint npersonas_blocked = 0, npersonas_notblocked = 0; gboolean can_report_abuse = FALSE; int res; dialog = gtk_message_dialog_new (parent, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, _("Block %s?"), folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (individual))); if (avatar != NULL) { GtkWidget *image = gtk_image_new_from_pixbuf (avatar); gtk_message_dialog_set_image (GTK_MESSAGE_DIALOG (dialog), image); gtk_widget_show (image); } /* build a list of personas that support blocking */ personas = folks_individual_get_personas (individual); iter = gee_iterable_iterator (GEE_ITERABLE (personas)); while (gee_iterator_next (iter)) { TpfPersona *persona = gee_iterator_get (iter); TpContact *contact; GString *s; char *str; TpConnection *conn; if (!TPF_IS_PERSONA (persona)) goto while_finish; contact = tpf_persona_get_contact (persona); if (contact == NULL) goto while_finish; conn = tp_contact_get_connection (contact); if (tp_proxy_has_interface_by_id (conn, TP_IFACE_QUARK_CONNECTION_INTERFACE_CONTACT_BLOCKING)) { s = blocked_str; npersonas_blocked++; } else { s = notblocked_str; npersonas_notblocked++; } if (tp_connection_can_report_abusive (conn)) can_report_abuse = TRUE; str = contact_pretty_name (contact); g_string_append_printf (s, "\n " BULLET_POINT " %s", str); g_free (str); while_finish: g_clear_object (&persona); } g_clear_object (&iter); g_string_append_printf (text, _("Are you sure you want to block '%s' from contacting you again?"), folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (individual))); if (npersonas_blocked > 0) g_string_append_printf (text, "\n\n%s\n%s", ngettext ("The following identity will be blocked:", "The following identities will be blocked:", npersonas_blocked), blocked_str->str); if (npersonas_notblocked > 0) g_string_append_printf (text, "\n\n%s\n%s", ngettext ("The following identity can not be blocked:", "The following identities can not be blocked:", npersonas_notblocked), notblocked_str->str); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", text->str); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Block"), GTK_RESPONSE_REJECT, NULL); if (can_report_abuse) { GtkWidget *vbox; vbox = gtk_message_dialog_get_message_area (GTK_MESSAGE_DIALOG (dialog)); abusive_check = gtk_check_button_new_with_mnemonic ( ngettext ("_Report this contact as abusive", "_Report these contacts as abusive", npersonas_blocked)); gtk_box_pack_start (GTK_BOX (vbox), abusive_check, FALSE, TRUE, 0); gtk_widget_show (abusive_check); } g_string_free (text, TRUE); g_string_free (blocked_str, TRUE); g_string_free (notblocked_str, TRUE); res = gtk_dialog_run (GTK_DIALOG (dialog)); if (abusive != NULL) { if (abusive_check != NULL) *abusive = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON (abusive_check)); else *abusive = FALSE; } gtk_widget_destroy (dialog); return res == GTK_RESPONSE_REJECT; }
static void nemo_window_slot_dispose (GObject *object) { NemoWindowSlot *slot; GtkWidget *widget; slot = NEMO_WINDOW_SLOT (object); nemo_window_slot_clear_forward_list (slot); nemo_window_slot_clear_back_list (slot); nemo_window_slot_remove_extra_location_widgets (slot); if (slot->content_view) { widget = GTK_WIDGET (slot->content_view); gtk_widget_destroy (widget); g_object_unref (slot->content_view); slot->content_view = NULL; } if (slot->new_content_view) { widget = GTK_WIDGET (slot->new_content_view); gtk_widget_destroy (widget); g_object_unref (slot->new_content_view); slot->new_content_view = NULL; } if (slot->set_status_timeout_id != 0) { g_source_remove (slot->set_status_timeout_id); slot->set_status_timeout_id = 0; } if (slot->loading_timeout_id != 0) { g_source_remove (slot->loading_timeout_id); slot->loading_timeout_id = 0; } nemo_window_slot_set_viewed_file (slot, NULL); /* TODO? why do we unref here? the file is NULL. * It was already here before the slot move, though */ nemo_file_unref (slot->viewed_file); if (slot->location) { /* TODO? why do we ref here, instead of unreffing? * It was already here before the slot migration, though */ g_object_ref (slot->location); } g_list_free_full (slot->pending_selection, g_object_unref); slot->pending_selection = NULL; g_clear_object (&slot->current_location_bookmark); g_clear_object (&slot->last_location_bookmark); if (slot->find_mount_cancellable != NULL) { g_cancellable_cancel (slot->find_mount_cancellable); slot->find_mount_cancellable = NULL; } slot->pane = NULL; g_free (slot->title); slot->title = NULL; g_free (slot->status_text); slot->status_text = NULL; G_OBJECT_CLASS (nemo_window_slot_parent_class)->dispose (object); }
static void update_properties_from_ifindex (NMDevice *device, int ifindex) { NMDeviceIPTunnel *self = NM_DEVICE_IP_TUNNEL (device); NMDeviceIPTunnelPrivate *priv = NM_DEVICE_IP_TUNNEL_GET_PRIVATE (self); GObject *object = G_OBJECT (device); NMDevice *parent; int parent_ifindex; in_addr_t local4, remote4; struct in6_addr local6, remote6; guint8 ttl = 0, tos = 0, encap_limit = 0; gboolean pmtud = FALSE; guint32 flow_label = 0; char *key; if (ifindex <= 0) { clear: if (priv->parent || priv->parent_ifindex) { g_clear_object (&priv->parent); priv->parent_ifindex = 0; g_object_notify (object, NM_DEVICE_IP_TUNNEL_PARENT); } if (priv->local) { g_clear_pointer (&priv->local, g_free); g_object_notify (object, NM_DEVICE_IP_TUNNEL_LOCAL); } if (priv->remote) { g_clear_pointer (&priv->remote, g_free); g_object_notify (object, NM_DEVICE_IP_TUNNEL_REMOTE); } if (priv->input_key) { g_clear_pointer (&priv->input_key, g_free); g_object_notify (object, NM_DEVICE_IP_TUNNEL_INPUT_KEY); } if (priv->output_key) { g_clear_pointer (&priv->output_key, g_free); g_object_notify (object, NM_DEVICE_IP_TUNNEL_OUTPUT_KEY); } goto out; } if (priv->mode == NM_IP_TUNNEL_MODE_GRE) { const NMPlatformLnkGre *lnk; lnk = nm_platform_link_get_lnk_gre (NM_PLATFORM_GET, ifindex, NULL); if (!lnk) { _LOGW (LOGD_HW, "could not read %s properties", "gre"); goto clear; } parent_ifindex = lnk->parent_ifindex; local4 = lnk->local; remote4 = lnk->remote; ttl = lnk->ttl; tos = lnk->tos; pmtud = lnk->path_mtu_discovery; if (NM_FLAGS_HAS (lnk->input_flags, NM_GRE_KEY)) { key = g_strdup_printf ("%u", lnk->input_key); if (g_strcmp0 (priv->input_key, key)) { g_free (priv->input_key); priv->input_key = key; g_object_notify (object, NM_DEVICE_IP_TUNNEL_INPUT_KEY); } else g_free (key); } else { if (priv->input_key) { g_clear_pointer (&priv->input_key, g_free); g_object_notify (object, NM_DEVICE_IP_TUNNEL_INPUT_KEY); } } if (NM_FLAGS_HAS (lnk->output_flags, NM_GRE_KEY)) { key = g_strdup_printf ("%u", lnk->output_key); if (g_strcmp0 (priv->output_key, key)) { g_free (priv->output_key); priv->output_key = key; g_object_notify (object, NM_DEVICE_IP_TUNNEL_OUTPUT_KEY); } else g_free (key); } else { if (priv->output_key) { g_clear_pointer (&priv->output_key, g_free); g_object_notify (object, NM_DEVICE_IP_TUNNEL_OUTPUT_KEY); } } } else if (priv->mode == NM_IP_TUNNEL_MODE_SIT) { const NMPlatformLnkSit *lnk; lnk = nm_platform_link_get_lnk_sit (NM_PLATFORM_GET, ifindex, NULL); if (!lnk) { _LOGW (LOGD_HW, "could not read %s properties", "sit"); goto clear; } parent_ifindex = lnk->parent_ifindex; local4 = lnk->local; remote4 = lnk->remote; ttl = lnk->ttl; tos = lnk->tos; pmtud = lnk->path_mtu_discovery; } else if (priv->mode == NM_IP_TUNNEL_MODE_IPIP) { const NMPlatformLnkIpIp *lnk; lnk = nm_platform_link_get_lnk_ipip (NM_PLATFORM_GET, ifindex, NULL); if (!lnk) { _LOGW (LOGD_HW, "could not read %s properties", "ipip"); goto clear; } parent_ifindex = lnk->parent_ifindex; local4 = lnk->local; remote4 = lnk->remote; ttl = lnk->ttl; tos = lnk->tos; pmtud = lnk->path_mtu_discovery; } else if ( priv->mode == NM_IP_TUNNEL_MODE_IPIP6 || priv->mode == NM_IP_TUNNEL_MODE_IP6IP6) { const NMPlatformLnkIp6Tnl *lnk; lnk = nm_platform_link_get_lnk_ip6tnl (NM_PLATFORM_GET, ifindex, NULL); if (!lnk) { _LOGW (LOGD_HW, "could not read %s properties", "ip6tnl"); goto clear; } parent_ifindex = lnk->parent_ifindex; local6 = lnk->local; remote6 = lnk->remote; ttl = lnk->ttl; tos = lnk->tclass; encap_limit = lnk->encap_limit; flow_label = lnk->flow_label; } else g_return_if_reached (); if (priv->parent_ifindex != parent_ifindex) { g_clear_object (&priv->parent); priv->parent_ifindex = parent_ifindex; parent = nm_manager_get_device_by_ifindex (nm_manager_get (), parent_ifindex); if (parent) priv->parent = g_object_ref (parent); g_object_notify (object, NM_DEVICE_IP_TUNNEL_PARENT); } if (priv->addr_family == AF_INET) { if (!address_equal_pn (AF_INET, priv->local, &local4)) { g_clear_pointer (&priv->local, g_free); if (local4) priv->local = g_strdup (nm_utils_inet4_ntop (local4, NULL)); g_object_notify (object, NM_DEVICE_IP_TUNNEL_LOCAL); } if (!address_equal_pn (AF_INET, priv->remote, &remote4)) { g_clear_pointer (&priv->remote, g_free); if (remote4) priv->remote = g_strdup (nm_utils_inet4_ntop (remote4, NULL)); g_object_notify (object, NM_DEVICE_IP_TUNNEL_REMOTE); } } else { if (!address_equal_pn (AF_INET6, priv->local, &local6)) { g_clear_pointer (&priv->local, g_free); if (memcmp (&local6, &in6addr_any, sizeof (in6addr_any))) priv->local = g_strdup (nm_utils_inet6_ntop (&local6, NULL)); g_object_notify (object, NM_DEVICE_IP_TUNNEL_LOCAL); } if (!address_equal_pn (AF_INET6, priv->remote, &remote6)) { g_clear_pointer (&priv->remote, g_free); if (memcmp (&remote6, &in6addr_any, sizeof (in6addr_any))) priv->remote = g_strdup (nm_utils_inet6_ntop (&remote6, NULL)); g_object_notify (object, NM_DEVICE_IP_TUNNEL_REMOTE); } } out: if (priv->ttl != ttl) { priv->ttl = ttl; g_object_notify (object, NM_DEVICE_IP_TUNNEL_TTL); } if (priv->tos != tos) { priv->tos = tos; g_object_notify (object, NM_DEVICE_IP_TUNNEL_TOS); } if (priv->path_mtu_discovery != pmtud) { priv->path_mtu_discovery = pmtud; g_object_notify (object, NM_DEVICE_IP_TUNNEL_PATH_MTU_DISCOVERY); } if (priv->encap_limit != encap_limit) { priv->encap_limit = encap_limit; g_object_notify (object, NM_DEVICE_IP_TUNNEL_ENCAPSULATION_LIMIT); } if (priv->flow_label != flow_label) { priv->flow_label = flow_label; g_object_notify (object, NM_DEVICE_IP_TUNNEL_FLOW_LABEL); } }
static void photos_item_manager_collection_path_free_foreach (gpointer data, gpointer user_data) { g_clear_object (&data); }
/** * udisks_daemon_util_inhibit_system_sync: * @reason: A human readable explanation of why the system is being inhibited. * * Tries to inhibit the system. * * Right now only * <ulink url="http://www.freedesktop.org/wiki/Software/systemd/inhibit">systemd</ulink> * inhibitors are supported but other inhibitors can be added in the future. * * Returns: A cookie that can be used with udisks_daemon_util_uninhibit_system_sync(). */ UDisksInhibitCookie * udisks_daemon_util_inhibit_system_sync (const gchar *reason) { #ifdef HAVE_LIBSYSTEMD_LOGIN UDisksInhibitCookie *ret = NULL; GDBusConnection *connection = NULL; GVariant *value = NULL; GUnixFDList *fd_list = NULL; gint32 index = -1; GError *error = NULL; g_return_val_if_fail (reason != NULL, NULL); connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error); if (connection == NULL) { udisks_error ("Error getting system bus: %s (%s, %d)", error->message, g_quark_to_string (error->domain), error->code); g_clear_error (&error); goto out; } value = g_dbus_connection_call_with_unix_fd_list_sync (connection, "org.freedesktop.login1", "/org/freedesktop/login1", "org.freedesktop.login1.Manager", "Inhibit", g_variant_new ("(ssss)", "sleep:shutdown:idle", /* what */ "Disk Manager", /* who */ reason, /* why */ "block"), /* mode */ G_VARIANT_TYPE ("(h)"), G_DBUS_CALL_FLAGS_NONE, -1, /* default timeout */ NULL, /* fd_list */ &fd_list, /* out_fd_list */ NULL, /* GCancellable */ &error); if (value == NULL) { udisks_error ("Error inhibiting: %s (%s, %d)", error->message, g_quark_to_string (error->domain), error->code); g_clear_error (&error); goto out; } g_variant_get (value, "(h)", &index); g_assert (index >= 0 && index < g_unix_fd_list_get_length (fd_list)); ret = g_new0 (UDisksInhibitCookie, 1); ret->magic = 0xdeadbeef; ret->fd = g_unix_fd_list_get (fd_list, index, &error); if (ret->fd == -1) { udisks_error ("Error getting fd: %s (%s, %d)", error->message, g_quark_to_string (error->domain), error->code); g_clear_error (&error); g_free (ret); ret = NULL; goto out; } out: if (value != NULL) g_variant_unref (value); g_clear_object (&fd_list); g_clear_object (&connection); return ret; #else /* non-systemd: just return a dummy pointer */ g_return_val_if_fail (reason != NULL, NULL); return (UDisksInhibitCookie* ) &udisks_daemon_util_inhibit_system_sync; #endif }
/** * udisks_daemon_util_setup_by_user: * @daemon: A #UDisksDaemon. * @object: The #GDBusObject that the call is on or %NULL. * @user: The user in question. * * Checks whether the device represented by @object (if any) has been * setup by @user. * * Returns: %TRUE if @object has been set-up by @user, %FALSE if not. */ gboolean udisks_daemon_util_setup_by_user (UDisksDaemon *daemon, UDisksObject *object, uid_t user) { gboolean ret; UDisksBlock *block = NULL; UDisksPartition *partition = NULL; UDisksState *state; uid_t setup_by_user; UDisksObject *crypto_object; ret = FALSE; state = udisks_daemon_get_state (daemon); block = udisks_object_get_block (object); if (block == NULL) goto out; partition = udisks_object_get_partition (object); /* loop devices */ if (udisks_state_has_loop (state, udisks_block_get_device (block), &setup_by_user)) { if (setup_by_user == user) { ret = TRUE; goto out; } } /* partition of a loop device */ if (partition != NULL) { UDisksObject *partition_object = NULL; partition_object = udisks_daemon_find_object (daemon, udisks_partition_get_table (partition)); if (partition_object != NULL) { if (udisks_daemon_util_setup_by_user (daemon, partition_object, user)) { ret = TRUE; g_object_unref (partition_object); goto out; } g_object_unref (partition_object); } } /* LUKS devices */ crypto_object = udisks_daemon_find_object (daemon, udisks_block_get_crypto_backing_device (block)); if (crypto_object != NULL) { UDisksBlock *crypto_block; crypto_block = udisks_object_peek_block (crypto_object); if (udisks_state_find_unlocked_luks (state, udisks_block_get_device_number (crypto_block), &setup_by_user)) { if (setup_by_user == user) { ret = TRUE; g_object_unref (crypto_object); goto out; } } g_object_unref (crypto_object); } /* MDRaid devices */ if (g_strcmp0 (udisks_block_get_mdraid (block), "/") != 0) { uid_t started_by_user; if (udisks_state_has_mdraid (state, udisks_block_get_device_number (block), &started_by_user)) { if (started_by_user == user) { ret = TRUE; goto out; } } } out: g_clear_object (&partition); g_clear_object (&block); return ret; }
static gboolean sendmail_send_to_sync (CamelTransport *transport, CamelMimeMessage *message, CamelAddress *from, CamelAddress *recipients, gboolean *out_sent_message_saved, GCancellable *cancellable, GError **error) { CamelHeaderRaw *header, *savedbcc, *n, *tail; const gchar *from_addr, *addr; GPtrArray *argv_arr; gint i, len, fd[2], nullfd, wstat; CamelStream *filter; CamelMimeFilter *crlf; sigset_t mask, omask; CamelStream *out; CamelSendmailSettings *settings; const gchar *binary = SENDMAIL_PATH; gchar *custom_binary = NULL, *custom_args = NULL; gboolean success; pid_t pid; success = camel_internet_address_get ( CAMEL_INTERNET_ADDRESS (from), 0, NULL, &from_addr); if (!success) { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("Failed to read From address")); return FALSE; } settings = CAMEL_SENDMAIL_SETTINGS (camel_service_ref_settings (CAMEL_SERVICE (transport))); if (!camel_sendmail_settings_get_send_in_offline (settings)) { CamelSession *session; gboolean is_online; session = camel_service_ref_session (CAMEL_SERVICE (transport)); is_online = session && camel_session_get_online (session); g_clear_object (&session); if (!is_online) { g_set_error ( error, CAMEL_SERVICE_ERROR, CAMEL_SERVICE_ERROR_UNAVAILABLE, _("Message send in offline mode is disabled")); return FALSE; } } if (camel_sendmail_settings_get_use_custom_binary (settings)) { custom_binary = camel_sendmail_settings_dup_custom_binary (settings); if (custom_binary && *custom_binary) binary = custom_binary; } if (camel_sendmail_settings_get_use_custom_args (settings)) { custom_args = camel_sendmail_settings_dup_custom_args (settings); /* means no arguments used */ if (!custom_args) custom_args = g_strdup (""); } g_object_unref (settings); len = camel_address_length (recipients); for (i = 0; i < len; i++) { success = camel_internet_address_get ( CAMEL_INTERNET_ADDRESS (recipients), i, NULL, &addr); if (!success) { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("Could not parse recipient list")); g_free (custom_binary); g_free (custom_args); return FALSE; } } argv_arr = parse_sendmail_args ( binary, custom_args ? custom_args : "-i -f %F -- %R", from_addr, recipients); if (!argv_arr) { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("Could not parse arguments")); g_free (custom_binary); g_free (custom_args); return FALSE; } /* unlink the bcc headers */ savedbcc = NULL; tail = (CamelHeaderRaw *) &savedbcc; header = (CamelHeaderRaw *) &CAMEL_MIME_PART (message)->headers; n = header->next; while (n != NULL) { if (!g_ascii_strcasecmp (n->name, "Bcc")) { header->next = n->next; tail->next = n; n->next = NULL; tail = n; } else { header = n; } n = header->next; } if (pipe (fd) == -1) { g_set_error ( error, G_IO_ERROR, g_io_error_from_errno (errno), _("Could not create pipe to '%s': %s: " "mail not sent"), binary, g_strerror (errno)); /* restore the bcc headers */ header->next = savedbcc; g_free (custom_binary); g_free (custom_args); g_ptr_array_free (argv_arr, TRUE); return FALSE; } /* Block SIGCHLD so the calling application doesn't notice * sendmail exiting before we do. */ sigemptyset (&mask); sigaddset (&mask, SIGCHLD); sigprocmask (SIG_BLOCK, &mask, &omask); pid = fork (); switch (pid) { case -1: g_set_error ( error, G_IO_ERROR, g_io_error_from_errno (errno), _("Could not fork '%s': %s: " "mail not sent"), binary, g_strerror (errno)); close (fd[0]); close (fd[1]); sigprocmask (SIG_SETMASK, &omask, NULL); /* restore the bcc headers */ header->next = savedbcc; g_free (custom_binary); g_free (custom_args); g_ptr_array_free (argv_arr, TRUE); return FALSE; case 0: /* Child process */ nullfd = open ("/dev/null", O_RDWR); dup2 (fd[0], STDIN_FILENO); if (nullfd != -1) { /*dup2 (nullfd, STDOUT_FILENO); dup2 (nullfd, STDERR_FILENO);*/ close (nullfd); } close (fd[1]); execv (binary, (gchar **) argv_arr->pdata); _exit (255); } g_ptr_array_free (argv_arr, TRUE); /* Parent process. Write the message out. */ close (fd[0]); out = camel_stream_fs_new_with_fd (fd[1]); /* XXX Workaround for lame sendmail implementations * that can't handle CRLF eoln sequences. */ filter = camel_stream_filter_new (out); crlf = camel_mime_filter_crlf_new ( CAMEL_MIME_FILTER_CRLF_DECODE, CAMEL_MIME_FILTER_CRLF_MODE_CRLF_ONLY); camel_stream_filter_add (CAMEL_STREAM_FILTER (filter), crlf); g_object_unref (crlf); g_object_unref (out); out = (CamelStream *) filter; if (camel_data_wrapper_write_to_stream_sync ( CAMEL_DATA_WRAPPER (message), out, cancellable, error) == -1 || camel_stream_close (out, cancellable, error) == -1) { g_object_unref (out); g_prefix_error (error, _("Could not send message: ")); /* Wait for sendmail to exit. */ while (waitpid (pid, &wstat, 0) == -1 && errno == EINTR) ; sigprocmask (SIG_SETMASK, &omask, NULL); /* restore the bcc headers */ header->next = savedbcc; g_free (custom_binary); g_free (custom_args); return FALSE; } g_object_unref (out); /* Wait for sendmail to exit. */ while (waitpid (pid, &wstat, 0) == -1 && errno == EINTR) ; sigprocmask (SIG_SETMASK, &omask, NULL); /* restore the bcc headers */ header->next = savedbcc; if (!WIFEXITED (wstat)) { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("'%s' exited with signal %s: mail not sent."), binary, g_strsignal (WTERMSIG (wstat))); g_free (custom_binary); g_free (custom_args); return FALSE; } else if (WEXITSTATUS (wstat) != 0) { if (WEXITSTATUS (wstat) == 255) { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("Could not execute '%s': mail not sent."), binary); } else { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("'%s' exited with status %d: " "mail not sent."), binary, WEXITSTATUS (wstat)); } g_free (custom_binary); g_free (custom_args); return FALSE; } g_free (custom_binary); g_free (custom_args); return TRUE; }
static void contact_blocking_dialog_account_changed (GtkWidget *account_chooser, EmpathyContactBlockingDialog *self) { TpConnection *conn = empathy_account_chooser_get_connection ( EMPATHY_ACCOUNT_CHOOSER (account_chooser)); GPtrArray *blocked; GPtrArray *members; guint i; if (self->priv->block_account_changed > 0) return; if (conn == self->priv->current_conn) return; /* clear the lists of contacts */ gtk_list_store_clear (self->priv->blocked_contacts); gtk_list_store_clear (self->priv->completion_contacts); if (self->priv->current_conn != NULL) { g_signal_handlers_disconnect_by_func (self->priv->current_conn, blocked_contacts_changed_cb, self); g_clear_object (&self->priv->current_conn); } if (conn == NULL) return; DEBUG ("Account changed: %s", get_pretty_conn_name (conn)); self->priv->current_conn = g_object_ref (conn); tp_g_signal_connect_object (conn, "blocked-contacts-changed", G_CALLBACK (blocked_contacts_changed_cb), self, 0); blocked = tp_connection_get_blocked_contacts (conn); DEBUG ("%u contacts blocked on %s", blocked != NULL ? blocked->len : 0, get_pretty_conn_name (conn)); contact_blocking_dialog_add_blocked (self, blocked); DEBUG ("Loading contacts"); members = tp_connection_dup_contact_list (conn); for (i = 0; i < members->len; i++) { TpContact *contact = g_ptr_array_index (members, i); gchar *tmpstr; tmpstr = g_strdup_printf ("%s (%s)", tp_contact_get_alias (contact), tp_contact_get_identifier (contact)); gtk_list_store_insert_with_values (self->priv->completion_contacts, NULL, -1, COL_COMPLETION_IDENTIFIER, tp_contact_get_identifier (contact), COL_COMPLETION_TEXT, tmpstr, -1); g_free (tmpstr); } g_ptr_array_unref (members); }
static void gtk_application_impl_dbus_startup (GtkApplicationImpl *impl, gboolean register_session) { GtkApplicationImplDBus *dbus = (GtkApplicationImplDBus *) impl; static gchar *client_id; GError *error = NULL; GVariant *res; dbus->session = g_application_get_dbus_connection (G_APPLICATION (impl->application)); if (!dbus->session) return; dbus->application_id = g_application_get_application_id (G_APPLICATION (impl->application)); dbus->object_path = g_application_get_dbus_object_path (G_APPLICATION (impl->application)); dbus->unique_name = g_dbus_connection_get_unique_name (dbus->session); if (client_id == NULL) { const gchar *desktop_autostart_id; desktop_autostart_id = g_getenv ("DESKTOP_AUTOSTART_ID"); /* Unset DESKTOP_AUTOSTART_ID in order to avoid child processes to * use the same client id. */ g_unsetenv ("DESKTOP_AUTOSTART_ID"); client_id = g_strdup (desktop_autostart_id ? desktop_autostart_id : ""); } g_debug ("Connecting to session manager"); dbus->sm_proxy = g_dbus_proxy_new_sync (dbus->session, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS, NULL, "org.gnome.SessionManager", "/org/gnome/SessionManager", "org.gnome.SessionManager", NULL, &error); if (error) { g_warning ("Failed to get a session proxy: %s", error->message); g_error_free (error); return; } /* FIXME: should we reuse the D-Bus application id here ? */ dbus->app_id = g_strdup (g_get_prgname ()); if (!register_session) return; g_debug ("Registering client '%s' '%s'", dbus->app_id, client_id); res = g_dbus_proxy_call_sync (dbus->sm_proxy, "RegisterClient", g_variant_new ("(ss)", dbus->app_id, client_id), G_DBUS_CALL_FLAGS_NONE, G_MAXINT, NULL, &error); if (error) { g_warning ("Failed to register client: %s", error->message); g_error_free (error); g_clear_object (&dbus->sm_proxy); return; } g_variant_get (res, "(o)", &dbus->client_path); g_variant_unref (res); g_debug ("Registered client at '%s'", dbus->client_path); dbus->client_proxy = g_dbus_proxy_new_sync (dbus->session, 0, NULL, "org.gnome.SessionManager", dbus->client_path, "org.gnome.SessionManager.ClientPrivate", NULL, &error); if (error) { g_warning ("Failed to get client proxy: %s", error->message); g_error_free (error); g_clear_object (&dbus->sm_proxy); g_free (dbus->client_path); dbus->client_path = NULL; return; } g_signal_connect (dbus->client_proxy, "g-signal", G_CALLBACK (client_proxy_signal), dbus); }
static gboolean write_checksum_file (GFile *parentdir, const char *name, const char *sha256, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; gsize bytes_written; int i; gs_unref_object GFile *parent = NULL; gs_unref_object GFile *child = NULL; gs_unref_object GOutputStream *out = NULL; gs_unref_ptrarray GPtrArray *components = NULL; if (!ostree_validate_checksum_string (sha256, error)) goto out; if (ostree_validate_checksum_string (name, NULL)) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Rev name '%s' looks like a checksum", name); goto out; } if (!ot_util_path_split_validate (name, &components, error)) goto out; if (components->len == 0) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Invalid empty ref name"); goto out; } parent = g_object_ref (parentdir); for (i = 0; i+1 < components->len; i++) { child = g_file_get_child (parent, (char*)components->pdata[i]); if (!gs_file_ensure_directory (child, FALSE, cancellable, error)) goto out; g_clear_object (&parent); parent = child; child = NULL; } child = g_file_get_child (parent, components->pdata[components->len - 1]); if ((out = (GOutputStream*)g_file_replace (child, NULL, FALSE, 0, cancellable, error)) == NULL) goto out; if (!g_output_stream_write_all (out, sha256, strlen (sha256), &bytes_written, cancellable, error)) goto out; if (!g_output_stream_write_all (out, "\n", 1, &bytes_written, cancellable, error)) goto out; if (!g_output_stream_close (out, cancellable, error)) goto out; ret = TRUE; out: return ret; }
static gboolean resolve_refspec (OstreeRepo *self, const char *remote, const char *ref, gboolean allow_noent, char **out_rev, GError **error) { gboolean ret = FALSE; __attribute__((unused)) GCancellable *cancellable = NULL; GError *temp_error = NULL; gs_free char *ret_rev = NULL; gs_unref_object GFile *child = NULL; g_return_val_if_fail (ref != NULL, FALSE); /* We intentionally don't allow a ref that looks like a checksum */ if (ostree_validate_checksum_string (ref, NULL)) { ret_rev = g_strdup (ref); } else if (remote != NULL) { child = ot_gfile_resolve_path_printf (self->remote_heads_dir, "%s/%s", remote, ref); if (!g_file_query_exists (child, NULL)) g_clear_object (&child); } else { child = g_file_resolve_relative_path (self->local_heads_dir, ref); if (!g_file_query_exists (child, NULL)) { g_clear_object (&child); child = g_file_resolve_relative_path (self->remote_heads_dir, ref); if (!g_file_query_exists (child, NULL)) { g_clear_object (&child); if (!find_ref_in_remotes (self, ref, &child, error)) goto out; } } } if (child) { if ((ret_rev = gs_file_load_contents_utf8 (child, NULL, &temp_error)) == NULL) { g_propagate_error (error, temp_error); g_prefix_error (error, "Couldn't open ref '%s': ", gs_file_get_path_cached (child)); goto out; } g_strchomp (ret_rev); if (!ostree_validate_checksum_string (ret_rev, error)) goto out; } else { if (!resolve_refspec_fallback (self, remote, ref, allow_noent, &ret_rev, cancellable, error)) goto out; } ot_transfer_out_value (out_rev, &ret_rev); ret = TRUE; out: return ret; }
static void move_caret_after_signature_inserted (EEditorPage *editor_page) { WebKitDOMDocument *document; WebKitDOMElement *element, *signature; WebKitDOMHTMLElement *body; WebKitDOMNodeList *paragraphs = NULL; gboolean top_signature; gboolean start_bottom; gboolean has_paragraphs_in_body = TRUE; g_return_if_fail (E_IS_EDITOR_PAGE (editor_page)); document = e_editor_page_get_document (editor_page); top_signature = use_top_signature (); start_bottom = start_typing_at_bottom (); body = webkit_dom_document_get_body (document); e_editor_page_block_selection_changed (editor_page); paragraphs = webkit_dom_document_query_selector_all (document, "[data-evo-paragraph]", NULL); signature = webkit_dom_document_query_selector (document, ".-x-evo-signature-wrapper", NULL); /* Situation when wrapped paragraph is just in signature and not in message body */ if (webkit_dom_node_list_get_length (paragraphs) == 1) { WebKitDOMNode *node; node = webkit_dom_node_list_item (paragraphs, 0); if (signature && webkit_dom_element_query_selector (signature, "[data-evo-paragraph]", NULL)) has_paragraphs_in_body = FALSE; /* Don't take the credentials into account. */ if (!webkit_dom_node_get_previous_sibling (node) && !element_has_id (WEBKIT_DOM_ELEMENT (node), "-x-evo-input-start")) has_paragraphs_in_body = FALSE; } /* * * Keeping Signatures in the beginning of composer * ------------------------------------------------ * * Purists are gonna blast me for this. * But there are so many people (read Outlook users) who want this. * And Evo is an exchange-client, Outlook-replacement etc. * So Here it goes :( * * -- Sankar * */ if (signature && top_signature) { WebKitDOMElement *spacer; spacer = prepare_top_signature_spacer (editor_page); webkit_dom_node_insert_before ( WEBKIT_DOM_NODE (body), WEBKIT_DOM_NODE (spacer), webkit_dom_node_get_next_sibling (WEBKIT_DOM_NODE (signature)), NULL); } if (webkit_dom_node_list_get_length (paragraphs) == 0) has_paragraphs_in_body = FALSE; element = webkit_dom_document_get_element_by_id (document, "-x-evo-input-start"); if (!signature) { if (start_bottom) { if (!element) { element = e_editor_dom_prepare_paragraph (editor_page, FALSE); webkit_dom_element_set_id (element, "-x-evo-input-start"); webkit_dom_node_append_child ( WEBKIT_DOM_NODE (body), WEBKIT_DOM_NODE (element), NULL); } } else element = WEBKIT_DOM_ELEMENT (body); goto move_caret; } /* When there is an option composer-reply-start-bottom set we have * to move the caret between reply and signature. */ if (!has_paragraphs_in_body) { element = e_editor_dom_prepare_paragraph (editor_page, FALSE); webkit_dom_element_set_id (element, "-x-evo-input-start"); if (top_signature) { if (start_bottom) { webkit_dom_node_append_child ( WEBKIT_DOM_NODE (body), WEBKIT_DOM_NODE (element), NULL); } else { webkit_dom_node_insert_before ( WEBKIT_DOM_NODE (body), WEBKIT_DOM_NODE (element), WEBKIT_DOM_NODE (signature), NULL); } } else { if (start_bottom) webkit_dom_node_insert_before ( WEBKIT_DOM_NODE (body), WEBKIT_DOM_NODE (element), WEBKIT_DOM_NODE (signature), NULL); else element = WEBKIT_DOM_ELEMENT (body); } } else { if (!element && top_signature) { element = e_editor_dom_prepare_paragraph (editor_page, FALSE); webkit_dom_element_set_id (element, "-x-evo-input-start"); if (start_bottom) { webkit_dom_node_append_child ( WEBKIT_DOM_NODE (body), WEBKIT_DOM_NODE (element), NULL); } else { webkit_dom_node_insert_before ( WEBKIT_DOM_NODE (body), WEBKIT_DOM_NODE (element), WEBKIT_DOM_NODE (signature), NULL); } } else if (element && top_signature && !start_bottom) { webkit_dom_node_insert_before ( WEBKIT_DOM_NODE (body), WEBKIT_DOM_NODE (element), WEBKIT_DOM_NODE (signature), NULL); } else if (element && start_bottom) { /* Leave it how it is */ } else element = WEBKIT_DOM_ELEMENT (body); } move_caret: if (element) { WebKitDOMDOMSelection *dom_selection = NULL; WebKitDOMDOMWindow *dom_window = NULL; WebKitDOMRange *range = NULL; dom_window = webkit_dom_document_get_default_view (document); dom_selection = webkit_dom_dom_window_get_selection (dom_window); range = webkit_dom_document_create_range (document); webkit_dom_range_select_node_contents ( range, WEBKIT_DOM_NODE (element), NULL); webkit_dom_range_collapse (range, TRUE, NULL); webkit_dom_dom_selection_remove_all_ranges (dom_selection); webkit_dom_dom_selection_add_range (dom_selection, range); g_clear_object (&dom_selection); g_clear_object (&dom_window); g_clear_object (&range); } if (start_bottom) e_editor_dom_scroll_to_caret (editor_page); g_clear_object (¶graphs); e_editor_dom_force_spell_check_in_viewport (editor_page); e_editor_page_unblock_selection_changed (editor_page); }
/** * udisks_daemon_util_check_authorization_sync: * @daemon: A #UDisksDaemon. * @object: (allow-none): The #GDBusObject that the call is on or %NULL. * @action_id: The action id to check for. * @options: (allow-none): A #GVariant to check for the <quote>auth.no_user_interaction</quote> option or %NULL. * @message: The message to convey (use N_). * @invocation: The invocation to check for. * * Checks if the caller represented by @invocation is authorized for * the action identified by @action_id, optionally displaying @message * if authentication is needed. Additionally, if the caller is not * authorized, the appropriate error is already returned to the caller * via @invocation. * * The calling thread is blocked for the duration of the authorization * check which could be a very long time since it may involve * presenting an authentication dialog and having a human user use * it. If <quote>auth.no_user_interaction</quote> in @options is %TRUE * no authentication dialog will be presented and the check is not * expected to take a long time. * * See <xref linkend="udisks-polkit-details"/> for the variables that * can be used in @message but note that not all variables can be used * in all checks. For example, any check involving a #UDisksDrive or a * #UDisksBlock object can safely include the fragment * <quote>$(drive)</quote> since it will always expand to the name of * the drive, e.g. <quote>INTEL SSDSA2MH080G1GC (/dev/sda1)</quote> or * the block device file e.g. <quote>/dev/vg_lucifer/lv_root</quote> * or <quote>/dev/sda1</quote>. However this won't work for operations * that isn't on a drive or block device, for example calls on the * <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager.top_of_page">Manager</link> * object. * * Returns: %TRUE if caller is authorized, %FALSE if not. */ gboolean udisks_daemon_util_check_authorization_sync (UDisksDaemon *daemon, UDisksObject *object, const gchar *action_id, GVariant *options, const gchar *message, GDBusMethodInvocation *invocation) { PolkitAuthority *authority = NULL; PolkitSubject *subject = NULL; PolkitDetails *details = NULL; PolkitCheckAuthorizationFlags flags = POLKIT_CHECK_AUTHORIZATION_FLAGS_NONE; PolkitAuthorizationResult *result = NULL; GError *error = NULL; gboolean ret = FALSE; UDisksBlock *block = NULL; UDisksDrive *drive = NULL; UDisksPartition *partition = NULL; UDisksObject *block_object = NULL; UDisksObject *drive_object = NULL; gboolean auth_no_user_interaction = FALSE; const gchar *details_device = NULL; gchar *details_drive = NULL; authority = udisks_daemon_get_authority (daemon); if (authority == NULL) { ret = check_authorization_no_polkit (daemon, object, action_id, options, message, invocation); goto out; } subject = polkit_system_bus_name_new (g_dbus_method_invocation_get_sender (invocation)); if (options != NULL) { g_variant_lookup (options, "auth.no_user_interaction", "b", &auth_no_user_interaction); } if (!auth_no_user_interaction) flags = POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION; details = polkit_details_new (); polkit_details_insert (details, "polkit.message", message); polkit_details_insert (details, "polkit.gettext_domain", "udisks2"); /* Find drive associated with the block device, if any */ if (object != NULL) { block = udisks_object_get_block (object); if (block != NULL) { block_object = g_object_ref (object); drive_object = udisks_daemon_find_object (daemon, udisks_block_get_drive (block)); if (drive_object != NULL) drive = udisks_object_get_drive (drive_object); } partition = udisks_object_get_partition (object); if (drive == NULL) drive = udisks_object_get_drive (object); } if (block != NULL) details_device = udisks_block_get_preferred_device (block); /* If we have a drive, use vendor/model in the message (in addition to Block:preferred-device) */ if (drive != NULL) { gchar *s; const gchar *vendor; const gchar *model; vendor = udisks_drive_get_vendor (drive); model = udisks_drive_get_model (drive); if (vendor == NULL) vendor = ""; if (model == NULL) model = ""; if (strlen (vendor) > 0 && strlen (model) > 0) s = g_strdup_printf ("%s %s", vendor, model); else if (strlen (vendor) > 0) s = g_strdup (vendor); else s = g_strdup (model); if (block != NULL) { details_drive = g_strdup_printf ("%s (%s)", s, udisks_block_get_preferred_device (block)); } else { details_drive = s; s = NULL; } g_free (s); _safe_polkit_details_insert (details, "drive.wwn", udisks_drive_get_wwn (drive)); _safe_polkit_details_insert (details, "drive.serial", udisks_drive_get_serial (drive)); _safe_polkit_details_insert (details, "drive.vendor", udisks_drive_get_vendor (drive)); _safe_polkit_details_insert (details, "drive.model", udisks_drive_get_model (drive)); _safe_polkit_details_insert (details, "drive.revision", udisks_drive_get_revision (drive)); if (udisks_drive_get_removable (drive)) { const gchar *const *media_compat; GString *media_compat_str; const gchar *sep = ","; polkit_details_insert (details, "drive.removable", "true"); _safe_polkit_details_insert (details, "drive.removable.bus", udisks_drive_get_connection_bus (drive)); media_compat_str = g_string_new (NULL); media_compat = udisks_drive_get_media_compatibility (drive); if (media_compat) { guint i; for (i = 0; media_compat[i] && strlen(media_compat[i]); i++) { if (i) g_string_append (media_compat_str, sep); g_string_append (media_compat_str, media_compat[i]); } } _safe_polkit_details_insert (details, "drive.removable.media", media_compat_str->str); g_string_free (media_compat_str, TRUE); } } if (block != NULL) { _safe_polkit_details_insert (details, "id.type", udisks_block_get_id_type (block)); _safe_polkit_details_insert (details, "id.usage", udisks_block_get_id_usage (block)); _safe_polkit_details_insert (details, "id.version", udisks_block_get_id_version (block)); _safe_polkit_details_insert (details, "id.label", udisks_block_get_id_label (block)); _safe_polkit_details_insert (details, "id.uuid", udisks_block_get_id_uuid (block)); } if (partition != NULL) { _safe_polkit_details_insert_int (details, "partition.number", udisks_partition_get_number (partition)); _safe_polkit_details_insert (details, "partition.type", udisks_partition_get_type_ (partition)); _safe_polkit_details_insert_uint64 (details, "partition.flags", udisks_partition_get_flags (partition)); _safe_polkit_details_insert (details, "partition.name", udisks_partition_get_name (partition)); _safe_polkit_details_insert (details, "partition.uuid", udisks_partition_get_uuid (partition)); } /* Fall back to Block:preferred-device */ if (details_drive == NULL && block != NULL) details_drive = udisks_block_dup_preferred_device (block); if (details_device != NULL) polkit_details_insert (details, "device", details_device); if (details_drive != NULL) polkit_details_insert (details, "drive", details_drive); error = NULL; result = polkit_authority_check_authorization_sync (authority, subject, action_id, details, flags, NULL, /* GCancellable* */ &error); if (result == NULL) { if (error->domain != POLKIT_ERROR) { /* assume polkit authority is not available (e.g. could be the service * manager returning org.freedesktop.systemd1.Masked) */ g_error_free (error); ret = check_authorization_no_polkit (daemon, object, action_id, options, message, invocation); } else { g_dbus_method_invocation_return_error (invocation, UDISKS_ERROR, UDISKS_ERROR_FAILED, "Error checking authorization: %s (%s, %d)", error->message, g_quark_to_string (error->domain), error->code); g_error_free (error); } goto out; } if (!polkit_authorization_result_get_is_authorized (result)) { if (polkit_authorization_result_get_dismissed (result)) g_dbus_method_invocation_return_error_literal (invocation, UDISKS_ERROR, UDISKS_ERROR_NOT_AUTHORIZED_DISMISSED, "The authentication dialog was dismissed"); else g_dbus_method_invocation_return_error_literal (invocation, UDISKS_ERROR, polkit_authorization_result_get_is_challenge (result) ? UDISKS_ERROR_NOT_AUTHORIZED_CAN_OBTAIN : UDISKS_ERROR_NOT_AUTHORIZED, "Not authorized to perform operation"); goto out; } ret = TRUE; out: g_free (details_drive); g_clear_object (&block_object); g_clear_object (&drive_object); g_clear_object (&block); g_clear_object (&partition); g_clear_object (&drive); g_clear_object (&subject); g_clear_object (&details); g_clear_object (&result); return ret; }
/* The error format used by the Google Tasks API doesn’t seem to be documented * anywhere, which is a little frustrating. Here’s an example of it: * { * "error": { * "errors": [ * { * "domain": "usageLimits", * "reason": "dailyLimitExceededUnreg", * "message": "Daily Limit for Unauthenticated Use Exceeded.", * "extendedHelp": "https://code.google.com/apis/console" * } * ], * "code": 403, * "message": "Daily Limit for Unauthenticated Use Exceeded." * } * } * or: * { * "error": { * "errors": [ * { * "domain": "global", * "reason": "authError", * "message": "Invalid Credentials", * "locationType": "header", * "location": "Authorization" * } * ], * "code": 401, * "message": "Invalid Credentials" * } * } */ static void parse_error_response (GDataService *self, GDataOperationType operation_type, guint status, const gchar *reason_phrase, const gchar *response_body, gint length, GError **error) { JsonParser *parser = NULL; /* owned */ JsonReader *reader = NULL; /* owned */ gint i; GError *child_error = NULL; if (response_body == NULL) { goto parent; } if (length == -1) { length = strlen (response_body); } parser = json_parser_new (); if (!json_parser_load_from_data (parser, response_body, length, &child_error)) { goto parent; } reader = json_reader_new (json_parser_get_root (parser)); /* Check that the outermost node is an object. */ if (!json_reader_is_object (reader)) { goto parent; } /* Grab the ‘error’ member, then its ‘errors’ member. */ if (!json_reader_read_member (reader, "error") || !json_reader_is_object (reader) || !json_reader_read_member (reader, "errors") || !json_reader_is_array (reader)) { goto parent; } /* Parse each of the errors. Return the first one, and print out any * others. */ for (i = 0; i < json_reader_count_elements (reader); i++) { const gchar *domain, *reason, *message, *extended_help; const gchar *location_type, *location; /* Parse the error. */ if (!json_reader_read_element (reader, i) || !json_reader_is_object (reader)) { goto parent; } json_reader_read_member (reader, "domain"); domain = json_reader_get_string_value (reader); json_reader_end_member (reader); json_reader_read_member (reader, "reason"); reason = json_reader_get_string_value (reader); json_reader_end_member (reader); json_reader_read_member (reader, "message"); message = json_reader_get_string_value (reader); json_reader_end_member (reader); json_reader_read_member (reader, "extendedHelp"); extended_help = json_reader_get_string_value (reader); json_reader_end_member (reader); json_reader_read_member (reader, "locationType"); location_type = json_reader_get_string_value (reader); json_reader_end_member (reader); json_reader_read_member (reader, "location"); location = json_reader_get_string_value (reader); json_reader_end_member (reader); /* End the error element. */ json_reader_end_element (reader); /* Create an error message, but only for the first error */ if (error == NULL || *error == NULL) { if (g_strcmp0 (domain, "usageLimits") == 0 && g_strcmp0 (reason, "dailyLimitExceededUnreg") == 0) { /* Daily Limit for Unauthenticated Use * Exceeded. */ g_set_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_API_QUOTA_EXCEEDED, _("You have made too many API " "calls recently. Please wait a " "few minutes and try again.")); } else if (g_strcmp0 (domain, "global") == 0 && (g_strcmp0 (reason, "authError") == 0 || g_strcmp0 (reason, "required") == 0)) { /* Authentication problem */ g_set_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_AUTHENTICATION_REQUIRED, _("You must be authenticated to " "do this.")); } else { /* Unknown or validation (protocol) error. Fall * back to working off the HTTP status code. */ g_warning ("Unknown error code ‘%s’ in domain " "‘%s’ received with location type " "‘%s’, location ‘%s’, extended help " "‘%s’ and message ‘%s’.", reason, domain, location_type, location, extended_help, message); goto parent; } } else { /* For all errors after the first, log the error in the * terminal. */ g_debug ("Error message received in response: domain " "‘%s’, reason ‘%s’, extended help ‘%s’, " "message ‘%s’, location type ‘%s’, location " "‘%s’.", domain, reason, extended_help, message, location_type, location); } } /* End the ‘errors’ and ‘error’ members. */ json_reader_end_element (reader); json_reader_end_element (reader); g_clear_object (&reader); g_clear_object (&parser); /* Ensure we’ve actually set an error message. */ g_assert (error == NULL || *error != NULL); return; parent: g_clear_object (&reader); g_clear_object (&parser); /* Chain up to the parent class */ GDATA_SERVICE_CLASS (gdata_tasks_service_parent_class)->parse_error_response (self, operation_type, status, reason_phrase, response_body, length, error); }
static void table_sorter_dispose (GObject *object) { ETableSorter *table_sorter = E_TABLE_SORTER (object); if (table_sorter->table_model_changed_id > 0) { g_signal_handler_disconnect ( table_sorter->source, table_sorter->table_model_changed_id); table_sorter->table_model_changed_id = 0; } if (table_sorter->table_model_row_changed_id > 0) { g_signal_handler_disconnect ( table_sorter->source, table_sorter->table_model_row_changed_id); table_sorter->table_model_row_changed_id = 0; } if (table_sorter->table_model_cell_changed_id > 0) { g_signal_handler_disconnect ( table_sorter->source, table_sorter->table_model_cell_changed_id); table_sorter->table_model_cell_changed_id = 0; } if (table_sorter->table_model_rows_inserted_id > 0) { g_signal_handler_disconnect ( table_sorter->source, table_sorter->table_model_rows_inserted_id); table_sorter->table_model_rows_inserted_id = 0; } if (table_sorter->table_model_rows_deleted_id > 0) { g_signal_handler_disconnect ( table_sorter->source, table_sorter->table_model_rows_deleted_id); table_sorter->table_model_rows_deleted_id = 0; } if (table_sorter->sort_info_changed_id > 0) { g_signal_handler_disconnect ( table_sorter->sort_info, table_sorter->sort_info_changed_id); table_sorter->sort_info_changed_id = 0; } if (table_sorter->group_info_changed_id > 0) { g_signal_handler_disconnect ( table_sorter->sort_info, table_sorter->group_info_changed_id); table_sorter->group_info_changed_id = 0; } g_clear_object (&table_sorter->sort_info); g_clear_object (&table_sorter->full_header); g_clear_object (&table_sorter->source); table_sorter_clean (table_sorter); /* Chain up to parent's dispose() method. */ G_OBJECT_CLASS (e_table_sorter_parent_class)->dispose (object); }
int main (int argc, char *argv[]) { gint ret = 1; GError *error = NULL; gchar *s = NULL; GOptionContext *o = NULL; gint n; GSList *uris = NULL; GSList *l; bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); have_gtk = gtk_init_check (&argc, &argv); main_loop = g_main_loop_new (NULL, FALSE); udisks_client = udisks_client_new_sync (NULL, &error); if (udisks_client == NULL) { g_printerr (_("Error connecting to udisks daemon: %s (%s, %d)"), error->message, g_quark_to_string (error->domain), error->code); g_error_free (error); goto out; } o = g_option_context_new (NULL); g_option_context_set_help_enabled (o, FALSE); g_option_context_set_summary (o, _("Attach and mount one or more disk image files.")); g_option_context_add_main_entries (o, opt_entries, GETTEXT_PACKAGE); if (!g_option_context_parse (o, &argc, &argv, NULL)) { s = g_option_context_get_help (o, FALSE, NULL); g_printerr ("%s", s); g_free (s); goto out; } if (argc > 1) { for (n = 1; n < argc; n++) uris = g_slist_prepend (uris, g_strdup (argv[n])); uris = g_slist_reverse (uris); } else { if (!have_gtk) { show_error ("No files given and GTK+ not available"); goto out; } else { uris = do_filechooser (); } } /* Files to attach are positional arguments */ for (l = uris; l != NULL; l = l->next) { const gchar *uri; gchar *filename; GUnixFDList *fd_list = NULL; GVariantBuilder options_builder; gint fd; gchar *loop_object_path = NULL; GFile *file; uri = l->data; file = g_file_new_for_commandline_arg (uri); filename = g_file_get_path (file); g_object_unref (file); if (filename == NULL) { show_error (_("Cannot open `%s' - maybe the volume isn't mounted?"), uri); goto done_with_image; } fd = open (filename, opt_writable ? O_RDWR : O_RDONLY); if (fd == -1) { show_error (_("Error opening `%s': %m"), filename); goto done_with_image; } g_variant_builder_init (&options_builder, G_VARIANT_TYPE_VARDICT); if (!opt_writable) g_variant_builder_add (&options_builder, "{sv}", "read-only", g_variant_new_boolean (TRUE)); fd_list = g_unix_fd_list_new_from_array (&fd, 1); /* adopts the fd */ /* Set up the disk image... */ error = NULL; if (!udisks_manager_call_loop_setup_sync (udisks_client_get_manager (udisks_client), g_variant_new_handle (0), g_variant_builder_end (&options_builder), fd_list, &loop_object_path, NULL, /* out_fd_list */ NULL, /* GCancellable */ &error)) { show_error (_("Error attaching disk image: %s (%s, %d)"), error->message, g_quark_to_string (error->domain), error->code); g_clear_error (&error); goto done_with_image; } /* Note that the desktop automounter is responsible for mounting, * unlocking etc. partitions etc. inside the image... */ done_with_image: g_clear_object (&fd_list); g_free (filename); g_free (loop_object_path); } /* for each image */ ret = 0; out: if (main_loop != NULL) g_main_loop_unref (main_loop); g_slist_free_full (uris, g_free); g_clear_object (&udisks_client); return ret; }
static void locations_dialog_destroy (GtkWidget *widget) { g_clear_object (&tracker_preferences); }
gboolean ostree_builtin_commit (int argc, char **argv, GCancellable *cancellable, GError **error) { GOptionContext *context; gs_unref_object OstreeRepo *repo = NULL; gboolean ret = FALSE; gboolean skip_commit = FALSE; gs_unref_object GFile *arg = NULL; gs_free char *parent = NULL; gs_free char *commit_checksum = NULL; gs_unref_object GFile *root = NULL; gs_unref_variant GVariant *metadata = NULL; gs_unref_variant GVariant *detached_metadata = NULL; gs_unref_object OstreeMutableTree *mtree = NULL; gs_free char *tree_type = NULL; gs_unref_hashtable GHashTable *mode_adds = NULL; OstreeRepoCommitModifierFlags flags = 0; OstreeRepoCommitModifier *modifier = NULL; OstreeRepoTransactionStats stats; context = g_option_context_new ("[PATH] - Commit a new revision"); if (!ostree_option_context_parse (context, options, &argc, &argv, OSTREE_BUILTIN_FLAG_NONE, &repo, cancellable, error)) goto out; if (opt_statoverride_file) { if (!parse_statoverride_file (&mode_adds, cancellable, error)) goto out; } if (opt_metadata_strings) { if (!parse_keyvalue_strings (opt_metadata_strings, &metadata, error)) goto out; } if (opt_detached_metadata_strings) { if (!parse_keyvalue_strings (opt_detached_metadata_strings, &detached_metadata, error)) goto out; } if (!opt_branch) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, "A branch must be specified with --branch"); goto out; } if (opt_no_xattrs) flags |= OSTREE_REPO_COMMIT_MODIFIER_FLAGS_SKIP_XATTRS; if (opt_generate_sizes) flags |= OSTREE_REPO_COMMIT_MODIFIER_FLAGS_GENERATE_SIZES; if (opt_disable_fsync) ostree_repo_set_disable_fsync (repo, TRUE); if (flags != 0 || opt_owner_uid >= 0 || opt_owner_gid >= 0 || opt_statoverride_file != NULL || opt_no_xattrs) { modifier = ostree_repo_commit_modifier_new (flags, commit_filter, mode_adds, NULL); } if (!ostree_repo_resolve_rev (repo, opt_branch, TRUE, &parent, error)) goto out; if (!opt_subject && !opt_body) { if (!commit_editor (repo, opt_branch, &opt_subject, &opt_body, cancellable, error)) goto out; } if (!opt_subject) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, "A subject must be specified with --subject"); goto out; } if (!ostree_repo_prepare_transaction (repo, NULL, cancellable, error)) goto out; if (opt_link_checkout_speedup && !ostree_repo_scan_hardlinks (repo, cancellable, error)) goto out; mtree = ostree_mutable_tree_new (); if (argc <= 1 && (opt_trees == NULL || opt_trees[0] == NULL)) { char *current_dir = g_get_current_dir (); arg = g_file_new_for_path (current_dir); g_free (current_dir); if (!ostree_repo_write_directory_to_mtree (repo, arg, mtree, modifier, cancellable, error)) goto out; } else if (opt_trees != NULL) { const char *const*tree_iter; const char *tree; const char *eq; for (tree_iter = (const char *const*)opt_trees; *tree_iter; tree_iter++) { tree = *tree_iter; eq = strchr (tree, '='); if (!eq) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Missing type in tree specification '%s'", tree); goto out; } g_free (tree_type); tree_type = g_strndup (tree, eq - tree); tree = eq + 1; g_clear_object (&arg); if (strcmp (tree_type, "dir") == 0) { arg = g_file_new_for_path (tree); if (!ostree_repo_write_directory_to_mtree (repo, arg, mtree, modifier, cancellable, error)) goto out; } else if (strcmp (tree_type, "tar") == 0) { arg = g_file_new_for_path (tree); if (!ostree_repo_write_archive_to_mtree (repo, arg, mtree, modifier, opt_tar_autocreate_parents, cancellable, error)) goto out; } else if (strcmp (tree_type, "ref") == 0) { if (!ostree_repo_read_commit (repo, tree, &arg, NULL, cancellable, error)) goto out; if (!ostree_repo_write_directory_to_mtree (repo, arg, mtree, modifier, cancellable, error)) goto out; } else { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Invalid tree type specification '%s'", tree_type); goto out; } } } else { g_assert (argc > 1); arg = g_file_new_for_path (argv[1]); if (!ostree_repo_write_directory_to_mtree (repo, arg, mtree, modifier, cancellable, error)) goto out; } if (mode_adds && g_hash_table_size (mode_adds) > 0) { GHashTableIter hash_iter; gpointer key, value; g_hash_table_iter_init (&hash_iter, mode_adds); while (g_hash_table_iter_next (&hash_iter, &key, &value)) { g_printerr ("Unmatched statoverride path: %s\n", (char*)key); } g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Unmatched statoverride paths"); goto out; } if (!ostree_repo_write_mtree (repo, mtree, &root, cancellable, error)) goto out; if (opt_skip_if_unchanged && parent) { gs_unref_object GFile *parent_root; if (!ostree_repo_read_commit (repo, parent, &parent_root, NULL, cancellable, error)) goto out; if (g_file_equal (root, parent_root)) skip_commit = TRUE; } if (!skip_commit) { if (!ostree_repo_write_commit (repo, parent, opt_subject, opt_body, metadata, OSTREE_REPO_FILE (root), &commit_checksum, cancellable, error)) goto out; if (detached_metadata) { if (!ostree_repo_write_commit_detached_metadata (repo, commit_checksum, detached_metadata, cancellable, error)) goto out; } #ifdef HAVE_GPGME if (opt_key_ids) { char **iter; for (iter = opt_key_ids; iter && *iter; iter++) { const char *keyid = *iter; if (!ostree_repo_sign_commit (repo, commit_checksum, keyid, opt_gpg_homedir, cancellable, error)) goto out; } } #endif ostree_repo_transaction_set_ref (repo, NULL, opt_branch, commit_checksum); if (!ostree_repo_commit_transaction (repo, &stats, cancellable, error)) goto out; } else { commit_checksum = g_strdup (parent); } if (opt_table_output) { g_print ("Commit: %s\n", commit_checksum); g_print ("Metadata Total: %u\n", stats.metadata_objects_total); g_print ("Metadata Written: %u\n", stats.metadata_objects_written); g_print ("Content Total: %u\n", stats.content_objects_total); g_print ("Content Written: %u\n", stats.content_objects_written); g_print ("Content Bytes Written: %" G_GUINT64_FORMAT "\n", stats.content_bytes_written); } else { g_print ("%s\n", commit_checksum); } ret = TRUE; out: if (repo) ostree_repo_abort_transaction (repo, cancellable, NULL); if (context) g_option_context_free (context); if (modifier) ostree_repo_commit_modifier_unref (modifier); return ret; }
static void do_lookup_by_name (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { const char *hostname = task_data; struct addrinfo *res = NULL; GList *addresses; gint retval; retval = getaddrinfo (hostname, NULL, &addrinfo_hints, &res); if (retval == 0) { struct addrinfo *ai; GSocketAddress *sockaddr; GInetAddress *addr; addresses = NULL; for (ai = res; ai; ai = ai->ai_next) { sockaddr = g_socket_address_new_from_native (ai->ai_addr, ai->ai_addrlen); if (!sockaddr) continue; if (!G_IS_INET_SOCKET_ADDRESS (sockaddr)) { g_clear_object (&sockaddr); continue; } addr = g_object_ref (g_inet_socket_address_get_address ((GInetSocketAddress *)sockaddr)); addresses = g_list_prepend (addresses, addr); g_object_unref (sockaddr); } if (addresses != NULL) { addresses = g_list_reverse (addresses); g_task_return_pointer (task, addresses, (GDestroyNotify)g_resolver_free_addresses); } else { /* All addresses failed to be converted to GSocketAddresses. */ g_task_return_new_error (task, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND, _("Error resolving “%s”: %s"), hostname, _("No valid addresses were found")); } } else { g_task_return_new_error (task, G_RESOLVER_ERROR, g_resolver_error_from_addrinfo_error (retval), _("Error resolving “%s”: %s"), hostname, gai_strerror (retval)); } if (res) freeaddrinfo (res); }
static void gom_repository_find_cb (GomAdapter *adapter, gpointer user_data) { GSimpleAsyncResult *simple = user_data; GomCommandBuilder *builder = NULL; GomResourceGroup *ret; GomRepository *repository = NULL; GomCommand *command; GomCursor *cursor; GomFilter *filter; GError *error = NULL; GType resource_type; GAsyncQueue *queue; guint count; g_return_if_fail(GOM_IS_ADAPTER(adapter)); g_return_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple)); repository = GOM_REPOSITORY(g_async_result_get_source_object(G_ASYNC_RESULT(simple))); g_assert(GOM_IS_REPOSITORY(repository)); resource_type = GPOINTER_TO_SIZE(g_object_get_data(G_OBJECT(simple), "resource-type")); g_assert(g_type_is_a(resource_type, GOM_TYPE_RESOURCE)); filter = g_object_get_data(G_OBJECT(simple), "filter"); g_assert(!filter || GOM_IS_FILTER(filter)); queue = g_object_get_data(G_OBJECT(simple), "queue"); builder = g_object_new(GOM_TYPE_COMMAND_BUILDER, "adapter", adapter, "resource-type", resource_type, "filter", filter, NULL); command = gom_command_builder_build_count(builder); g_assert(GOM_IS_COMMAND(command)); if (!gom_command_execute(command, &cursor, &error)) { g_simple_async_result_take_error(simple, error); goto out; } g_assert(GOM_IS_CURSOR(cursor)); if (!gom_cursor_next(cursor)) { g_assert_not_reached(); goto out; } count = gom_cursor_get_column_uint(cursor, 0); ret = g_object_new(GOM_TYPE_RESOURCE_GROUP, "adapter", adapter, "count", count, "filter", filter, "repository", repository, "resource-type", resource_type, NULL); g_simple_async_result_set_op_res_gpointer(simple, ret, g_object_unref); out: if (!queue) g_simple_async_result_complete_in_idle(simple); else g_async_queue_push(queue, GINT_TO_POINTER(TRUE)); g_object_unref(repository); g_clear_object(&cursor); g_clear_object(&command); g_clear_object(&builder); }
void e_mail_shell_view_private_constructed (EMailShellView *mail_shell_view) { EMailShellViewPrivate *priv = mail_shell_view->priv; EMailShellContent *mail_shell_content; EMailShellSidebar *mail_shell_sidebar; EShell *shell; EShellView *shell_view; EShellBackend *shell_backend; EShellContent *shell_content; EShellSidebar *shell_sidebar; EShellTaskbar *shell_taskbar; EShellWindow *shell_window; EShellSearchbar *searchbar; EMFolderTree *folder_tree; EActionComboBox *combo_box; ERuleContext *context; EFilterRule *rule = NULL; GtkTreeSelection *selection; GtkUIManager *ui_manager; GtkWidget *message_list; GSettings *settings; EMailLabelListStore *label_store; EMailBackend *backend; EMailSession *session; EMailReader *reader; EMailView *mail_view; EMailDisplay *display; const gchar *source; guint merge_id; gint ii = 0; shell_view = E_SHELL_VIEW (mail_shell_view); shell_backend = e_shell_view_get_shell_backend (shell_view); shell_content = e_shell_view_get_shell_content (shell_view); shell_sidebar = e_shell_view_get_shell_sidebar (shell_view); shell_taskbar = e_shell_view_get_shell_taskbar (shell_view); shell_window = e_shell_view_get_shell_window (shell_view); ui_manager = e_shell_window_get_ui_manager (shell_window); shell = e_shell_window_get_shell (shell_window); backend = E_MAIL_BACKEND (shell_backend); session = e_mail_backend_get_session (backend); label_store = e_mail_ui_session_get_label_store ( E_MAIL_UI_SESSION (session)); e_shell_window_add_action_group (shell_window, "mail"); e_shell_window_add_action_group (shell_window, "mail-filter"); e_shell_window_add_action_group (shell_window, "mail-label"); e_shell_window_add_action_group (shell_window, "search-folders"); merge_id = gtk_ui_manager_new_merge_id (ui_manager); priv->label_merge_id = merge_id; /* Cache these to avoid lots of awkward casting. */ priv->mail_shell_backend = g_object_ref (shell_backend); priv->mail_shell_content = g_object_ref (shell_content); priv->mail_shell_sidebar = g_object_ref (shell_sidebar); mail_shell_sidebar = E_MAIL_SHELL_SIDEBAR (shell_sidebar); folder_tree = e_mail_shell_sidebar_get_folder_tree (mail_shell_sidebar); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_tree)); mail_shell_content = E_MAIL_SHELL_CONTENT (shell_content); mail_view = e_mail_shell_content_get_mail_view (mail_shell_content); searchbar = e_mail_shell_content_get_searchbar (mail_shell_content); combo_box = e_shell_searchbar_get_scope_combo_box (searchbar); reader = E_MAIL_READER (shell_content); display = e_mail_reader_get_mail_display (reader); message_list = e_mail_reader_get_message_list (reader); em_folder_tree_set_selectable_widget (folder_tree, message_list); /* The folder tree and scope combo box are both insensitive * when searching beyond the currently selected folder. */ e_binding_bind_property ( folder_tree, "sensitive", combo_box, "sensitive", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); combo_box = e_shell_searchbar_get_filter_combo_box (searchbar); g_signal_connect_object ( combo_box, "changed", G_CALLBACK (mail_shell_view_search_filter_changed_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( folder_tree, "folder-selected", G_CALLBACK (mail_shell_view_folder_tree_selected_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( folder_tree, "key-press-event", G_CALLBACK (mail_shell_view_folder_tree_key_press_event_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( folder_tree, "popup-event", G_CALLBACK (mail_shell_view_folder_tree_popup_event_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( message_list, "key-press", G_CALLBACK (mail_shell_view_message_list_key_press_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( message_list, "popup-menu", G_CALLBACK (mail_shell_view_message_list_popup_menu_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( message_list, "right-click", G_CALLBACK (mail_shell_view_message_list_right_click_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( reader, "changed", G_CALLBACK (mail_shell_view_reader_changed_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( mail_view, "update-actions", G_CALLBACK (mail_shell_view_reader_update_actions_cb), mail_shell_view, 0); g_signal_connect_object ( reader, "folder-loaded", G_CALLBACK (e_mail_view_update_view_instance), mail_view, G_CONNECT_SWAPPED); /* Use the same callback as "changed". */ g_signal_connect_object ( reader, "folder-loaded", G_CALLBACK (mail_shell_view_reader_changed_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( reader, "folder-loaded", G_CALLBACK (e_mail_shell_view_restore_state), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( label_store, "changed", G_CALLBACK (e_mail_shell_view_update_search_filter), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( display, "key-press-event", G_CALLBACK (mail_shell_view_key_press_event_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( display, "popup-event", G_CALLBACK (mail_shell_view_popup_event_cb), mail_shell_view, G_CONNECT_SWAPPED); g_signal_connect_object ( display, "status-message", G_CALLBACK (e_shell_taskbar_set_message), shell_taskbar, G_CONNECT_SWAPPED); g_signal_connect_object ( mail_shell_view, "toggled", G_CALLBACK (e_mail_shell_view_update_send_receive_menus), mail_shell_view, G_CONNECT_AFTER | G_CONNECT_SWAPPED); /* Need to keep the handler ID so we can disconnect it in * dispose(). The shell outlives us and we don't want it * invoking callbacks on finalized shell views. */ priv->prepare_for_quit_handler_id = g_signal_connect_object ( shell, "prepare-for-quit", G_CALLBACK (mail_shell_view_prepare_for_quit_cb), mail_shell_view, G_CONNECT_SWAPPED); e_mail_reader_init (reader, TRUE, FALSE); e_mail_shell_view_actions_init (mail_shell_view); e_mail_shell_view_update_search_filter (mail_shell_view); /* This binding must come after e_mail_reader_init(). */ e_binding_bind_property ( shell_content, "group-by-threads", mail_view, "group-by-threads", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); settings = e_util_ref_settings ("org.gnome.evolution.mail"); g_settings_bind ( settings, "vfolder-allow-expunge", mail_shell_view, "vfolder-allow-expunge", G_SETTINGS_BIND_GET); g_clear_object (&settings); /* Populate built-in rules for search entry popup menu. * Keep the assertions, please. If the conditions aren't * met we're going to crash anyway, just more mysteriously. */ context = E_SHELL_VIEW_GET_CLASS (shell_view)->search_context; source = E_FILTER_SOURCE_DEMAND; while ((rule = e_rule_context_next_rule (context, rule, source))) { if (!rule->system) continue; g_return_if_fail (ii < MAIL_NUM_SEARCH_RULES); priv->search_rules[ii++] = g_object_ref (rule); } g_return_if_fail (ii == MAIL_NUM_SEARCH_RULES); /* Now that we're all set up, simulate selecting a folder. */ g_signal_emit_by_name (selection, "changed"); }
static gboolean on_socket_input (GSocket *socket, GIOCondition condition, gpointer user_data) { CockpitRequest *request = user_data; guchar first_byte; GInputVector vector[1] = { { &first_byte, 1 } }; gint flags = G_SOCKET_MSG_PEEK; gboolean redirect_tls; gboolean is_tls; GSocketAddress *addr; GInetAddress *inet; GError *error = NULL; GIOStream *tls_stream; gssize num_read; num_read = g_socket_receive_message (socket, NULL, /* out GSocketAddress */ vector, 1, NULL, /* out GSocketControlMessage */ NULL, /* out num_messages */ &flags, NULL, /* GCancellable* */ &error); if (num_read < 0) { /* Just wait and try again */ if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) { g_error_free (error); return TRUE; } if (!should_suppress_request_error (error)) g_message ("couldn't read from socket: %s", error->message); cockpit_request_finish (request); g_error_free (error); return FALSE; } is_tls = TRUE; redirect_tls = FALSE; /* * TLS streams are guaranteed to start with octet 22.. this way we can distinguish them * from regular HTTP requests */ if (first_byte != 22 && first_byte != 0x80) { is_tls = FALSE; redirect_tls = request->web_server->redirect_tls; if (redirect_tls) { addr = g_socket_connection_get_local_address (G_SOCKET_CONNECTION (request->io), NULL); if (G_IS_INET_SOCKET_ADDRESS (addr)) { inet = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (addr)); redirect_tls = !g_inet_address_get_is_loopback (inet); } g_clear_object (&addr); } } if (is_tls) { tls_stream = g_tls_server_connection_new (request->io, request->web_server->certificate, &error); if (tls_stream == NULL) { g_warning ("couldn't create new TLS stream: %s", error->message); cockpit_request_finish (request); g_error_free (error); return FALSE; } if (cockpit_webserver_want_certificate) { g_object_set (tls_stream, "authentication-mode", G_TLS_AUTHENTICATION_REQUESTED, NULL); g_signal_connect (tls_stream, "accept-certificate", G_CALLBACK (on_accept_certificate), NULL); } g_object_unref (request->io); request->io = G_IO_STREAM (tls_stream); } else if (redirect_tls) { request->delayed_reply = 301; } start_request_input (request); /* No longer run *this* source */ return FALSE; }
void e_mail_shell_view_update_sidebar (EMailShellView *mail_shell_view) { EMailShellContent *mail_shell_content; EShellBackend *shell_backend; EShellSidebar *shell_sidebar; EShellView *shell_view; EShell *shell; EMailReader *reader; EMailView *mail_view; ESourceRegistry *registry; CamelStore *parent_store; CamelFolder *folder; CamelFolderInfoFlags flags = 0; CamelFolderSummary *folder_summary; MailFolderCache *folder_cache; MessageList *message_list; guint selected_count; GString *buffer, *title_short = NULL; gboolean store_is_local, is_inbox; const gchar *display_name; const gchar *folder_name; const gchar *uid; gchar *title; guint32 num_deleted; guint32 num_junked; guint32 num_junked_not_deleted; guint32 num_unread; guint32 num_visible; g_return_if_fail (E_IS_MAIL_SHELL_VIEW (mail_shell_view)); mail_shell_content = mail_shell_view->priv->mail_shell_content; mail_view = e_mail_shell_content_get_mail_view (mail_shell_content); shell_view = E_SHELL_VIEW (mail_shell_view); shell_backend = e_shell_view_get_shell_backend (shell_view); shell_sidebar = e_shell_view_get_shell_sidebar (shell_view); shell = e_shell_backend_get_shell (shell_backend); registry = e_shell_get_registry (shell); reader = E_MAIL_READER (mail_view); folder = e_mail_reader_ref_folder (reader); /* If no folder is selected, reset the sidebar banners * to their default values and stop. */ if (folder == NULL) { GtkAction *action; gchar *label; action = e_shell_view_get_action (shell_view); g_object_get (action, "label", &label, NULL); e_shell_sidebar_set_secondary_text (shell_sidebar, NULL); e_shell_view_set_title (shell_view, label); g_free (label); return; } folder_name = camel_folder_get_display_name (folder); parent_store = camel_folder_get_parent_store (folder); folder_summary = camel_folder_get_folder_summary (folder); folder_cache = e_mail_session_get_folder_cache ( e_mail_backend_get_session (E_MAIL_BACKEND (shell_backend))); mail_folder_cache_get_folder_info_flags (folder_cache, parent_store, folder_name, &flags); is_inbox = (flags & CAMEL_FOLDER_TYPE_MASK) == CAMEL_FOLDER_TYPE_INBOX; num_deleted = camel_folder_summary_get_deleted_count (folder_summary); num_junked = camel_folder_summary_get_junk_count (folder_summary); num_junked_not_deleted = camel_folder_summary_get_junk_not_deleted_count (folder_summary); num_unread = camel_folder_summary_get_unread_count (folder_summary); num_visible = camel_folder_summary_get_visible_count (folder_summary); buffer = g_string_sized_new (256); message_list = MESSAGE_LIST (e_mail_reader_get_message_list (reader)); selected_count = message_list_selected_count (message_list); if (selected_count > 1) g_string_append_printf ( buffer, ngettext ("%d selected, ", "%d selected, ", selected_count), selected_count); /* "Trash" folder (virtual or real) */ if (camel_folder_get_flags (folder) & CAMEL_FOLDER_IS_TRASH) { if (CAMEL_IS_VTRASH_FOLDER (folder)) { /* For a virtual Trash folder, count * the messages marked for deletion. */ g_string_append_printf ( buffer, ngettext ("%d deleted", "%d deleted", num_deleted), num_deleted); } else { /* For a regular Trash folder, just * count the visible messages. * * XXX Open question: what to do about messages * marked for deletion in Trash? Probably * this is the wrong question to be asking * anyway. Deleting a message in a real * Trash should permanently expunge the * message (if the server supports that), * which would eliminate this corner case. */ if (!e_mail_reader_get_hide_deleted (reader)) num_visible += num_deleted; g_string_append_printf ( buffer, ngettext ("%d deleted", "%d deleted", num_visible), num_visible); } /* "Junk" folder (virtual or real) */ } else if (camel_folder_get_flags (folder) & CAMEL_FOLDER_IS_JUNK) { if (e_mail_reader_get_hide_deleted (reader)) { /* Junk folder with deleted messages hidden. */ g_string_append_printf ( buffer, ngettext ("%d junk", "%d junk", num_junked_not_deleted), num_junked_not_deleted); } else { /* Junk folder with deleted messages visible. */ g_string_append_printf ( buffer, ngettext ("%d junk", "%d junk", num_junked), num_junked); } /* "Drafts" folder */ } else if (!is_inbox && em_utils_folder_is_drafts (registry, folder)) { g_string_append_printf ( buffer, ngettext ("%d draft", "%d drafts", num_visible), num_visible); /* "Outbox" folder */ } else if (!is_inbox && em_utils_folder_is_outbox (registry, folder)) { g_string_append_printf ( buffer, ngettext ("%d unsent", "%d unsent", num_visible), num_visible); /* "Sent" folder */ } else if (!is_inbox && em_utils_folder_is_sent (registry, folder)) { g_string_append_printf ( buffer, ngettext ("%d sent", "%d sent", num_visible), num_visible); /* Normal folder */ } else { if (!e_mail_reader_get_hide_deleted (reader)) num_visible += num_deleted - num_junked + num_junked_not_deleted; if (num_unread > 0 && selected_count <= 1) { g_string_append_printf ( buffer, ngettext ("%d unread, ", "%d unread, ", num_unread), num_unread); title_short = g_string_sized_new (64); g_string_append_printf ( title_short, ngettext ("%d unread", "%d unread", num_unread), num_unread); } g_string_append_printf ( buffer, ngettext ("%d total", "%d total", num_visible), num_visible); } uid = camel_service_get_uid (CAMEL_SERVICE (parent_store)); store_is_local = (g_strcmp0 (uid, E_MAIL_SESSION_LOCAL_UID) == 0); /* Choose a suitable folder name for displaying. */ display_name = folder_name; if (store_is_local) { if (strcmp (folder_name, "Drafts") == 0) display_name = _("Drafts"); else if (strcmp (folder_name, "Inbox") == 0) display_name = _("Inbox"); else if (strcmp (folder_name, "Outbox") == 0) display_name = _("Outbox"); else if (strcmp (folder_name, "Sent") == 0) display_name = _("Sent"); else if (strcmp (folder_name, "Templates") == 0) display_name = _("Templates"); else if (strcmp (folder_name, "Trash") == 0) display_name = _("Trash"); } if (strcmp (folder_name, "INBOX") == 0) display_name = _("Inbox"); if (title_short && title_short->len > 0) title = g_strdup_printf ("%s (%s)", display_name, title_short->str); else title = g_strdup (display_name); e_shell_sidebar_set_secondary_text (shell_sidebar, buffer->str); e_shell_view_set_title (shell_view, title); g_free (title); g_string_free (buffer, TRUE); if (title_short) g_string_free (title_short, TRUE); g_clear_object (&folder); }
gboolean check_bundle(const gchar *bundlename, gsize *size, gboolean verify, GError **error) { GError *ierror = NULL; GBytes *sig = NULL; GFile *bundlefile = NULL; GFileInputStream *bundlestream = NULL; guint64 sigsize; goffset offset; gboolean res = FALSE; r_context_begin_step("check_bundle", "Checking bundle", verify); if (!r_context()->config->keyring_path) { g_set_error(error, G_FILE_ERROR, G_FILE_ERROR_EXIST, "No keyring file provided"); goto out; } g_message("Reading bundle: %s", bundlename); bundlefile = g_file_new_for_path(bundlename); bundlestream = g_file_read(bundlefile, NULL, &ierror); if (bundlestream == NULL) { g_propagate_prefixed_error( error, ierror, "failed to open bundle for reading: "); goto out; } offset = sizeof(sigsize); res = g_seekable_seek(G_SEEKABLE(bundlestream), -offset, G_SEEK_END, NULL, &ierror); if (!res) { g_propagate_prefixed_error( error, ierror, "failed to seek to end of bundle: "); goto out; } offset = g_seekable_tell((GSeekable *)bundlestream); res = input_stream_read_uint64_all(G_INPUT_STREAM(bundlestream), &sigsize, NULL, &ierror); if (!res) { g_propagate_prefixed_error( error, ierror, "failed to read signature size from bundle: "); goto out; } offset -= sigsize; if (size) *size = offset; res = g_seekable_seek(G_SEEKABLE(bundlestream), offset, G_SEEK_SET, NULL, &ierror); if (!res) { g_propagate_prefixed_error( error, ierror, "failed to seek to start of bundle signature: "); goto out; } res = input_stream_read_bytes_all(G_INPUT_STREAM(bundlestream), &sig, sigsize, NULL, &ierror); if (!res) { g_propagate_prefixed_error( error, ierror, "failed to read signature from bundle: "); goto out; } if (verify) { g_message("Verifying bundle... "); /* the squashfs image size is in offset */ res = cms_verify_file(bundlename, sig, offset, &ierror); if (!res) { g_propagate_error(error, ierror); goto out; } } res = TRUE; out: g_clear_object(&bundlestream); g_clear_object(&bundlefile); g_clear_pointer(&sig, g_bytes_unref); r_context_end_step("check_bundle", res); return res; }
gchar * e_composer_dom_insert_signature (EEditorPage *editor_page, const gchar *content, gboolean is_html, const gchar *id, gboolean *set_signature_from_message, gboolean *check_if_signature_is_changed, gboolean *ignore_next_signature_change) { WebKitDOMDocument *document; WebKitDOMElement *signature_to_insert; WebKitDOMElement *insert_signature_in = NULL; WebKitDOMElement *signature_wrapper = NULL; WebKitDOMElement *element, *converted_signature = NULL; WebKitDOMHTMLElement *body; WebKitDOMHTMLCollection *signatures = NULL; gchar *new_signature_id = NULL; gchar *signature_text = NULL; gboolean top_signature, html_mode; gulong ii; g_return_val_if_fail (E_IS_EDITOR_PAGE (editor_page), NULL); g_return_val_if_fail (set_signature_from_message != NULL, NULL); g_return_val_if_fail (check_if_signature_is_changed != NULL, NULL); g_return_val_if_fail (ignore_next_signature_change != NULL, NULL); document = e_editor_page_get_document (editor_page); body = webkit_dom_document_get_body (document); /* "Edit as New Message" sets is_message_from_edit_as_new. * Always put the signature at the bottom for that case. */ top_signature = use_top_signature (); html_mode = e_editor_page_get_html_mode (editor_page); /* Create the DOM signature that is the same across all types of signatures. */ signature_to_insert = webkit_dom_document_create_element (document, "span", NULL); webkit_dom_element_set_class_name (signature_to_insert, "-x-evo-signature"); /* The combo box active ID is the signature's ESource UID. */ webkit_dom_element_set_id (signature_to_insert, id); insert_signature_in = signature_to_insert; /* The signature has no content usually it means it is set to None. */ if (!(content && *content)) goto insert; if (!is_html) { gchar *html; html = camel_text_to_html (content, 0, 0); if (html) { signature_text = html; } else signature_text = g_strdup (content); insert_signature_in = webkit_dom_document_create_element (document, "pre", NULL); webkit_dom_node_append_child ( WEBKIT_DOM_NODE (signature_to_insert), WEBKIT_DOM_NODE (insert_signature_in), NULL); } else signature_text = g_strdup (content); /* If inserting HTML signature in the plain text composer we have to convert it. */ if (is_html && !html_mode && !strstr (signature_text, "data-evo-signature-plain-text-mode")) { gchar *inner_text; /* Save the converted signature to avoid parsing it later again * while inserting it into the view. */ converted_signature = webkit_dom_document_create_element (document, "pre", NULL); webkit_dom_element_set_inner_html (converted_signature, signature_text, NULL); e_editor_dom_convert_element_from_html_to_plain_text (editor_page, converted_signature); inner_text = webkit_dom_html_element_get_inner_text (WEBKIT_DOM_HTML_ELEMENT (converted_signature)); g_free (signature_text); signature_text = inner_text ? g_strstrip (inner_text) : g_strdup (""); /* because of the -- \n check */ is_html = FALSE; } /* The signature dash convention ("-- \n") is specified * in the "Son of RFC 1036", section 4.3.2. * http://www.chemie.fu-berlin.de/outerspace/netnews/son-of-1036.html */ if (add_signature_delimiter ()) { const gchar *delim; const gchar *delim_nl; if (is_html) { delim = "-- <BR>"; delim_nl = "\n-- <BR>"; } else { delim = "-- \n"; delim_nl = "\n-- \n"; } /* Skip the delimiter if the signature already has one. */ if (g_ascii_strncasecmp (signature_text, delim, strlen (delim)) == 0) ; /* skip */ else if (e_util_strstrcase (signature_text, delim_nl) != NULL) ; /* skip */ else { WebKitDOMElement *pre_delimiter; pre_delimiter = webkit_dom_document_create_element (document, "pre", NULL); /* Always use the HTML delimiter as we are never in anything * like a strict plain text mode. */ webkit_dom_element_set_inner_html (pre_delimiter, "-- <br>", NULL); webkit_dom_node_append_child ( WEBKIT_DOM_NODE (insert_signature_in), WEBKIT_DOM_NODE (pre_delimiter), NULL); } } if (converted_signature) { WebKitDOMNode *node; while ((node = webkit_dom_node_get_first_child (WEBKIT_DOM_NODE (converted_signature)))) webkit_dom_node_append_child ( WEBKIT_DOM_NODE (insert_signature_in), node, NULL); remove_node (WEBKIT_DOM_NODE (converted_signature)); } else webkit_dom_element_insert_adjacent_html ( insert_signature_in, "beforeend", signature_text, NULL); element = webkit_dom_element_query_selector ( insert_signature_in, "[data-evo-signature-plain-text-mode]", NULL); if (element) webkit_dom_element_remove_attribute ( element, "data-evo-signature-plain-text-mode"); g_free (signature_text); insert: /* Remove the old signature and insert the new one. */ signatures = webkit_dom_document_get_elements_by_class_name_as_html_collection ( document, "-x-evo-signature-wrapper"); for (ii = webkit_dom_html_collection_get_length (signatures); ii--;) { WebKitDOMNode *wrapper, *signature; wrapper = webkit_dom_html_collection_item (signatures, ii); signature = webkit_dom_node_get_first_child (wrapper); /* Old messages will have the signature id in the name attribute, correct it. */ element_rename_attribute (WEBKIT_DOM_ELEMENT (signature), "name", "id"); /* When we are editing a message with signature, we need to unset the * active signature id as if the signature in the message was edited * by the user we would discard these changes. */ if (*set_signature_from_message && content) { if (*check_if_signature_is_changed) { /* Normalize the signature that we want to insert as the one in the * message already is normalized. */ webkit_dom_node_normalize (WEBKIT_DOM_NODE (signature_to_insert)); if (!webkit_dom_node_is_equal_node (WEBKIT_DOM_NODE (signature_to_insert), signature)) { /* Signature in the body is different than the one with the * same id, so set the active signature to None and leave * the signature that is in the body. */ new_signature_id = g_strdup ("none"); *ignore_next_signature_change = TRUE; } *check_if_signature_is_changed = FALSE; *set_signature_from_message = FALSE; } else { /* Load the signature and check if is it the same * as the signature in body or the user previously * changed it. */ new_signature_id = webkit_dom_element_get_id (WEBKIT_DOM_ELEMENT (signature)); *check_if_signature_is_changed = TRUE; } g_clear_object (&signatures); return new_signature_id; } /* If the top signature was set we have to remove the newline * that was inserted after it */ if (top_signature) { WebKitDOMElement *spacer; spacer = webkit_dom_document_query_selector ( document, ".-x-evo-top-signature-spacer", NULL); if (spacer) remove_node_if_empty (WEBKIT_DOM_NODE (spacer)); } /* Leave just one signature wrapper there as it will be reused. */ if (ii != 0) { remove_node (wrapper); } else { remove_node (signature); signature_wrapper = WEBKIT_DOM_ELEMENT (wrapper); } } if (signature_wrapper) { webkit_dom_node_append_child ( WEBKIT_DOM_NODE (signature_wrapper), WEBKIT_DOM_NODE (signature_to_insert), NULL); /* Insert a spacer below the top signature */ if (top_signature && content) { WebKitDOMElement *spacer; spacer = prepare_top_signature_spacer (editor_page); webkit_dom_node_insert_before ( WEBKIT_DOM_NODE (body), WEBKIT_DOM_NODE (spacer), webkit_dom_node_get_next_sibling (WEBKIT_DOM_NODE (signature_wrapper)), NULL); } } else { signature_wrapper = webkit_dom_document_create_element (document, "div", NULL); webkit_dom_element_set_class_name (signature_wrapper, "-x-evo-signature-wrapper"); webkit_dom_node_append_child ( WEBKIT_DOM_NODE (signature_wrapper), WEBKIT_DOM_NODE (signature_to_insert), NULL); if (top_signature) { WebKitDOMNode *child; child = webkit_dom_node_get_first_child (WEBKIT_DOM_NODE (body)); if (start_typing_at_bottom ()) { webkit_dom_node_insert_before ( WEBKIT_DOM_NODE (body), WEBKIT_DOM_NODE (signature_wrapper), child, NULL); } else { /* When we are using signature on top the caret * should be before the signature */ webkit_dom_node_insert_before ( WEBKIT_DOM_NODE (body), WEBKIT_DOM_NODE (signature_wrapper), child, NULL); } } else { webkit_dom_node_append_child ( WEBKIT_DOM_NODE (body), WEBKIT_DOM_NODE (signature_wrapper), NULL); } move_caret_after_signature_inserted (editor_page); } g_clear_object (&signatures); if (is_html && html_mode) e_editor_dom_fix_file_uri_images (editor_page); /* Make sure the flag will be unset and won't influence user's choice */ *set_signature_from_message = FALSE; return NULL; }
static gboolean add_single_file (BgPicturesSource *bg_source, GFile *file, const gchar *content_type, guint64 mtime, GtkTreeRowReference **ret_row_ref) { CcBackgroundItem *item = NULL; CcBackgroundItemFlags flags = 0; GtkListStore *store; GtkTreeIter iter; GtkTreePath *path = NULL; GtkTreeRowReference *row_ref = NULL; cairo_surface_t *surface = NULL; char *source_uri = NULL; char *uri = NULL; gboolean needs_download; gboolean retval = FALSE; GFile *pictures_dir, *cache_dir; GrlMedia *media; /* find png and jpeg files */ if (!content_type) goto out; if (!in_content_types (content_type)) goto out; /* create a new CcBackgroundItem */ uri = g_file_get_uri (file); pictures_dir = g_file_new_for_path (g_get_user_special_dir (G_USER_DIRECTORY_PICTURES)); cache_dir = bg_pictures_source_get_cache_file (); needs_download = !g_file_has_parent (file, pictures_dir) && !g_file_has_parent (file, cache_dir); g_object_unref (pictures_dir); g_object_unref (cache_dir); if (!needs_download) { source_uri = g_strdup (uri); flags |= CC_BACKGROUND_ITEM_HAS_URI; } else { source_uri = uri; uri = NULL; } item = cc_background_item_new (uri); flags |= CC_BACKGROUND_ITEM_HAS_SHADING | CC_BACKGROUND_ITEM_HAS_PLACEMENT; g_object_set (G_OBJECT (item), "flags", flags, "shading", G_DESKTOP_BACKGROUND_SHADING_SOLID, "placement", G_DESKTOP_BACKGROUND_STYLE_ZOOM, "modified", mtime, "needs-download", needs_download, "source-url", source_uri, NULL); if (!ret_row_ref && in_screenshot_types (content_type)) goto read_file; surface = get_content_loading_icon (BG_SOURCE (bg_source)); store = bg_source_get_liststore (BG_SOURCE (bg_source)); /* insert the item into the liststore */ gtk_list_store_insert_with_values (store, &iter, -1, 0, surface, 1, item, -1); path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter); row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (store), path); g_object_set_data_full (G_OBJECT (item), "row-ref", row_ref, (GDestroyNotify) gtk_tree_row_reference_free); read_file: media = g_object_get_data (G_OBJECT (file), "grl-media"); if (media == NULL) { g_object_set_data_full (G_OBJECT (file), "item", g_object_ref (item), g_object_unref); g_file_read_async (file, G_PRIORITY_DEFAULT, bg_source->priv->cancellable, picture_opened_for_read, bg_source); } else { GFile *native_file; GFile *thumbnail_file = NULL; gchar *native_dir; gchar *native_path; const gchar *title; const gchar *thumbnail_uri; title = grl_media_get_title (media); g_object_set (G_OBJECT (item), "name", title, NULL); thumbnail_uri = grl_media_get_thumbnail (media); thumbnail_file = g_file_new_for_uri (thumbnail_uri); native_path = gnome_desktop_thumbnail_path_for_uri (source_uri, GNOME_DESKTOP_THUMBNAIL_SIZE_LARGE); native_file = g_file_new_for_path (native_path); native_dir = g_path_get_dirname (native_path); g_mkdir_with_parents (native_dir, USER_DIR_MODE); g_object_set_data_full (G_OBJECT (thumbnail_file), "item", g_object_ref (item), g_object_unref); g_object_set_data_full (G_OBJECT (thumbnail_file), "native-file", g_object_ref (native_file), g_object_unref); g_file_copy_async (thumbnail_file, native_file, G_FILE_COPY_ALL_METADATA, G_PRIORITY_DEFAULT, bg_source->priv->cancellable, NULL, NULL, picture_copied_for_read, bg_source); g_clear_object (&thumbnail_file); g_object_unref (native_file); g_free (native_dir); g_free (native_path); } retval = TRUE; out: if (ret_row_ref) { if (row_ref && retval != FALSE) *ret_row_ref = gtk_tree_row_reference_copy (row_ref); else *ret_row_ref = NULL; } gtk_tree_path_free (path); g_clear_pointer (&surface, (GDestroyNotify) cairo_surface_destroy); g_clear_object (&item); g_object_unref (file); g_free (source_uri); g_free (uri); return retval; }
static void test1 (void) { SoupClientContext *client; SoupMessage *message; SoupServer *server; UrlRouter *router; router = url_router_new(); matches = g_hash_table_new(g_str_hash, g_str_equal); server = g_object_new(SOUP_TYPE_SERVER, NULL); message = g_object_new(SOUP_TYPE_MESSAGE, NULL); client = GINT_TO_POINTER(1); #define ADD_HANDLER(key) \ url_router_add_handler(router, key, handler, (gpointer)key) #define TEST_HANDLER(key, check) \ G_STMT_START { \ gboolean r = url_router_route(router, server, message, key, NULL, client); \ g_assert(g_hash_table_contains(matches, check)); \ g_assert_cmpint(g_hash_table_size(matches), ==, 1); \ g_assert(r); \ g_hash_table_remove_all(matches); \ } G_STMT_END #define TEST_FAILURE(key) \ G_STMT_START { \ gboolean r = url_router_route(router, server, message, key, NULL, client); \ g_assert_cmpint(g_hash_table_size(matches), ==, 0); \ g_assert(!r); \ g_hash_table_remove_all(matches); \ } G_STMT_END ADD_HANDLER("/v1"); ADD_HANDLER("/v1/users"); ADD_HANDLER("/v1/users/:user"); ADD_HANDLER("/v1/users/:user/devices"); ADD_HANDLER("/v1/users/:user/devices/:device"); TEST_HANDLER("/v1", "/v1"); TEST_HANDLER("/v1/", "/v1"); TEST_HANDLER("/v1/users", "/v1/users"); TEST_HANDLER("/v1/users/", "/v1/users"); TEST_HANDLER("/v1/users/000011110000111100001111", "/v1/users/:user"); TEST_HANDLER("/v1/users/000011110000111100001111/", "/v1/users/:user"); TEST_HANDLER("/v1/users/000011110000111100001111/devices", "/v1/users/:user/devices"); TEST_HANDLER("/v1/users/000011110000111100001111/devices/", "/v1/users/:user/devices"); TEST_HANDLER("/v1/users/000011110000111100001111/devices/111100001111000011110000", "/v1/users/:user/devices/:device"); TEST_HANDLER("/v1/users/000011110000111100001111/devices/111100001111000011110000/", "/v1/users/:user/devices/:device"); TEST_FAILURE("/"); TEST_FAILURE("//"); TEST_FAILURE("////"); TEST_FAILURE("/v1////"); TEST_FAILURE("/v1/users/1234/devices/1234/blah"); #undef TEST_HANDLER #undef ADD_HANDLER g_clear_object(&server); g_clear_object(&message); url_router_free(router); g_hash_table_unref(matches); }