colin/ModemManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

core: implement the Manager1 DBus interface, based on GDBus

Browse Source 
The MMManager object now derives from the gdbus-codegen-generated
MmGdbusOrgFreedesktopModemManager1Skeleton object, and implements the handlers
for the SetLogging() and ScanDevices() DBus methods.

The main program is also modified to be based on GDBus.
This commit is contained in:
Aleksander Morgado
2011-10-25 13:06:21 +02:00
parent a6d9bad4bd
commit 60c7f7d9ee
3 changed files with 193 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
src/main.c
View File

@@ -19,10 +19,12 @@
#include <syslog.h>
#include <string.h>
#include <unistd.h>
#include <dbus/dbus-glib.h>
#include <dbus/dbus-glib-lowlevel.h>
#include <stdlib.h>
#include <gio/gio.h>
#include "ModemManager.h"
#include "mm-manager.h"
#include "mm-log.h"
@@ -30,7 +32,8 @@
# define MM_DIST_VERSION VERSION
#endif
static GMainLoop *loop = NULL;
static GMainLoop *loop;
static MMManager *manager;
static void
mm_signal_handler (int signo)
@@ -62,68 +65,46 @@ setup_signals (void)
}
static void
destroy_cb (DBusGProxy *proxy, gpointer user_data)
name_acquired_cb (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
mm_warn ("disconnected from the system bus, exiting.");
GError *error = NULL;
mm_dbg ("Service name '%s' was acquired", name);
/* Create Manager object */
g_assert (!manager);
manager = mm_manager_new (connection, &error);
if (!manager) {
mm_warn ("Could not create manager: %s", error->message);
g_error_free (error);
g_main_loop_quit (loop);
return;
}
static DBusGProxy *
create_dbus_proxy (DBusGConnection *bus)
/* Launch scan for devices */
mm_manager_start (manager);
}
static void
name_lost_cb (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
DBusGProxy *proxy;
GError *err = NULL;
int request_name_result;
proxy = dbus_g_proxy_new_for_name (bus,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus");
if (!dbus_g_proxy_call (proxy, "RequestName", &err,
G_TYPE_STRING, MM_DBUS_SERVICE,
G_TYPE_UINT, DBUS_NAME_FLAG_DO_NOT_QUEUE,
G_TYPE_INVALID,
G_TYPE_UINT, &request_name_result,
G_TYPE_INVALID)) {
mm_warn ("Could not acquire the %s service.\n"
" Message: '%s'", MM_DBUS_SERVICE, err->message);
g_error_free (err);
g_object_unref (proxy);
proxy = NULL;
} else if (request_name_result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
mm_warn ("Could not acquire the " MM_DBUS_SERVICE
" service as it is already taken. Return: %d",
request_name_result);
g_object_unref (proxy);
proxy = NULL;
} else {
dbus_g_proxy_add_signal (proxy, "NameOwnerChanged",
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_INVALID);
}
return proxy;
}
static gboolean
start_manager (gpointer user_data)
{
mm_manager_start (MM_MANAGER (user_data));
return FALSE;
/* Note that we're not allowing replacement, so once the name acquired, the
* process won't lose it. */
mm_warn ("Could not acquire the '%s' service name", name);
g_main_loop_quit (loop);
}
int
main (int argc, char *argv[])
{
DBusGConnection *bus;
DBusGProxy *proxy;
MMManager *manager;
GDBusConnection *bus;
GError *err = NULL;
GOptionContext *opt_ctx;
guint id;
guint name_id;
const char *log_level = NULL, *log_file = NULL;
gboolean debug = FALSE, show_ts = FALSE, rel_ts = FALSE;
@@ -166,7 +147,8 @@ main (int argc, char *argv[])
mm_info ("ModemManager (version " MM_DIST_VERSION ") starting...");
bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &err);
/* Get system bus */
bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &err);
if (!bus) {
g_warning ("Could not get the system bus. Make sure "
"the message bus daemon is running! Message: %s",
@@ -175,31 +157,20 @@ main (int argc, char *argv[])
return -1;
}
#ifndef HAVE_DBUS_GLIB_DISABLE_LEGACY_PROP_ACCESS
#error HAVE_DBUS_GLIB_DISABLE_LEGACY_PROP_ACCESS not defined
#endif
#if HAVE_DBUS_GLIB_DISABLE_LEGACY_PROP_ACCESS
/* Ensure that non-exported properties don't leak out, and that the
* introspection 'access' permissions are respected.
*/
dbus_glib_global_set_disable_legacy_property_access ();
#endif
proxy = create_dbus_proxy (bus);
if (!proxy)
return -1;
manager = mm_manager_new (bus);
g_idle_add (start_manager, manager);
/* Acquire name, don't allow replacement */
name_id = g_bus_own_name_on_connection (bus,
MM_DBUS_SERVICE,
G_BUS_NAME_OWNER_FLAGS_NONE,
name_acquired_cb,
name_lost_cb,
NULL,
NULL);
/* Go into the main loop */
loop = g_main_loop_new (NULL, FALSE);
id = g_signal_connect (proxy, "destroy", G_CALLBACK (destroy_cb), loop);
g_main_loop_run (loop);
g_signal_handler_disconnect (proxy, id);
if (manager) {
mm_manager_shutdown (manager);
/* Wait for all modems to be removed */
@@ -211,8 +182,10 @@ main (int argc, char *argv[])
}
g_object_unref (manager);
g_object_unref (proxy);
dbus_g_connection_unref (bus);
}
g_bus_unown_name (name_id);
g_object_unref (bus);
mm_log_shutdown ();

