static void
mbox_preview_add_message (CamelMimeMessage *msg,
			  GtkListStore **pstore)
{
	GtkTreeIter iter;
	gchar *from;

	g_return_if_fail (CAMEL_IS_MIME_MESSAGE (msg));
	g_return_if_fail (pstore != NULL);

	if (!*pstore)
		*pstore = gtk_list_store_new (
			3, G_TYPE_STRING, G_TYPE_STRING,
			CAMEL_TYPE_MIME_MESSAGE);

	from = NULL;

	if (camel_mime_message_get_from (msg))
		from = camel_address_encode (CAMEL_ADDRESS (camel_mime_message_get_from (msg)));

	gtk_list_store_append (*pstore, &iter);
	gtk_list_store_set (
		*pstore, &iter,
		0, camel_mime_message_get_subject (msg) ?
		camel_mime_message_get_subject (msg) : "",
		1, from ? from : "", 2, msg, -1);

	g_free (from);
}
Example #2
0
void
em_junk_sa_report_junk (EPlugin *ep, EMJunkHookTarget *target)
{
	char *sync_op = ((get_spamassassin_version () >= 3) ? "--no-sync": "--no-rebuild");
	char *argv[6] = {
		"sa-learn",
		sync_op,
		"--spam",
		"--single",
		NULL,
		NULL
	};
	gchar *sub = NULL;
	CamelMimeMessage *msg = target->m;

	sub = g_strdup (camel_mime_message_get_subject (msg));
	g_print ("\nreport junk?? %s\n", sub);

	d(fprintf (stderr, "em_junk_sa_report_junk\n"));

	if (em_junk_sa_is_available (&target->error)) {
		if (em_junk_sa_local_only)
			argv[4] = "--local";

		pthread_mutex_lock (&em_junk_sa_report_lock);
		pipe_to_sa (msg, NULL, argv, &target->error);
		pthread_mutex_unlock (&em_junk_sa_report_lock);
	}
}
Example #3
0
CamelMimePart *
mail_tool_make_message_attachment (CamelMimeMessage *message)
{
	CamelMimePart *part;
	const char *subject;
	struct _camel_header_raw *xev;
	char *desc;

	subject = camel_mime_message_get_subject (message);
	if (subject)
		desc = g_strdup_printf (_("Forwarded message - %s"), subject);
	else
		desc = g_strdup (_("Forwarded message"));

	/* rip off the X-Evolution headers */
	xev = mail_tool_remove_xevolution_headers (message);
	camel_header_raw_clear(&xev);

	/* remove Bcc headers */
	camel_medium_remove_header (CAMEL_MEDIUM (message), "Bcc");

	part = camel_mime_part_new ();
	camel_mime_part_set_disposition (part, "inline");
	camel_mime_part_set_description (part, desc);
	camel_medium_set_content_object (CAMEL_MEDIUM (part),
					 CAMEL_DATA_WRAPPER (message));
	camel_mime_part_set_content_type (part, "message/rfc822");
	g_free (desc);

	return part;
}
Example #4
0
void
test_message_info (CamelMimeMessage *msg, const CamelMessageInfo *info)
{
	check_msg (safe_strcmp (camel_message_info_subject (info), camel_mime_message_get_subject (msg)) == 0,
		  "info->subject = '%s', get_subject () = '%s'", camel_message_info_subject (info), camel_mime_message_get_subject (msg));

	/* FIXME: testing from/cc/to, etc is more tricky */

	check (camel_message_info_date_sent (info) == camel_mime_message_get_date (msg, NULL));

	/* date received isn't set for messages that haven't been sent anywhere ... */
	/*check (info->date_received == camel_mime_message_get_date_received (msg, NULL));*/

	/* so is messageid/references, etc */
}
Example #5
0
char *
mail_tool_generate_forward_subject (CamelMimeMessage *msg)
{
	const char *subject;
	char *fwd_subj;
	const int max_subject_length = 1024;

	subject = camel_mime_message_get_subject(msg);

	if (subject && *subject) {
		/* Truncate insanely long subjects */
		if (strlen (subject) < max_subject_length) {
			fwd_subj = g_strdup_printf ("[Fwd: %s]", subject);
		} else {
			/* We can't use %.*s because it depends on the locale being C/POSIX
			   or UTF-8 to work correctly in glibc */
			/*fwd_subj = g_strdup_printf ("[Fwd: %.*s...]", max_subject_length, subject);*/
			fwd_subj = g_malloc (max_subject_length + 11);
			memcpy (fwd_subj, "[Fwd: ", 6);
			memcpy (fwd_subj + 6, subject, max_subject_length);
			memcpy (fwd_subj + 6 + max_subject_length, "...]", 5);
		}
	} else {
		const CamelInternetAddress *from;
		char *fromstr;

		from = camel_mime_message_get_from (msg);
		if (from) {
			fromstr = camel_address_format (CAMEL_ADDRESS (from));
			fwd_subj = g_strdup_printf ("[Fwd: %s]", fromstr);
			g_free (fromstr);
		} else
			fwd_subj = g_strdup ("[Fwd: No Subject]");
	}

	return fwd_subj;
}
static gboolean
mbox_supported (EImport *ei,
                EImportTarget *target,
                EImportImporter *im)
{
	gchar signature[1024];
	gboolean ret = FALSE;
	gint fd, n;
	EImportTargetURI *s;
	gchar *filename;

	if (target->type != E_IMPORT_TARGET_URI)
		return FALSE;

	s = (EImportTargetURI *) target;
	if (s->uri_src == NULL)
		return TRUE;

	if (strncmp (s->uri_src, "file:///", strlen ("file:///")) != 0)
		return FALSE;

	filename = g_filename_from_uri (s->uri_src, NULL, NULL);
	fd = g_open (filename, O_RDONLY, 0);
	if (fd != -1) {
		n = read (fd, signature, 1024);
		ret = n >= 5 && memcmp (signature, "From ", 5) == 0;
		close (fd);

		/* An artificial number, at least 256 bytes message
		   to be able to try to import it as an MBOX */
		if (!ret && n >= 256) {
			gint ii;

			ret = (signature[0] >= 'a' && signature[0] <= 'z') ||
			      (signature[0] >= 'A' && signature[0] <= 'Z');

			for (ii = 0; ii < n && ret; ii++) {
				ret = signature[ii] == '-' ||
				      signature[ii] == ' ' ||
				      signature[ii] == '\t' ||
				     (signature[ii] >= 'a' && signature[ii] <= 'z') ||
				     (signature[ii] >= 'A' && signature[ii] <= 'Z') ||
				     (signature[ii] >= '0' && signature[ii] <= '9');
			}

			/* It's probably a header name which starts with ASCII letter and
			   contains only [a..z][A..Z][\t, ,-] and the read stopped on ':'. */
			if (ii > 0 && ii < n && !ret && signature[ii - 1] == ':') {
				CamelStream *stream;

				stream = camel_stream_fs_new_with_name (filename, O_RDONLY, 0, NULL);
				if (stream) {
					CamelMimeMessage *msg;

					msg = camel_mime_message_new ();

					/* Check whether the message can be parsed and whether
					   it contains any mandatory fields. */
					ret = camel_data_wrapper_construct_from_stream_sync ((CamelDataWrapper *) msg, stream, NULL, NULL) &&
					      camel_mime_message_get_message_id (msg) &&
					      camel_mime_message_get_subject (msg) &&
					      camel_mime_message_get_from (msg) &&
					      (camel_mime_message_get_recipients (msg, CAMEL_RECIPIENT_TYPE_TO) ||
					       camel_mime_message_get_recipients (msg, CAMEL_RECIPIENT_TYPE_RESENT_TO));

					g_object_unref (msg);
					g_object_unref (stream);
				}
			}
		}
	}

	g_free (filename);

	return ret;
}
Example #7
0
static void
emfqe_format_header (EMailFormatter *formatter,
		     EMailFormatterContext *context,
                     GString *buffer,
                     EMailPart *part,
                     const gchar *header_name,
                     const gchar *charset)
{
	CamelMimePart *mime_part;
	EMailFormatterHeaderFlags flags;
	gchar *canon_name, *buf, *value = NULL;
	const gchar *txt, *label;
	gboolean addrspec = FALSE;
	gint is_html = FALSE;
	gint i;

	/* Skip Face header in prints, which includes also message forward */
	if (context->mode == E_MAIL_FORMATTER_MODE_PRINTING &&
	    g_ascii_strcasecmp (header_name, "Face") == 0)
		return;

	flags = E_MAIL_FORMATTER_HEADER_FLAG_NOELIPSIZE;

	canon_name = g_alloca (strlen (header_name) + 1);
	strcpy (canon_name, header_name);
	e_mail_formatter_canon_header_name (canon_name);

	/* Never quote Bcc/Resent-Bcc headers. */
	if (g_str_equal (canon_name, "Bcc"))
		return;
	if (g_str_equal (canon_name, "Resent-Bcc"))
		return;

	mime_part = e_mail_part_ref_mime_part (part);

	for (i = 0; addrspec_hdrs[i]; i++) {
		if (g_str_equal (canon_name, addrspec_hdrs[i])) {
			addrspec = TRUE;
			break;
		}
	}

	label = _(canon_name);

	if (addrspec) {
		CamelMedium *medium;
		struct _camel_header_address *addrs;
		GString *html;
		gchar *charset;

		medium = CAMEL_MEDIUM (mime_part);
		txt = camel_medium_get_header (medium, canon_name);
		if (txt == NULL)
			return;

		charset = e_mail_formatter_dup_charset (formatter);
		if (!charset)
			charset = e_mail_formatter_dup_default_charset (formatter);

		buf = camel_header_unfold (txt);
		addrs = camel_header_address_decode (txt, charset);
		g_free (charset);

		if (addrs == NULL) {
			g_free (buf);
			return;
		}

		g_free (buf);

		html = g_string_new ("");
		e_mail_formatter_format_address (formatter, html,
			addrs, canon_name, FALSE, FALSE);
		camel_header_address_unref (addrs);
		txt = value = html->str;
		g_string_free (html, FALSE);
		flags |= E_MAIL_FORMATTER_HEADER_FLAG_BOLD;
		is_html = TRUE;

	} else if (g_str_equal (canon_name, "Subject")) {
		CamelMimeMessage *message;

		message = CAMEL_MIME_MESSAGE (mime_part);
		txt = camel_mime_message_get_subject (message);
		label = _("Subject");
		flags |= E_MAIL_FORMATTER_HEADER_FLAG_BOLD;

	} else if (g_str_equal (canon_name, "X-Evolution-Mailer")) {
		CamelMedium *medium;

		medium = CAMEL_MEDIUM (mime_part);
		txt = camel_medium_get_header (medium, "x-mailer");
		if (txt == NULL)
			txt = camel_medium_get_header (medium, "user-agent");
		if (txt == NULL)
			txt = camel_medium_get_header (medium, "x-newsreader");
		if (txt == NULL)
			txt = camel_medium_get_header (medium, "x-mimeole");
		if (txt == NULL)
			return;

		txt = value = camel_header_format_ctext (txt, charset);

		label = _("Mailer");
		flags |= E_MAIL_FORMATTER_HEADER_FLAG_BOLD;

	} else if (g_str_equal (canon_name, "Date") ||
		   g_str_equal (canon_name, "Resent-Date")) {
		CamelMedium *medium;

		medium = CAMEL_MEDIUM (mime_part);
		txt = camel_medium_get_header (medium, canon_name);
		if (txt == NULL)
			return;

		flags |= E_MAIL_FORMATTER_HEADER_FLAG_BOLD;

	} else {
		CamelMedium *medium;

		medium = CAMEL_MEDIUM (mime_part);
		txt = camel_medium_get_header (medium, canon_name);
		buf = camel_header_unfold (txt);
		txt = value = camel_header_decode_string (txt, charset);
		g_free (buf);
	}

	emfqe_format_text_header (formatter, buffer, label, txt, flags, is_html);

	g_free (value);

	g_object_unref (mime_part);
}
Example #8
0
void
com_irontec_evosugar(void *ep, EMPopupTargetSelect *t) {

   CamelException ex = {0};


   gchar *folder_name =  camel_folder_get_name(t->folder);
   gboolean folder_is_sent = FALSE;
   BREAKPOINT;
   gui.gtkBuilder = gtk_builder_new();
   gtk_builder_set_translation_domain(gui.gtkBuilder, GETTEXT_PACKAGE);
   gtk_builder_add_from_file(gui.gtkBuilder, g_build_filename(PLUGIN_INSTALL_DIR, UI_FILE, NULL), NULL);


   gui.entry_search = GTK_WIDGET(gtk_builder_get_object(gui.gtkBuilder, "entrySearch"));
   gui.button_search = GTK_WIDGET(gtk_builder_get_object(gui.gtkBuilder, "buttonSearch"));
   gui.radio_button_from = GTK_WIDGET(gtk_builder_get_object(gui.gtkBuilder, "radiobuttonFrom"));
   gui.radio_button_to = GTK_WIDGET(gtk_builder_get_object(gui.gtkBuilder, "radiobuttonTo"));
   gui.button_submit = GTK_WIDGET(gtk_builder_get_object(gui.gtkBuilder, "buttonAddToSugarCRM"));

   gui.entry_subject_edit = GTK_WIDGET(gtk_builder_get_object(gui.gtkBuilder, "entryEditSubject"));

   BREAKPOINT;
   g_signal_connect(gui.button_search, "clicked",
         G_CALLBACK(on_button_search_clicked), GTK_ENTRY(gui.entry_search));
   g_signal_connect(gui.button_submit, "clicked",
         G_CALLBACK(on_button_AddToSugarCRM_clicked), NULL);

   scrm_session.id = scrm_login(gconf_get_username(), gconf_get_password(), gconf_get_server());

   if ((g_strcmp0(folder_name, "Sent") == 0) || (g_strcmp0(folder_name, _("Sent")) == 0) ) {
      folder_is_sent = TRUE;
   }

   if (scrm_session.id == NULL || g_strcmp0(scrm_session.id, "-1") == 0) {
      gui_show_message(_("SugarCRM"), _("Unable to connect: check your connection and settings please."));
   } else {


      BREAKPOINT;

      msg = camel_folder_get_message(t->folder, t->uids->pdata[0], &ex);
      util_get_msg_body(msg, &msg_body);

      if (msg == NULL) {
         camel_exception_clear(&ex);
         return;
      }
      BREAKPOINT;

      subject = camel_mime_message_get_subject(msg);
      gtk_entry_set_text(gui.entry_subject_edit, subject);

      gui.body_text_view = gtk_builder_get_object(gui.gtkBuilder, "bodyTextView");
      model.body_text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gui.body_text_view));

      gtk_text_buffer_set_text(model.body_text_buffer, msg_body, -1);

      from = camel_mime_message_get_from(msg);
      to = camel_mime_message_get_recipients(msg, CAMEL_RECIPIENT_TYPE_TO);

      BREAKPOINT;
      msg_date = camel_mime_message_get_date(msg, NULL);
      camel_internet_address_get(from, 0, &from_name, &from_addr);
      camel_internet_address_get(to, 0, &to_name, &to_addr);
      g_signal_connect(gui.radio_button_from, "pressed",
            G_CALLBACK(on_radio_group_search_changed), from_addr);

      gchar *to_search = to_addr;


      g_signal_connect(gui.radio_button_to, "pressed",
            G_CALLBACK(on_radio_group_search_changed), to_search);
      if (folder_is_sent) {
         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gui.radio_button_to),TRUE);
      }

      BREAKPOINT;

      GtkWidget *content_box = GTK_WIDGET(gtk_builder_get_object(gui.gtkBuilder, "vboxContents"));
      GtkWidget *frame_attach = GTK_WIDGET(gtk_builder_get_object(gui.gtkBuilder, "frameAttach"));

      if (folder_is_sent) {
         gtk_entry_set_text(gui.entry_search, to_addr);
      } else {
         gtk_entry_set_text(gui.entry_search, from_addr);
      }

      GtkScrolledWindow *scrolledwindow = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));
      gtk_scrolled_window_set_policy(scrolledwindow,
            GTK_POLICY_AUTOMATIC,
            GTK_POLICY_AUTOMATIC);
      GtkScrolledWindow *scrolledwindow2 = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));
      gtk_scrolled_window_set_policy(scrolledwindow2,
            GTK_POLICY_AUTOMATIC,
            GTK_POLICY_AUTOMATIC);



      BREAKPOINT;
      gtk_container_add(GTK_CONTAINER(content_box), scrolledwindow);
      gtk_container_add(GTK_CONTAINER(frame_attach), scrolledwindow2);
      BREAKPOINT;
      gui.treeview_search = gtk_tree_view_new();
      gui.treeview_attach = gtk_tree_view_new();


      add_columns_search(GTK_TREE_VIEW(gui.treeview_search));
      add_columns_attachment(GTK_TREE_VIEW(gui.treeview_attach));
      model.model_attach = util_get_msg_attachments(msg);


      //gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), model_search);
      BREAKPOINT;
      //g_object_unref (G_OBJECT (model_search));

      gtk_builder_connect_signals(gui.gtkBuilder, NULL);
      gtk_tree_view_set_model(GTK_TREE_VIEW(gui.treeview_attach), model.model_attach);
      gtk_container_add(scrolledwindow, gui.treeview_search);
      gtk_container_add(scrolledwindow2, gui.treeview_attach);

      gui.mainwin =
         GTK_WIDGET(gtk_builder_get_object
               (gui.gtkBuilder, "addToSugarCRMwindow"));


      /*
       * Show the application window
       */
      gtk_widget_show_all(gui.mainwin);

      //trigger
      on_button_search_clicked(NULL, gui.entry_search);
      if (DEBUG_ON) {
         //g_mem_profile ();
      }

   } // end-else comprobar conexion
}
Example #9
0
static gboolean
do_mail_to_event (AsyncData *data)
{
	EClient *client;
	CamelFolder *folder = data->folder;
	GPtrArray *uids = data->uids;
	GError *error = NULL;

	client = e_client_cache_get_client_sync (data->client_cache,
		data->source, data->extension_name, 30, NULL, &error);

	/* Sanity check. */
	g_return_val_if_fail (
		((client != NULL) && (error == NULL)) ||
		((client == NULL) && (error != NULL)), TRUE);

	if (error != NULL) {
		report_error_idle (_("Cannot open calendar. %s"), error->message);
	} else if (e_client_is_readonly (E_CLIENT (client))) {
		switch (data->source_type) {
		case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
			report_error_idle (_("Selected calendar is read only, thus cannot create event there. Select other calendar, please."), NULL);
			break;
		case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
			report_error_idle (_("Selected task list is read only, thus cannot create task there. Select other task list, please."), NULL);
			break;
		case E_CAL_CLIENT_SOURCE_TYPE_MEMOS:
			report_error_idle (_("Selected memo list is read only, thus cannot create memo there. Select other memo list, please."), NULL);
			break;
		default:
			g_warn_if_reached ();
			break;
		}
	} else {
		gint i;
		ECalComponentDateTime dt, dt2;
		struct icaltimetype tt, tt2;
		struct _manage_comp *oldmc = NULL;

		#define cache_backend_prop(prop) { \
			gchar *val = NULL; \
			e_client_get_backend_property_sync (E_CLIENT (client), prop, &val, NULL, NULL); \
			g_free (val); \
		}

		/* precache backend properties, thus editor have them ready when needed */
		cache_backend_prop (CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS);
		cache_backend_prop (CAL_BACKEND_PROPERTY_ALARM_EMAIL_ADDRESS);
		cache_backend_prop (CAL_BACKEND_PROPERTY_DEFAULT_OBJECT);
		e_client_get_capabilities (E_CLIENT (client));

		#undef cache_backend_prop

		/* set start day of the event as today, without time - easier than looking for a calendar's time zone */
		tt = icaltime_today ();
		dt.value = &tt;
		dt.tzid = NULL;

		tt2 = tt;
		icaltime_adjust (&tt2, 1, 0, 0, 0);
		dt2.value = &tt2;
		dt2.tzid = NULL;

		for (i = 0; i < (uids ? uids->len : 0); i++) {
			CamelMimeMessage *message;
			ECalComponent *comp;
			ECalComponentText text;
			icalproperty *icalprop;
			icalcomponent *icalcomp;
			struct _manage_comp *mc;

			/* retrieve the message from the CamelFolder */
			/* FIXME Not passing a GCancellable or GError. */
			message = camel_folder_get_message_sync (
				folder, g_ptr_array_index (uids, i),
				NULL, NULL);
			if (!message) {
				continue;
			}

			comp = e_cal_component_new ();

			switch (data->source_type) {
			case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
				e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_EVENT);
				break;
			case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
				e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_TODO);
				break;
			case E_CAL_CLIENT_SOURCE_TYPE_MEMOS:
				e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_JOURNAL);
				break;
			default:
				g_warn_if_reached ();
				break;
			}

			e_cal_component_set_uid (comp, camel_mime_message_get_message_id (message));
			e_cal_component_set_dtstart (comp, &dt);

			if (data->source_type == E_CAL_CLIENT_SOURCE_TYPE_EVENTS) {
				/* make it an all-day event */
				e_cal_component_set_dtend (comp, &dt2);
			}

			/* set the summary */
			text.value = camel_mime_message_get_subject (message);
			text.altrep = NULL;
			e_cal_component_set_summary (comp, &text);

			/* set all fields */
			if (data->selected_text) {
				GSList sl;

				text.value = data->selected_text;
				text.altrep = NULL;
				sl.next = NULL;
				sl.data = &text;

				e_cal_component_set_description_list (comp, &sl);
			} else
				set_description (comp, message);

			if (data->with_attendees) {
				gchar *organizer;

				/* set actual user as organizer, to be able to change event's properties */
				organizer = set_organizer (comp, data->folder);
				set_attendees (comp, message, organizer);
				g_free (organizer);
			}

			/* set attachment files */
			set_attachments (E_CAL_CLIENT (client), comp, message);

			/* priority */
			set_priority (comp, CAMEL_MIME_PART (message));

			/* no need to increment a sequence number, this is a new component */
			e_cal_component_abort_sequence (comp);

			icalcomp = e_cal_component_get_icalcomponent (comp);

			icalprop = icalproperty_new_x ("1");
			icalproperty_set_x_name (icalprop, "X-EVOLUTION-MOVE-CALENDAR");
			icalcomponent_add_property (icalcomp, icalprop);

			mc = g_new0 (struct _manage_comp, 1);
			mc->client = g_object_ref (client);
			mc->comp = g_object_ref (comp);
			g_mutex_init (&mc->mutex);
			g_cond_init (&mc->cond);
			mc->mails_count = uids->len;
			mc->mails_done = i + 1; /* Current task */
			mc->editor_title = NULL;
			mc->can_continue = TRUE;

			if (oldmc) {
				/* Wait for user to quit the editor created in previous iteration
				 * before displaying next one */
				gboolean can_continue;
				g_mutex_lock (&oldmc->mutex);
				g_cond_wait (&oldmc->cond, &oldmc->mutex);
				g_mutex_unlock (&oldmc->mutex);
				can_continue = oldmc->can_continue;
				free_manage_comp_struct (oldmc);
				oldmc = NULL;

				if (!can_continue)
					break;
			}

			e_cal_client_get_object_sync (
				E_CAL_CLIENT (client),
				icalcomponent_get_uid (icalcomp),
				NULL, &mc->stored_comp, NULL, NULL);

			/* Prioritize ahead of GTK+ redraws. */
			g_idle_add_full (
				G_PRIORITY_HIGH_IDLE,
				(GSourceFunc) do_manage_comp_idle, mc, NULL);

			oldmc = mc;

			g_object_unref (comp);
			g_object_unref (message);

		}

		/* Wait for the last editor and then clean up */
		if (oldmc) {
			g_mutex_lock (&oldmc->mutex);
			g_cond_wait (&oldmc->cond, &oldmc->mutex);
			g_mutex_unlock (&oldmc->mutex);
			free_manage_comp_struct (oldmc);
		}
	}

	/* free memory */
	if (client != NULL)
		g_object_unref (client);
	g_ptr_array_unref (uids);
	g_object_unref (folder);

	g_object_unref (data->client_cache);
	g_object_unref (data->source);
	g_free (data->selected_text);
	g_free (data);
	data = NULL;

	if (error != NULL)
		g_error_free (error);

	return TRUE;
}