/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
/*
* Copyright (C) 2004-2008 Red Hat, Inc.
* Copyright (C) 2013 Intel Corporation.
*
* Nautilus is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* Nautilus is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* Authors: Bastien Nocera <hadess@hadess.net>
* Authors: Emilio Pozuelo Monfort <emilio.pozuelo@collabora.co.uk>
*
*/
#include "config.h"
#include <glib.h>
#include <glib/gstdio.h>
#include <glib/gi18n-lib.h>
#include <gio/gio.h>
#include <gtk/gtk.h>
#include <bluetooth-client.h>
#include <libnotify/notify.h>
#include <canberra-gtk.h>
#include "bluetooth-settings-obexpush.h"
#define MANAGER_SERVICE "org.bluez.obex"
#define MANAGER_IFACE "org.bluez.obex.AgentManager1"
#define MANAGER_PATH "/org/bluez/obex"
#define AGENT_PATH "/org/gnome/share/agent"
#define AGENT_IFACE "org.bluez.obex.Agent1"
#define TRANSFER_IFACE "org.bluez.obex.Transfer1"
#define SESSION_IFACE "org.bluez.obex.Session1"
static GDBusNodeInfo *introspection_data = NULL;
static const gchar introspection_xml[] =
"<node name='"AGENT_PATH"'>"
" <interface name='"AGENT_IFACE"'>"
" <method name='Release'>"
" </method>"
" <method name='Cancel'>"
" </method>"
" <method name='AuthorizePush'>"
" <arg name='transfer' type='o' />"
" <arg name='path' type='s' direction='out' />"
" </method>"
" </interface>"
"</node>";
G_DEFINE_TYPE(ObexAgent, obex_agent, G_TYPE_OBJECT)
static ObexAgent *agent;
static BluetoothClient *client;
static void
on_close_notification (NotifyNotification *notification)
{
g_object_unref (notification);
}
static void
notification_launch_action_on_file_cb (NotifyNotification *notification,
const char *action,
const char *file_uri)
{
g_assert (action != NULL);
/* We launch the file viewer for the file */
if (g_str_equal (action, "display") != FALSE) {
GdkDisplay *display;
GAppLaunchContext *ctx;
GTimeVal val;
g_get_current_time (&val);
display = gdk_display_get_default ();
ctx = G_APP_LAUNCH_CONTEXT (gdk_display_get_app_launch_context (display));
gdk_app_launch_context_set_timestamp (GDK_APP_LAUNCH_CONTEXT (ctx), val.tv_sec);
if (g_app_info_launch_default_for_uri (file_uri, ctx, NULL) == FALSE) {
g_warning ("Failed to launch the file viewer\n");
}
g_object_unref (ctx);
}
/* we open the Downloads folder */
if (g_str_equal (action, "reveal") != FALSE) {
GDBusConnection *connection = agent->connection;
GVariantBuilder builder;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("as"));
g_variant_builder_add (&builder, "s", file_uri);
g_dbus_connection_call (connection,
"org.freedesktop.FileManager1",
"/org/freedesktop/FileManager1",
"org.freedesktop.FileManager1",
"ShowItems",
g_variant_new ("(ass)", &builder, ""),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
NULL,
NULL);
g_variant_builder_clear (&builder);
}
notify_notification_close (notification, NULL);
}
static void
show_notification (const char *filename)
{
char *file_uri, *notification_text, *display, *mime_type;
NotifyNotification *notification;
ca_context *ctx;
GAppInfo *app;
file_uri = g_filename_to_uri (filename, NULL, NULL);
if (file_uri == NULL) {
g_warning ("Could not make a filename from '%s'", filename);
return;
}
display = g_filename_display_basename (filename);
/* Translators: %s is the name of the filename received */
notification_text = g_strdup_printf(_("You received ā%sā via Bluetooth"), display);
g_free (display);
notification = notify_notification_new (_("You received a file"),
notification_text,
"bluetooth");
notify_notification_set_timeout (notification, NOTIFY_EXPIRES_DEFAULT);
notify_notification_set_hint_string (notification, "desktop-entry", "gnome-bluetooth-panel");
mime_type = g_content_type_guess (filename, NULL, 0, NULL);
app = g_app_info_get_default_for_type (mime_type, FALSE);
if (app != NULL) {
g_object_unref (app);
notify_notification_add_action (notification, "display", _("Open File"),
(NotifyActionCallback) notification_launch_action_on_file_cb,
g_strdup (file_uri), (GFreeFunc) g_free);
}
notify_notification_add_action (notification, "reveal", _("Reveal File"),
(NotifyActionCallback) notification_launch_action_on_file_cb,
g_strdup (file_uri), (GFreeFunc) g_free);
g_free (file_uri);
g_signal_connect (G_OBJECT (notification), "closed", G_CALLBACK (on_close_notification), notification);
if (!notify_notification_show (notification, NULL)) {
g_warning ("failed to send notification\n");
}
g_free (notification_text);
/* Now we do the audio notification */
ctx = ca_gtk_context_get ();
ca_context_play (ctx, 0,
CA_PROP_EVENT_ID, "complete-download",
CA_PROP_EVENT_DESCRIPTION, _("File reception complete"),
NULL);
}
static void
reject_transfer (GDBusMethodInvocation *invocation)
{
const char *filename;
filename = g_object_get_data (G_OBJECT (invocation), "temp-filename");
g_remove (filename);
g_dbus_method_invocation_return_dbus_error (invocation,
"org.bluez.obex.Error.Rejected", "Not Authorized");
}
static void
ask_user_transfer_accepted (NotifyNotification *notification,
char *action,
GDBusMethodInvocation *invocation)
{
gchar *file = g_object_get_data (G_OBJECT (invocation), "temp-filename");
g_debug ("Notification: transfer accepted! accepting transfer");
g_dbus_method_invocation_return_value (invocation,
g_variant_new ("(s)", file));
}
static void
ask_user_transfer_rejected (NotifyNotification *notification,
char *action,
GDBusMethodInvocation *invocation)
{
g_debug ("Notification: transfer rejected! rejecting transfer");
reject_transfer (invocation);
}
static void
ask_user_on_close (NotifyNotification *notification,
GDBusMethodInvocation *invocation)
{
g_debug ("Notification closed! rejecting transfer");
reject_transfer (invocation);
}
static void
ask_user (GDBusMethodInvocation *invocation,
const char *filename,
const char *name)
{
NotifyNotification *notification;
char *summary, *body;
summary = g_strdup_printf(_("Bluetooth file transfer from %s"), name);
body = g_filename_display_basename (filename);
notification = notify_notification_new (summary, body, "bluetooth");
notify_notification_set_urgency (notification, NOTIFY_URGENCY_CRITICAL);
notify_notification_set_timeout (notification, NOTIFY_EXPIRES_NEVER);
notify_notification_set_hint_string (notification, "desktop-entry",
"gnome-bluetooth-panel");
notify_notification_add_action (notification, "cancel", _("Decline"),
(NotifyActionCallback) ask_user_transfer_rejected,
invocation, NULL);
notify_notification_add_action (notification, "receive", _("Accept"),
(NotifyActionCallback) ask_user_transfer_accepted,
invocation, NULL);
/* We want to reject the transfer if the user closes the notification
* without accepting or rejecting it, so we connect to it. However
* if the user clicks on one of the actions, the callback for the
* action will be invoked, and then the notification will be closed
* and the callback for :closed will be called. So we disconnect
* from :closed if the invocation object goes away (which will happen
* after the handler of either action accepts or rejects the transfer).
*/
g_signal_connect_object (G_OBJECT (notification), "closed",
G_CALLBACK (ask_user_on_close), invocation, 0);
if (!notify_notification_show (notification, NULL))
g_warning ("failed to send notification\n");
g_free (summary);
g_free (body);
}
static gboolean
get_paired_for_address (const char *adapter,
const char *device,
char **name)
{
GtkTreeModel *model;
GtkTreeIter parent;
gboolean next;
gboolean ret = FALSE;
char *addr;
model = bluetooth_client_get_model (client);
for (next = gtk_tree_model_get_iter_first (model, &parent);
next;
next = gtk_tree_model_iter_next (model, &parent)) {
gtk_tree_model_get (model, &parent,
BLUETOOTH_COLUMN_ADDRESS, &addr,
-1);
if (g_strcmp0 (addr, adapter) == 0) {
GtkTreeIter child;
char *dev_addr;
for (next = gtk_tree_model_iter_children (model, &child, &parent);
next;
next = gtk_tree_model_iter_next (model, &child)) {
gboolean paired;
char *alias;
gtk_tree_model_get (model, &child,
BLUETOOTH_COLUMN_ADDRESS, &dev_addr,
BLUETOOTH_COLUMN_PAIRED, &paired,
BLUETOOTH_COLUMN_ALIAS, &alias,
-1);
if (g_strcmp0 (dev_addr, device) == 0) {
ret = paired;
*name = alias;
next = FALSE;
} else {
g_free (alias);
}
g_free (dev_addr);
}
}
g_free (addr);
}
g_object_unref (model);
return ret;
}
static void
on_check_bonded_or_ask_session_acquired (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
GDBusMethodInvocation *invocation = user_data;
GDBusProxy *session;
GError *error = NULL;
GVariant *v;
char *device, *adapter, *name;
gboolean paired;
session = g_dbus_proxy_new_for_bus_finish (res, &error);
if (!session) {
g_debug ("Failed to create a proxy for the session: %s", error->message);
g_clear_error (&error);
goto out;
}
device = NULL;
adapter = NULL;
/* obexd puts the remote device in Destination and our adapter
* in Source */
v = g_dbus_proxy_get_cached_property (session, "Destination");
if (v) {
device = g_variant_dup_string (v, NULL);
g_variant_unref (v);
}
v = g_dbus_proxy_get_cached_property (session, "Source");
if (v) {
adapter = g_variant_dup_string (v, NULL);
g_variant_unref (v);
}
g_object_unref (session);
if (!device || !adapter) {
g_debug ("Could not get remote device for the transfer");
g_free (device);
g_free (adapter);
goto out;
}
name = NULL;
paired = get_paired_for_address (adapter, device, &name);
g_free (device);
g_free (adapter);
if (paired) {
g_debug ("Remote device '%s' is paired, auto-accepting the transfer", name);
g_dbus_method_invocation_return_value (invocation,
g_variant_new ("(s)", g_object_get_data (G_OBJECT (invocation), "temp-filename")));
g_free (name);
return;
} else {
ask_user (invocation,
g_object_get_data (G_OBJECT (invocation), "filename"),
name ? name : device);
g_free (name);
return;
}
out:
g_debug ("Rejecting transfer");
reject_transfer (invocation);
}
static void
check_if_bonded_or_ask (GDBusProxy *transfer,
GDBusMethodInvocation *invocation)
{
GVariant *v;
const gchar *session = NULL;
v = g_dbus_proxy_get_cached_property (transfer, "Session");
if (v) {
session = g_variant_get_string (v, NULL);
g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
MANAGER_SERVICE,
session,
SESSION_IFACE,
NULL,
on_check_bonded_or_ask_session_acquired,
invocation);
g_variant_unref (v);
} else {
g_debug ("Could not get session path for the transfer, "
"rejecting the transfer");
reject_transfer (invocation);
}
}
static void
obex_agent_release (GError **error)
{
}
static void
obex_agent_cancel (GError **error)
{
}
/* From the old embed/mozilla/MozDownload.cpp */
static const char*
file_is_compressed (const char *filename)
{
int i;
static const char * const compression[] = {".gz", ".bz2", ".Z", ".lz", ".xz", NULL};
for (i = 0; compression[i] != NULL; i++) {
if (g_str_has_suffix (filename, compression[i]))
return compression[i];
}
return NULL;
}
static const char*
parse_extension (const char *filename)
{
const char *compression;
const char *last_separator;
compression = file_is_compressed (filename);
/* if the file is compressed we might have a double extension */
if (compression != NULL) {
int i;
static const char * const extensions[] = {"tar", "ps", "xcf", "dvi", "txt", "text", NULL};
for (i = 0; extensions[i] != NULL; i++) {
char *suffix;
suffix = g_strdup_printf (".%s%s", extensions[i], compression);
if (g_str_has_suffix (filename, suffix)) {
char *p;
p = g_strrstr (filename, suffix);
g_free (suffix);
return p;
}
g_free (suffix);
}
}
/* no compression, just look for the last dot in the filename */
last_separator = strrchr (filename, G_DIR_SEPARATOR);
return strrchr ((last_separator) ? last_separator : filename, '.');
}
char *
lookup_download_dir (void)
{
const char *special_dir;
char *dir;
special_dir = g_get_user_special_dir (G_USER_DIRECTORY_DOWNLOAD);
if (special_dir != NULL && strcmp (special_dir, g_get_home_dir ()) != 0) {
g_mkdir_with_parents (special_dir, 0755);
return g_strdup (special_dir);
}
dir = g_build_filename (g_get_home_dir (), "Downloads", NULL);
g_mkdir_with_parents (dir, 0755);
return dir;
}
static char *
move_temp_filename (GObject *object)
{
const char *orig_filename;
char *dest_filename, *dest_dir;
GFile *src, *dest;
GError *error = NULL;
gboolean res;
orig_filename = g_object_get_data (object, "temp-filename");
src = g_file_new_for_path (orig_filename);
dest_dir = lookup_download_dir ();
dest_filename = g_build_filename (dest_dir, g_object_get_data (object, "filename"), NULL);
g_free (dest_dir);
dest = g_file_new_for_path (dest_filename);
res = g_file_move (src, dest,
G_FILE_COPY_NONE, NULL,
NULL, NULL, &error);
/* This is sync, but the files will be on the same partition already
* (~/.cache/obexd to ~/Downloads) */
if (!res && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS)) {
guint i = 1;
const char *dot_pos;
gssize position;
char *serial = NULL;
GString *tmp_filename;
dot_pos = parse_extension (dest_filename);
if (dot_pos)
position = dot_pos - dest_filename;
else
position = strlen (dest_filename);
tmp_filename = g_string_new (NULL);
g_string_assign (tmp_filename, dest_filename);
while (!res && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS)) {
g_debug ("Couldn't move file to %s", tmp_filename->str);
g_clear_error (&error);
g_object_unref (dest);
serial = g_strdup_printf ("(%d)", i++);
g_string_assign (tmp_filename, dest_filename);
g_string_insert (tmp_filename, position, serial);
g_free (serial);
dest = g_file_new_for_path (tmp_filename->str);
res = g_file_move (src, dest,
G_FILE_COPY_NONE, NULL,
NULL, NULL, &error);
}
g_free (dest_filename);
dest_filename = g_strdup (tmp_filename->str);
g_string_free (tmp_filename, TRUE);
}
if (!res) {
g_warning ("Failed to move %s to %s: '%s'",
orig_filename, dest_filename, error->message);
g_error_free (error);
} else {
g_debug ("Moved %s (orig name %s) to %s",
orig_filename, (char *) g_object_get_data (object, "filename"), dest_filename);
}
g_object_unref (src);
g_object_unref (dest);
return dest_filename;
}
static void
transfer_property_changed (GDBusProxy *transfer,
GVariant *changed_properties,
GStrv invalidated_properties,
gpointer user_data)
{
GVariantIter iter;
const gchar *key;
GVariant *value;
const char *filename;
g_debug ("Calling transfer_property_changed()");
filename = g_object_get_data (G_OBJECT (transfer), "filename");
g_variant_iter_init (&iter, changed_properties);
while (g_variant_iter_next (&iter, "{&sv}", &key, &value)) {
char *str = g_variant_print (value, TRUE);
if (g_str_equal (key, "Status")) {
const gchar *status;
status = g_variant_get_string (value, NULL);
g_debug ("Got status %s = %s for filename %s", status, str, filename);
if (g_str_equal (status, "complete")) {
char *path;
path = move_temp_filename (G_OBJECT (transfer));
g_debug ("transfer completed, showing a notification");
show_notification (path);
g_free (path);
}
/* Done with this transfer */
if (g_str_equal (status, "complete") ||
g_str_equal (status, "error")) {
g_object_unref (transfer);
}
} else {
g_debug ("Unhandled property changed %s = %s for filename %s", key, str, filename);
}
g_free (str);
g_variant_unref (value);
}
}
static void
obex_agent_authorize_push (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GDBusProxy *transfer = g_dbus_proxy_new_for_bus_finish (res, NULL);
GDBusMethodInvocation *invocation = user_data;
GVariant *variant = g_dbus_proxy_get_cached_property (transfer, "Name");
const gchar *filename = g_variant_get_string (variant, NULL);
char *template;
int fd;
g_debug ("AuthorizePush received");
template = g_build_filename (g_get_user_cache_dir (), "obexd", "XXXXXX", NULL);
fd = g_mkstemp (template);
close (fd);
g_object_set_data_full (G_OBJECT (transfer), "filename", g_strdup (filename), g_free);
g_object_set_data_full (G_OBJECT (transfer), "temp-filename", g_strdup (template), g_free);
g_object_set_data_full (G_OBJECT (invocation), "filename", g_strdup (filename), g_free);
g_object_set_data_full (G_OBJECT (invocation), "temp-filename", g_strdup (template), g_free);
g_signal_connect (transfer, "g-properties-changed",
G_CALLBACK (transfer_property_changed), NULL);
/* check_if_bonded_or_ask() will accept or reject the transfer */
check_if_bonded_or_ask (transfer, invocation);
g_variant_unref (variant);
g_free (template);
}
static void
handle_method_call (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *method_name,
GVariant *parameters,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
if (g_str_equal (method_name, "Cancel")) {
obex_agent_cancel (NULL);
g_dbus_method_invocation_return_value (invocation, NULL);
} else if (g_str_equal (method_name, "Release")) {
obex_agent_release (NULL);
g_dbus_method_invocation_return_value (invocation, NULL);
} else if (g_str_equal (method_name, "AuthorizePush")) {
const gchar *transfer;
g_variant_get (parameters, "(&o)", &transfer);
g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
MANAGER_SERVICE,
transfer,
TRANSFER_IFACE,
NULL,
obex_agent_authorize_push,
invocation);
} else {
g_warning ("Unknown method name or unknown parameters: %s",
method_name);
}
}
static const GDBusInterfaceVTable interface_vtable =
{
handle_method_call,
NULL,
NULL
};
static void
obexd_appeared_cb (GDBusConnection *connection,
const gchar *name,
const gchar *name_owner,
gpointer user_data)
{
ObexAgent *self = user_data;
g_debug ("obexd appeared, registering agent");
g_dbus_connection_call (self->connection,
MANAGER_SERVICE,
MANAGER_PATH,
MANAGER_IFACE,
"RegisterAgent",
g_variant_new ("(o)", AGENT_PATH),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
NULL,
NULL);
}
static void
on_bus_acquired (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
ObexAgent *self = user_data;
/* parse introspection data */
introspection_data = g_dbus_node_info_new_for_xml (introspection_xml,
NULL);
self->connection = connection;
self->object_reg_id = g_dbus_connection_register_object (connection,
AGENT_PATH,
introspection_data->interfaces[0],
&interface_vtable,
NULL, /* user_data */
NULL, /* user_data_free_func */
NULL); /* GError** */
g_dbus_node_info_unref (introspection_data);
g_assert (self->object_reg_id > 0);
self->obexd_watch_id = g_bus_watch_name_on_connection (self->connection,
MANAGER_SERVICE,
G_BUS_NAME_WATCHER_FLAGS_AUTO_START,
obexd_appeared_cb,
NULL,
self,
NULL);
}
static void
obex_agent_init (ObexAgent *self)
{
self->owner_id = g_bus_own_name (G_BUS_TYPE_SESSION,
AGENT_IFACE,
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT,
on_bus_acquired,
NULL,
NULL,
self,
NULL);
client = bluetooth_client_new ();
}
static void
obex_agent_dispose (GObject *obj)
{
ObexAgent *self = OBEX_AGENT (obj);
g_dbus_connection_unregister_object (self->connection, self->object_reg_id);
self->object_reg_id = 0;
g_bus_unown_name (self->owner_id);
self->owner_id = 0;
g_bus_unwatch_name (self->obexd_watch_id);
self->obexd_watch_id = 0;
g_clear_object (&client);
G_OBJECT_CLASS (obex_agent_parent_class)->dispose (obj);
}
static void
obex_agent_class_init (ObexAgentClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->dispose = obex_agent_dispose;
}
static ObexAgent *
obex_agent_new (void)
{
return (ObexAgent *) g_object_new (OBEX_AGENT_TYPE, NULL);
}
void
obex_agent_down (void)
{
if (agent != NULL) {
g_dbus_connection_call (agent->connection,
MANAGER_SERVICE,
MANAGER_PATH,
MANAGER_IFACE,
"UnregisterAgent",
g_variant_new ("(o)", AGENT_PATH),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
NULL,
NULL);
}
g_clear_object (&agent);
g_clear_object (&client);
}
void
obex_agent_up (void)
{
if (agent == NULL)
agent = obex_agent_new ();
if (!notify_init ("gnome-bluetooth")) {
g_warning("Unable to initialize the notification system");
}
}