308
src/mm-manager.c
View File

@@ -13,15 +13,21 @@
* Copyright (C) 2008 - 2009 Novell, Inc.
* Copyright (C) 2009 - 2011 Red Hat, Inc.
* Copyright (C) 2011 Aleksander Morgado <aleksander@gnu.org>
* Copyright (C) 2011 Google, Inc.
*/
#include <string.h>
#include <ctype.h>
#include <gmodule.h>
#define G_UDEV_API_IS_SUBJECT_TO_CHANGE
#include <gudev/gudev.h>
#include <dbus/dbus-glib.h>
#include <dbus/dbus-glib-lowlevel.h>
#include <ModemManager.h>
#include <mm-gdbus-manager.h>
#include "mm-manager.h"
#include "mm-plugin-manager.h"
#include "mm-auth-provider.h"
@@ -30,39 +36,17 @@
#include "mm-log.h"
#include "mm-port-probe-cache.h"
static gboolean impl_manager_enumerate_devices (MMManager *manager,
GPtrArray **devices,
GError **err);
static void impl_manager_scan_devices (MMManager *manager,
DBusGMethodInvocation *context);
static gboolean impl_manager_set_logging (MMManager *manager,
const char *level,
GError **error);
static void grab_port (MMManager *manager,
MMPlugin *plugin,
GUdevDevice *device,
GUdevDevice *physical_device);
#include "mm-manager-glue.h"
G_DEFINE_TYPE (MMManager, mm_manager, G_TYPE_OBJECT)
enum {
DEVICE_ADDED,
DEVICE_REMOVED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE (MMManager, mm_manager, MM_GDBUS_TYPE_ORG_FREEDESKTOP_MODEM_MANAGER1_SKELETON);
#define MM_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MM_TYPE_MANAGER, MMManagerPrivate))
typedef struct {
DBusGConnection *connection;
GDBusConnection *connection;
GUdevClient *udev;
GHashTable *modems;
@@ -101,37 +85,6 @@ find_port_support_context_free (FindPortSupportContext *ctx)
g_free (ctx);
}
MMManager *
mm_manager_new (DBusGConnection *bus)
{
MMManager *manager;
g_return_val_if_fail (bus != NULL, NULL);
manager = (MMManager *) g_object_new (MM_TYPE_MANAGER, NULL);
if (manager) {
GError *error = NULL;
MMManagerPrivate *priv = MM_MANAGER_GET_PRIVATE (manager);
priv->connection = dbus_g_connection_ref (bus);
dbus_g_connection_register_g_object (priv->connection,
MM_DBUS_PATH,
G_OBJECT (manager));
priv->plugin_manager = mm_plugin_manager_new (&error);
if (!priv->plugin_manager) {
mm_warn ("Error creating Plugin Manager: '%s'",
error ? error->message : "unknown error");
g_clear_error (&error);
g_object_unref (manager);
manager = NULL;
}
}
return manager;
}
static void
remove_modem (MMManager *manager, MMModem *modem)
{
@@ -142,7 +95,8 @@ remove_modem (MMManager *manager, MMModem *modem)
g_assert (device);
mm_dbg ("Removed modem %s", device);
g_signal_emit (manager, signals[DEVICE_REMOVED], 0, modem);
/* GDBus TODO: Unexport object
* g_signal_emit (manager, signals[DEVICE_REMOVED], 0, modem); */
g_hash_table_remove (priv->modems, device);
g_free (device);
}
@@ -190,13 +144,14 @@ check_export_modem (MMManager *self, MMModem *modem)
/* No outstanding port tasks, so if the modem is valid we can export it */
if (mm_modem_get_valid (modem)) {
static guint32 id = 0, vid = 0, pid = 0;
char *path, *data_device = NULL;
gchar *path, *data_device = NULL;
GUdevDevice *physdev;
subsys = NULL;
path = g_strdup_printf (MM_DBUS_PATH"/Modems/%d", id++);
dbus_g_connection_register_g_object (priv->connection, path, G_OBJECT (modem));
/* GDBus TODO:
* dbus_g_connection_register_g_object (priv->connection, path, G_OBJECT (modem)); */
g_object_set_data_full (G_OBJECT (modem), DBUS_PATH_TAG, path, (GDestroyNotify) g_free);
mm_dbg ("Exported modem %s as %s", modem_physdev, path);
@@ -219,7 +174,8 @@ check_export_modem (MMManager *self, MMModem *modem)
if (physdev)
g_object_unref (physdev);
g_signal_emit (self, signals[DEVICE_ADDED], 0, modem);
/* GDBus TODO: export object
* g_signal_emit (self, signals[DEVICE_ADDED], 0, modem); */
}
out:
@@ -258,36 +214,6 @@ add_modem (MMManager *manager, MMModem *modem, MMPlugin *plugin)
g_free (device);
}
static void
enumerate_devices_cb (gpointer key, gpointer val, gpointer user_data)
{
MMModem *modem = MM_MODEM (val);
GPtrArray **devices = (GPtrArray **) user_data;
if (mm_modem_get_valid (modem)) {
const char *path;
path = g_object_get_data (G_OBJECT (modem), DBUS_PATH_TAG);
/* A valid modem without dbus path may happen when enumerating devices
* while there is an ongoing modem probing. */
if (path)
g_ptr_array_add (*devices, g_strdup (path));
}
}
static gboolean
impl_manager_enumerate_devices (MMManager *manager,
GPtrArray **devices,
GError **err)
{
MMManagerPrivate *priv = MM_MANAGER_GET_PRIVATE (manager);
*devices = g_ptr_array_sized_new (g_hash_table_size (priv->modems));
g_hash_table_foreach (priv->modems, enumerate_devices_cb, devices);
return TRUE;
}
static MMModem *
find_modem_for_device (MMManager *manager, const char *device)
{
@@ -674,62 +600,6 @@ handle_uevent (GUdevClient *client,
device_removed (self, device);
}
static void
scan_devices_auth_cb (MMAuthRequest *req,
GObject *owner,
DBusGMethodInvocation *context,
gpointer user_data)
{
if (mm_auth_request_get_result (req) != MM_AUTH_RESULT_AUTHORIZED) {
GError *error;
error = g_error_new (MM_MODEM_ERROR, MM_MODEM_ERROR_AUTHORIZATION_REQUIRED,
"This request requires the '%s' authorization",
mm_auth_request_get_authorization (req));
dbus_g_method_return_error (context, error);
g_error_free (error);
return;
}
/* Otherwise relaunch device scan */
mm_manager_start (MM_MANAGER (owner));
dbus_g_method_return (context);
}
static void
impl_manager_scan_devices (MMManager *manager,
DBusGMethodInvocation *context)
{
GError *error = NULL;
MMManagerPrivate *priv;
priv = MM_MANAGER_GET_PRIVATE (manager);
if (!mm_auth_provider_request_auth (priv->authp,
MM_AUTHORIZATION_MANAGER_CONTROL,
G_OBJECT (manager),
context,
(MMAuthRequestCb)scan_devices_auth_cb,
NULL,
NULL,
&error)) {
dbus_g_method_return_error (context, error);
g_error_free (error);
}
}
static gboolean
impl_manager_set_logging (MMManager *manager,
const char *level,
GError **error)
{
if (mm_log_set_level (level, error)) {
mm_info ("logging: level '%s'", level);
return TRUE;
}
return FALSE;
}
void
mm_manager_start (MMManager *manager)
{
@@ -825,6 +695,117 @@ mm_manager_num_modems (MMManager *self)
return g_hash_table_size (MM_MANAGER_GET_PRIVATE (self)->modems);
}
static gboolean
handle_set_logging (MmGdbusOrgFreedesktopModemManager1 *manager,
GDBusMethodInvocation *invocation,
const gchar *level)
{
GError *error = NULL;
if (!mm_log_set_level (level, &error)) {
mm_warn ("couldn't set logging level to '%s': '%s'",
level,
error->message);
g_dbus_method_invocation_return_gerror (invocation, error);
g_error_free (error);
return TRUE;
}
mm_info ("logging: level '%s'", level);
mm_gdbus_org_freedesktop_modem_manager1_complete_set_logging (manager, invocation);
return TRUE;
}
static void
scan_devices_request_auth_cb (MMAuthRequest *req,
MmGdbusOrgFreedesktopModemManager1 *manager,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
if (mm_auth_request_get_result (req) != MM_AUTH_RESULT_AUTHORIZED) {
g_dbus_method_invocation_return_error (invocation,
MM_MODEM_ERROR,
MM_MODEM_ERROR_AUTHORIZATION_REQUIRED,
"This request requires the '%s' authorization",
mm_auth_request_get_authorization (req));
return;
}
/* Otherwise relaunch device scan */
mm_manager_start (MM_MANAGER (manager));
mm_gdbus_org_freedesktop_modem_manager1_complete_scan_devices (manager, invocation);
g_object_unref (invocation);
}
static gboolean
handle_scan_devices (MmGdbusOrgFreedesktopModemManager1 *manager,
GDBusMethodInvocation *invocation)
{
GError *error = NULL;
MMManagerPrivate *priv;
priv = MM_MANAGER_GET_PRIVATE (manager);
if (!mm_auth_provider_request_auth (priv->authp,
MM_AUTHORIZATION_MANAGER_CONTROL,
G_OBJECT (manager),
g_object_ref (invocation),
(MMAuthRequestCb)scan_devices_request_auth_cb,
NULL,
NULL,
&error)) {
g_dbus_method_invocation_return_gerror (invocation, error);
g_error_free (error);
g_object_unref (invocation);
}
return TRUE;
}
MMManager *
mm_manager_new (GDBusConnection *connection,
GError **error)
{
MMManager *manager;
g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL);
manager = (MMManager *) g_object_new (MM_TYPE_MANAGER, NULL);
if (manager) {
MMManagerPrivate *priv = MM_MANAGER_GET_PRIVATE (manager);
priv->plugin_manager = mm_plugin_manager_new (error);
if (!priv->plugin_manager) {
g_object_unref (manager);
return NULL;
}
priv->connection = g_object_ref (connection);
/* Enable processing of input DBus messages */
g_signal_connect (manager,
"handle-set-logging",
G_CALLBACK (handle_set_logging),
NULL);
g_signal_connect (manager,
"handle-scan-devices",
G_CALLBACK (handle_scan_devices),
NULL);
/* Export the manager interface */
if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (manager),
priv->connection,
MM_DBUS_PATH,
error))
{
g_object_unref (manager);
return NULL;
}
}
return manager;
}
static void
mm_manager_init (MMManager *manager)
{
@@ -856,7 +837,7 @@ finalize (GObject *object)
g_object_unref (priv->plugin_manager);
if (priv->connection)
dbus_g_connection_unref (priv->connection);
g_object_unref (priv->connection);
G_OBJECT_CLASS (mm_manager_parent_class)->finalize (object);
}
@@ -870,35 +851,4 @@ mm_manager_class_init (MMManagerClass *manager_class)
/* Virtual methods */
object_class->finalize = finalize;
/* Signals */
signals[DEVICE_ADDED] =
g_signal_new ("device-added",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (MMManagerClass, device_added),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
G_TYPE_OBJECT);
signals[DEVICE_REMOVED] =
g_signal_new ("device-removed",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (MMManagerClass, device_removed),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
G_TYPE_OBJECT);
dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (manager_class),
&dbus_glib_mm_manager_object_info);
dbus_g_error_domain_register (MM_SERIAL_ERROR, "org.freedesktop.ModemManager.Modem", MM_TYPE_SERIAL_ERROR);
dbus_g_error_domain_register (MM_MODEM_ERROR, "org.freedesktop.ModemManager.Modem", MM_TYPE_MODEM_ERROR);
dbus_g_error_domain_register (MM_MODEM_CONNECT_ERROR, "org.freedesktop.ModemManager.Modem", MM_TYPE_MODEM_CONNECT_ERROR);
dbus_g_error_domain_register (MM_MOBILE_ERROR, "org.freedesktop.ModemManager.Modem.Gsm", MM_TYPE_MOBILE_ERROR);
dbus_g_error_domain_register (MM_MSG_ERROR, "org.freedesktop.ModemManager.Modem.Gsm.SMS", MM_TYPE_MSG_ERROR);
}

19
src/mm-manager.h
View File

@@ -11,15 +11,17 @@
* GNU General Public License for more details:
*
* Copyright (C) 2008 - 2009 Novell, Inc.
* Copyright (C) 2009 Red Hat, Inc.
* Copyright (C) 2009 - 2011 Red Hat, Inc.
* Copyright (C) 2011 Google, Inc.
*/
#ifndef MM_MANAGER_H
#define MM_MANAGER_H
#include <glib-object.h>
#include <dbus/dbus-glib.h>
#include "mm-modem.h"
#include <gio/gio.h>
#include "mm-gdbus-manager.h"
#define MM_TYPE_MANAGER (mm_manager_get_type ())
#define MM_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MM_TYPE_MANAGER, MMManager))
@@ -29,20 +31,17 @@
#define MM_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MM_TYPE_MANAGER, MMManagerClass))
typedef struct {
GObject parent;
MmGdbusOrgFreedesktopModemManager1Skeleton parent;
} MMManager;
typedef struct {
GObjectClass parent;
/* Signals */
void (*device_added) (MMManager *manager, MMModem *device);
void (*device_removed) (MMManager *manager, MMModem *device);
MmGdbusOrgFreedesktopModemManager1SkeletonClass parent;
} MMManagerClass;
GType mm_manager_get_type (void);
MMManager *mm_manager_new (DBusGConnection *bus);
MMManager *mm_manager_new (GDBusConnection *bus,
GError **error);
void mm_manager_start (MMManager *manager);