modem/call: using telepathy coding style

3 files changed, 1629 insertions, 1549 deletions

diff --git a/modem/call-service.c b/modem/call-service.c
index 124e960..89c3a0a 100644
--- a/modem/call-service.c
+++ b/modem/call-service.c
@@ -41,19 +41,19 @@
 
 /* ---------------------------------------------------------------------- */
 
-/* ---------------------------------------------------------------------- */
-
-G_DEFINE_TYPE(ModemCallService, modem_call_service, G_TYPE_OBJECT);
+G_DEFINE_TYPE (ModemCallService, modem_call_service, G_TYPE_OBJECT);
 
 /* Properties */
-enum {
+enum
+{
   PROP_NONE,
   PROP_EMERGENCY_NUMBERS,
   LAST_PROPERTY
 };
 
 /* Signals */
-enum {
+enum
+{
   SIGNAL_CONNECTED,
   SIGNAL_INCOMING,
   SIGNAL_CREATED,
@@ -101,159 +101,160 @@ struct _ModemCallServicePrivate
 static ModemOfonoPropsReply reply_to_call_manager_get_properties;
 static ModemOfonoPropChangedCb on_manager_property_changed;
 
-static void modem_call_service_connect_to_instance(ModemCallService *self,
-  ModemCall *ci);
-
-static void modem_call_service_disconnect_instance(ModemCallService *self,
-  ModemCall *ci);
+static void modem_call_service_connect_to_instance (ModemCallService *self,
+    ModemCall *ci);
 
-typedef void MyDBusGProxyCallNotify(DBusGProxy *, DBusGProxyCall *, gpointer);
+static void modem_call_service_disconnect_instance (ModemCallService *self,
+    ModemCall *ci);
 
 static ModemRequestCallNotify modem_call_request_dial_reply;
 
 static ModemRequestCallNotify modem_call_conference_request_reply;
 
-static void modem_call_service_check_connected(ModemCallService *self,
-  ModemRequest *request,
-  GError const *error);
+static void modem_call_service_check_connected (ModemCallService *self,
+    ModemRequest *request,
+    GError const *error);
+
 #if nomore
-static void on_user_connection(DBusGProxy *proxy,
-  gboolean attached,
-  ModemCallService *self);
+static void on_user_connection (DBusGProxy *proxy,
+    gboolean attached,
+    ModemCallService *self);
 #endif
-static void on_modem_call_state(ModemCall *, ModemCallState,
-  ModemCallService *);
-static void on_modem_call_terminated(ModemCall *, ModemCallService *);
+static void on_modem_call_state (ModemCall *, ModemCallState,
+    ModemCallService *);
+static void on_modem_call_terminated (ModemCall *, ModemCallService *);
 
 /* ---------------------------------------------------------------------- */
 
 static void
-modem_call_service_constructed(GObject *object)
+modem_call_service_constructed (GObject *object)
 {
-  if (G_OBJECT_CLASS(modem_call_service_parent_class)->constructed)
-    G_OBJECT_CLASS(modem_call_service_parent_class)->constructed(object);
+  if (G_OBJECT_CLASS (modem_call_service_parent_class)->constructed)
+    G_OBJECT_CLASS (modem_call_service_parent_class)->constructed (object);
 }
 
 static void
-modem_call_service_init(ModemCallService *self)
+modem_call_service_init (ModemCallService *self)
 {
-  self->priv = G_TYPE_INSTANCE_GET_PRIVATE(
-    self, MODEM_TYPE_CALL_SERVICE, ModemCallServicePrivate);
+  self->priv = G_TYPE_INSTANCE_GET_PRIVATE(self,
+      MODEM_TYPE_CALL_SERVICE, ModemCallServicePrivate);
 
-  g_queue_init(self->priv->dialing.queue);
-  g_queue_init(self->priv->dialing.created);
+  g_queue_init (self->priv->dialing.queue);
+  g_queue_init (self->priv->dialing.created);
 
-  g_queue_init(self->priv->connecting.queue);
+  g_queue_init (self->priv->connecting.queue);
 
-  self->priv->instances = g_hash_table_new_full(
-    g_str_hash, g_str_equal, g_free, g_object_unref);
+  self->priv->instances = g_hash_table_new_full (
+      g_str_hash, g_str_equal, g_free, g_object_unref);
 }
 
 static void
-modem_call_service_get_property(GObject *object,
-  guint property_id,
-  GValue *value,
-  GParamSpec *pspec)
+modem_call_service_get_property (GObject *object,
+                                 guint property_id,
+                                 GValue *value,
+                                 GParamSpec *pspec)
 {
-  ModemCallService *self = MODEM_CALL_SERVICE(object);
-
-  switch(property_id) {
+  ModemCallService *self = MODEM_CALL_SERVICE (object);
 
+  switch (property_id)
+    {
     case PROP_EMERGENCY_NUMBERS:
-      g_value_set_boxed(value, modem_call_get_emergency_numbers(self));
+      g_value_set_boxed (value, modem_call_get_emergency_numbers (self));
       break;
 
     default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
       break;
-  }
+    }
 }
 
 static void
-modem_call_service_set_property(GObject *obj,
-  guint property_id,
-  const GValue *value,
-  GParamSpec *pspec)
+modem_call_service_set_property (GObject *obj,
+                                 guint property_id,
+                                 const GValue *value,
+                                 GParamSpec *pspec)
 {
-  ModemCallService *self = MODEM_CALL_SERVICE(obj);
+  ModemCallService *self = MODEM_CALL_SERVICE (obj);
   ModemCallServicePrivate *priv = self->priv;
   gpointer old;
 
-  switch (property_id) {
+  switch (property_id)
+    {
 
     case PROP_EMERGENCY_NUMBERS:
       old = priv->emergency_numbers;
-      priv->emergency_numbers = g_value_dup_boxed(value);
-      g_strfreev(old);
+      priv->emergency_numbers = g_value_dup_boxed (value);
+      g_strfreev (old);
       break;
 
     default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, property_id, pspec);
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec);
       break;
-  }
+    }
 }
 
 static void
-modem_call_service_dispose(GObject *object)
+modem_call_service_dispose (GObject *object)
 {
-  DEBUG("enter");
+  DEBUG ("enter");
 
   ModemCall *ci;
   GHashTableIter iter[1];
-  ModemCallService *self = MODEM_CALL_SERVICE(object);
+  ModemCallService *self = MODEM_CALL_SERVICE (object);
   ModemCallServicePrivate *priv = self->priv;
 
   if (priv->dispose_has_run)
     return;
 
-  modem_call_service_disconnect(self);
+  modem_call_service_disconnect (self);
 
   priv->dispose_has_run = TRUE;
 
-  g_hash_table_iter_init(iter, priv->instances);
-  while (g_hash_table_iter_next (iter, NULL, (gpointer)&ci)) {
-    modem_call_service_disconnect_instance(self, ci);
-  }
+  g_hash_table_iter_init (iter, priv->instances);
+  while (g_hash_table_iter_next (iter, NULL, (gpointer)&ci))
+    {
+      modem_call_service_disconnect_instance (self, ci);
+    }
 
   ci = priv->conference.instance;
-  modem_call_service_disconnect_instance(self, ci);
+  modem_call_service_disconnect_instance (self, ci);
 
   if (priv->proxy)
-    g_object_run_dispose(G_OBJECT(priv->proxy));
+    g_object_run_dispose (G_OBJECT (priv->proxy));
 
-  if (G_OBJECT_CLASS(modem_call_service_parent_class)->dispose)
-    G_OBJECT_CLASS(modem_call_service_parent_class)->dispose(object);
+  if (G_OBJECT_CLASS (modem_call_service_parent_class)->dispose)
+    G_OBJECT_CLASS (modem_call_service_parent_class)->dispose (object);
 
-  DEBUG("leave");
+  DEBUG ("leave");
 }
 
 
 static void
-modem_call_service_finalize(GObject *object)
+modem_call_service_finalize (GObject *object)
 {
-  DEBUG("enter");
+  DEBUG ("enter");
 
-  ModemCallService *self = MODEM_CALL_SERVICE(object);
+  ModemCallService *self = MODEM_CALL_SERVICE (object);
   ModemCallServicePrivate *priv = self->priv;
 
-  if (priv->proxy) g_object_unref(priv->proxy), priv->proxy = NULL;
-  g_strfreev(priv->emergency_numbers), priv->emergency_numbers = NULL;
-  g_clear_error(&priv->connecting.error);
+  if (priv->proxy) g_object_unref (priv->proxy), priv->proxy = NULL;
+  g_strfreev (priv->emergency_numbers), priv->emergency_numbers = NULL;
+  g_clear_error (&priv->connecting.error);
 
-  g_hash_table_destroy(priv->instances);
+  g_hash_table_destroy (priv->instances);
 
-  G_OBJECT_CLASS(modem_call_service_parent_class)->finalize(object);
+  G_OBJECT_CLASS (modem_call_service_parent_class)->finalize (object);
 
-  DEBUG("leave");
+  DEBUG ("leave");
 }
 
 
 static void
-modem_call_service_class_init(ModemCallServiceClass *klass)
+modem_call_service_class_init (ModemCallServiceClass *klass)
 {
-  GObjectClass *object_class = G_OBJECT_CLASS(klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-  g_type_class_add_private(klass, sizeof (ModemCallServicePrivate));
+  g_type_class_add_private (klass, sizeof (ModemCallServicePrivate));
 
   object_class->constructed = modem_call_service_constructed;
   object_class->get_property = modem_call_service_get_property;
@@ -262,80 +263,74 @@ modem_call_service_class_init(ModemCallServiceClass *klass)
   object_class->finalize = modem_call_service_finalize;
 
   /* Properties */
-  g_object_class_install_property(
-    object_class, PROP_EMERGENCY_NUMBERS,
-    g_param_spec_boxed("emergency-numbers",
-      "Emergency Numbers",
-      "List of emergency numbers obtained from modem",
-      G_TYPE_STRV,
-      G_PARAM_READWRITE | G_PARAM_CONSTRUCT |
-      G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (object_class, PROP_EMERGENCY_NUMBERS,
+      g_param_spec_boxed ("emergency-numbers",
+          "Emergency Numbers",
+          "List of emergency numbers obtained from modem",
+          G_TYPE_STRV,
+          G_PARAM_READWRITE | G_PARAM_CONSTRUCT |
+          G_PARAM_STATIC_STRINGS));
 
   /* Signals to emit */
   signals[SIGNAL_CONNECTED] =
-    g_signal_new("connected",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      g_cclosure_marshal_VOID__VOID,
-      G_TYPE_NONE, 0);
+    g_signal_new ("connected", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        g_cclosure_marshal_VOID__VOID,
+        G_TYPE_NONE, 0);
 
   signals[SIGNAL_INCOMING] =
-    g_signal_new("incoming",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      _modem__marshal_VOID__OBJECT_STRING,
-      G_TYPE_NONE, 2,
-      MODEM_TYPE_CALL, G_TYPE_STRING);
+    g_signal_new ("incoming", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        _modem__marshal_VOID__OBJECT_STRING,
+        G_TYPE_NONE, 2,
+        MODEM_TYPE_CALL, G_TYPE_STRING);
 
   signals[SIGNAL_CREATED] =
-    g_signal_new("created",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      _modem__marshal_VOID__OBJECT_STRING,
-      G_TYPE_NONE, 2,
-      MODEM_TYPE_CALL, G_TYPE_STRING);
+    g_signal_new ("created", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        _modem__marshal_VOID__OBJECT_STRING,
+        G_TYPE_NONE, 2,
+        MODEM_TYPE_CALL, G_TYPE_STRING);
 
   signals[SIGNAL_USER_CONNECTION] =
-    g_signal_new("user-connection",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      g_cclosure_marshal_VOID__BOOLEAN,
-      G_TYPE_NONE, 1,
-      G_TYPE_BOOLEAN);
+    g_signal_new ("user-connection", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        g_cclosure_marshal_VOID__BOOLEAN,
+        G_TYPE_NONE, 1,
+        G_TYPE_BOOLEAN);
 
   signals[SIGNAL_EMERGENCY_NUMBERS_CHANGED] =
-    g_signal_new("emergency-numbers-changed",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      g_cclosure_marshal_VOID__BOXED,
-      G_TYPE_NONE, 1,
-      G_TYPE_STRV);
+    g_signal_new ("emergency-numbers-changed", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        g_cclosure_marshal_VOID__BOXED,
+        G_TYPE_NONE, 1,
+        G_TYPE_STRV);
 
 
-  modem_error_domain_prefix(0); /* Init errors */
+  modem_error_domain_prefix (0); /* Init errors */
 }
 
 /* ---------------------------------------------------------------------- */
 
-#define RETURN_NULL_IF_NOT_VALID(self)                                  \
-  g_return_val_if_fail(self != NULL && self->priv->proxy != NULL &&     \
-    !self->priv->dispose_has_run, NULL)
+#define RETURN_NULL_IF_NOT_VALID(self)                                 \
+  g_return_val_if_fail (self != NULL && self->priv->proxy != NULL &&    \
+      !self->priv->dispose_has_run, NULL)
 
 /* ---------------------------------------------------------------------- */
 
 static ModemOfonoGetDescsReply reply_to_call_manager_get_calls;
 
-static void on_manager_call_added(DBusGProxy *proxy,
+static void on_manager_call_added (DBusGProxy *proxy,
     char const *path,
     GHashTable *properties,
     gpointer user_data);
@@ -343,33 +338,35 @@ static void on_manager_call_added(DBusGProxy *proxy,
 /* ---------------------------------------------------------------------- */
 
 static void
-modem_call_service_connect_to_instance(ModemCallService *self,
-  ModemCall *instance)
+modem_call_service_connect_to_instance (ModemCallService *self,
+                                        ModemCall *instance)
 {
-  if (instance) {
-    g_signal_connect(instance, "state",
-      G_CALLBACK(on_modem_call_state), self);
-    g_signal_connect_after(instance, "terminated",
-      G_CALLBACK(on_modem_call_terminated), self);
-  }
+  if (instance)
+    {
+      g_signal_connect (instance, "state",
+          G_CALLBACK (on_modem_call_state), self);
+      g_signal_connect_after (instance, "terminated",
+          G_CALLBACK (on_modem_call_terminated), self);
+    }
 }
 
 static void
-modem_call_service_disconnect_instance(ModemCallService *self,
-  ModemCall *instance)
+modem_call_service_disconnect_instance (ModemCallService *self,
+                                        ModemCall *instance)
 {
-  if (instance) {
-    g_signal_handlers_disconnect_by_func(instance,
-      on_modem_call_state, self);
-    g_signal_handlers_disconnect_by_func(instance,
-      on_modem_call_terminated, self);
-  }
+  if (instance)
+    {
+      g_signal_handlers_disconnect_by_func (instance,
+          on_modem_call_state, self);
+      g_signal_handlers_disconnect_by_func (instance,
+          on_modem_call_terminated, self);
+    }
 }
 
 static ModemCall *
-modem_call_service_ensure_instance(ModemCallService *self,
-                                   char const *object_path,
-                                   GHashTable *properties)
+modem_call_service_ensure_instance (ModemCallService *self,
+                                    char const *object_path,
+                                    GHashTable *properties)
 {
   ModemCallServicePrivate *priv = self->priv;
   char *key;
@@ -380,51 +377,55 @@ modem_call_service_ensure_instance(ModemCallService *self,
   gboolean incoming = FALSE, originating = FALSE;
   ModemCall *ci;
 
-  DEBUG("path %s", object_path);
+  DEBUG ("path %s", object_path);
+
+  if (DEBUGGING)
+    {
+      for (g_hash_table_iter_init (iter, properties);
+           g_hash_table_iter_next (iter, (gpointer)&key, (gpointer)&value);)
+        {
+          char *s = g_strdup_value_contents (value);
+          DEBUG ("%s = %s", key, s);
+          g_free (s);
+        }
+    }
 
-  if (DEBUGGING) {
-    for (g_hash_table_iter_init(iter, properties);
-         g_hash_table_iter_next(iter, (gpointer)&key, (gpointer)&value);) {
-      char *s = g_strdup_value_contents(value);
-      DEBUG("%s = %s", key, s);
-      g_free(s);
+  ci = g_hash_table_lookup (priv->instances, object_path);
+  if (ci)
+    {
+      DEBUG ("call already exists %p", (void *)ci);
+      return ci;
     }
-  }
 
-  ci = g_hash_table_lookup(priv->instances, object_path);
-  if (ci) {
-    DEBUG("call already exists %p", (void *)ci);
-    return ci;
-  }
+  value = g_hash_table_lookup (properties, "LineIdentification");
+  remote = g_value_get_string (value);
 
-  value = g_hash_table_lookup(properties, "LineIdentification");
-  remote = g_value_get_string(value);
-
-  value = g_hash_table_lookup(properties, "State");
-  state = modem_call_state_from_ofono_state(g_value_get_string(value));
-
-  switch (state) {
-  case MODEM_CALL_STATE_INCOMING:
-  case MODEM_CALL_STATE_WAITING:
-    incoming = TRUE;
-    originating = FALSE;
-    break;
-
-  case MODEM_CALL_STATE_DIALING:
-  case MODEM_CALL_STATE_ALERTING:
-  case MODEM_CALL_STATE_ACTIVE:
-  case MODEM_CALL_STATE_HELD:
-    incoming = FALSE;
-    originating = TRUE;
-    break;
-
-  case MODEM_CALL_STATE_INVALID:
-  case MODEM_CALL_STATE_DISCONNECTED:
-    DEBUG("call already in invalid state");
-    return NULL;
-  }
+  value = g_hash_table_lookup (properties, "State");
+  state = modem_call_state_from_ofono_state (g_value_get_string (value));
+
+  switch (state)
+    {
+    case MODEM_CALL_STATE_INCOMING:
+    case MODEM_CALL_STATE_WAITING:
+      incoming = TRUE;
+      originating = FALSE;
+      break;
+
+    case MODEM_CALL_STATE_DIALING:
+    case MODEM_CALL_STATE_ALERTING:
+    case MODEM_CALL_STATE_ACTIVE:
+    case MODEM_CALL_STATE_HELD:
+      incoming = FALSE;
+      originating = TRUE;
+      break;
+
+    case MODEM_CALL_STATE_INVALID:
+    case MODEM_CALL_STATE_DISCONNECTED:
+      DEBUG ("call already in invalid state");
+      return NULL;
+    }
 
-  ci = g_object_new(MODEM_TYPE_CALL,
+  ci = g_object_new (MODEM_TYPE_CALL,
       "call-service", self,
       "object-path", object_path,
       "remote", remote,
@@ -433,45 +434,48 @@ modem_call_service_ensure_instance(ModemCallService *self,
       "originating",  originating,
       NULL);
 
-  modem_call_service_connect_to_instance(self, ci);
-  g_hash_table_insert(priv->instances, g_strdup(object_path), ci);
+  modem_call_service_connect_to_instance (self, ci);
+  g_hash_table_insert (priv->instances, g_strdup (object_path), ci);
 
-  if (incoming) {
-    DEBUG("emit \"incoming\"(%s (%p), %s)",
-        modem_call_get_name(ci), ci, remote);
-    g_signal_emit(self, signals[SIGNAL_INCOMING], 0, ci, remote);
-  }
-  else if (g_queue_is_empty(priv->dialing.queue)) {
-    DEBUG("emit \"created\"(%s (%p), %s)",
-        modem_call_get_name(ci), ci, remote);
-    g_signal_emit(self, signals[SIGNAL_CREATED], 0, ci, remote);
-  }
+  if (incoming)
+    {
+      DEBUG ("emit \"incoming\"(%s (%p), %s)",
+          modem_call_get_name (ci), ci, remote);
+      g_signal_emit (self, signals[SIGNAL_INCOMING], 0, ci, remote);
+    }
+  else if (g_queue_is_empty (priv->dialing.queue))
+    {
+      DEBUG ("emit \"created\"(%s (%p), %s)",
+          modem_call_get_name (ci), ci, remote);
+      g_signal_emit (self, signals[SIGNAL_CREATED], 0, ci, remote);
+    }
   else {
-    g_queue_push_tail(priv->dialing.created, ci);
+    g_queue_push_tail (priv->dialing.created, ci);
   }
 
   return ci;
 }
 
 static ModemCall *
-modem_call_service_get_dialed(ModemCallService *self,
-                              char const *object_path,
-                              char const *remote)
+modem_call_service_get_dialed (ModemCallService *self,
+                               char const *object_path,
+                               char const *remote)
 {
   ModemCallServicePrivate *priv = self->priv;
   ModemCall *ci;
 
-  ci = g_hash_table_lookup(priv->instances, object_path);
-  if (ci) {
-    DEBUG("call already exists %p", (void *)ci);
+  ci = g_hash_table_lookup (priv->instances, object_path);
+  if (ci)
+    {
+      DEBUG ("call already exists %p", (void *)ci);
 
-    if (g_queue_find(priv->dialing.created, ci))
-      g_queue_remove(priv->dialing.created, ci);
+      if (g_queue_find (priv->dialing.created, ci))
+        g_queue_remove (priv->dialing.created, ci);
 
-    return ci;
-  }
+      return ci;
+    }
 
-  ci = g_object_new(MODEM_TYPE_CALL,
+  ci = g_object_new (MODEM_TYPE_CALL,
       "call-service", self,
       "object-path", object_path,
       "remote", remote,
@@ -480,8 +484,8 @@ modem_call_service_get_dialed(ModemCallService *self,
       "originating", TRUE,
       NULL);
 
-  modem_call_service_connect_to_instance(self, ci);
-  g_hash_table_insert(priv->instances, g_strdup(object_path), ci);
+  modem_call_service_connect_to_instance (self, ci);
+  g_hash_table_insert (priv->instances, g_strdup (object_path), ci);
 
   return ci;
 }
@@ -489,9 +493,9 @@ modem_call_service_get_dialed(ModemCallService *self,
 /* ---------------------------------------------------------------------- */
 
 DBusGProxy *
-_modem_call_service_proxy(ModemCallService *self)
+_modem_call_service_proxy (ModemCallService *self)
 {
-  RETURN_NULL_IF_NOT_VALID(self);
+  RETURN_NULL_IF_NOT_VALID (self);
 
   return self->priv->proxy;
 }
@@ -500,8 +504,8 @@ _modem_call_service_proxy(ModemCallService *self)
 /* ModemCallService interface */
 
 gboolean
-modem_call_service_connect(ModemCallService *self,
-  char const *object_path)
+modem_call_service_connect (ModemCallService *self,
+                            char const *object_path)
 {
   ModemCallServicePrivate *priv = self->priv;
 
@@ -514,39 +518,41 @@ modem_call_service_connect(ModemCallService *self,
   if (priv->connected)
     return TRUE;
 
-  if (!g_queue_is_empty(priv->connecting.queue))
+  if (!g_queue_is_empty (priv->connecting.queue))
     return TRUE;
 
-  g_clear_error(&priv->connecting.error);
+  g_clear_error (&priv->connecting.error);
 
   if (!priv->proxy)
-    priv->proxy = modem_ofono_proxy(object_path,
-                  OFONO_IFACE_CALL_MANAGER);
+    priv->proxy = modem_ofono_proxy (object_path,
+        OFONO_IFACE_CALL_MANAGER);
 
-  if (!priv->proxy) {
-    g_error("Failed to proxy the call service");
-    return FALSE;
-  }
+  if (!priv->proxy)
+    {
+      g_error ("Failed to proxy the call service");
+      return FALSE;
+    }
 
-  if (!priv->signals) {
-    priv->signals = TRUE;
+  if (!priv->signals)
+    {
+      priv->signals = TRUE;
 
-    modem_ofono_proxy_connect_to_property_changed(
-        priv->proxy, on_manager_property_changed, self);
+      modem_ofono_proxy_connect_to_property_changed (
+          priv->proxy, on_manager_property_changed, self);
 
-    dbus_g_proxy_add_signal(priv->proxy, "CallAdded",
-        DBUS_TYPE_G_OBJECT_PATH, MODEM_TYPE_DBUS_DICT, G_TYPE_INVALID);
+      dbus_g_proxy_add_signal (priv->proxy, "CallAdded",
+          DBUS_TYPE_G_OBJECT_PATH, MODEM_TYPE_DBUS_DICT, G_TYPE_INVALID);
 
-    dbus_g_proxy_connect_signal(priv->proxy, "CallAdded",
-        G_CALLBACK(on_manager_call_added), self, NULL);
-  }
+      dbus_g_proxy_connect_signal (priv->proxy, "CallAdded",
+          G_CALLBACK (on_manager_call_added), self, NULL);
+    }
 
-  g_queue_push_tail(priv->connecting.queue,
-      modem_ofono_proxy_request_properties(priv->proxy,
+  g_queue_push_tail (priv->connecting.queue,
+      modem_ofono_proxy_request_properties (priv->proxy,
           reply_to_call_manager_get_properties, self, NULL));
 
-  g_queue_push_tail(priv->connecting.queue,
-      modem_ofono_request_descs(self, priv->proxy,
+  g_queue_push_tail (priv->connecting.queue,
+      modem_ofono_request_descs (self, priv->proxy,
           "GetCalls", reply_to_call_manager_get_calls, NULL));
 
   return TRUE;
@@ -554,183 +560,199 @@ modem_call_service_connect(ModemCallService *self,
 
 #if 0
 static void
-refresh_conference_memberships(ModemCallService *self,
-  GPtrArray *members)
+refresh_conference_memberships (ModemCallService *self,
+                                GPtrArray *members)
 {
   guint i;
   char const *path;
   ModemCall *ci;
   GList *instances;
 
-  instances = g_hash_table_get_values(self->priv->instances);
+  instances = g_hash_table_get_values (self->priv->instances);
 
-  for (i = 0; i < members->len; i++) {
-    path = g_ptr_array_index(members, i);
+  for (i = 0; i < members->len; i++)
+    {
+      path = g_ptr_array_index (members, i);
 
-    ci = g_hash_table_lookup(self->priv->instances, path);
-    if (ci != NULL) {
-      if (!modem_call_is_member(ci))
-        g_object_set(ci, "member", TRUE, NULL);
+      ci = g_hash_table_lookup (self->priv->instances, path);
+      if (ci != NULL)
+        {
+          if (!modem_call_is_member (ci))
+            g_object_set (ci, "member", TRUE, NULL);
 
-      instances = g_list_remove(instances, ci);
+          instances = g_list_remove (instances, ci);
+        }
     }
-  }
 
   /* The remaining instances aren't members */
-  while (instances) {
-    ci = instances->data;
+  while (instances)
+    {
+      ci = instances->data;
 
-    if (modem_call_is_member(ci))
-      g_object_set(ci, "member", FALSE, NULL);
+      if (modem_call_is_member (ci))
+        g_object_set (ci, "member", FALSE, NULL);
 
-    instances = g_list_delete_link(instances, instances);
-  }
+      instances = g_list_delete_link (instances, instances);
+    }
 }
 #endif
 
 static void
-on_manager_property_changed(DBusGProxy *proxy,
-  char const *property,
-  GValue const *value,
-  gpointer user_data)
+on_manager_property_changed (DBusGProxy *proxy,
+                             char const *property,
+                             GValue const *value,
+                             gpointer user_data)
 {
-  ModemCallService *self = MODEM_CALL_SERVICE(user_data);
-
-  if (DEBUGGING) {
-    char *s;
-    DEBUG("enter");
-    s = g_strdup_value_contents(value);
-    DEBUG("%s = %s", property, s);
-    g_free(s);
-  }
+  ModemCallService *self = MODEM_CALL_SERVICE (user_data);
+
+  if (DEBUGGING)
+    {
+      char *s;
+      DEBUG ("enter");
+      s = g_strdup_value_contents (value);
+      DEBUG ("%s = %s", property, s);
+      g_free (s);
+    }
 
-  if (!strcmp(property, "EmergencyNumbers")) {
-    g_object_set_property(G_OBJECT (self), "emergency-numbers", value);
-    g_signal_emit(self, signals[SIGNAL_EMERGENCY_NUMBERS_CHANGED], 0,
-      modem_call_get_emergency_numbers(self));
-  }
+  if (!strcmp (property, "EmergencyNumbers"))
+    {
+      g_object_set_property (G_OBJECT (self), "emergency-numbers", value);
+      g_signal_emit (self, signals[SIGNAL_EMERGENCY_NUMBERS_CHANGED], 0,
+          modem_call_get_emergency_numbers (self));
+    }
 #if 0
-  else if (!strcmp(property, "MultipartyCalls")) {
-    refresh_conference_memberships(self, g_value_get_boxed(value));
-  }
+  else if (!strcmp (property, "MultipartyCalls"))
+    {
+      refresh_conference_memberships (self, g_value_get_boxed (value));
+    }
 #endif
 }
 
 static void
-reply_to_call_manager_get_properties(gpointer _self,
-  ModemRequest *request,
-  GHashTable *properties,
-  GError const *error,
-  gpointer user_data)
+reply_to_call_manager_get_properties (gpointer _self,
+                                      ModemRequest *request,
+                                      GHashTable *properties,
+                                      GError const *error,
+                                      gpointer user_data)
 {
-  ModemCallService *self = MODEM_CALL_SERVICE(_self);
-
-  DEBUG("enter");
-
-  if (!error) {
-    GValue *value;
-
-    value = g_hash_table_lookup(properties, "EmergencyNumbers");
-    if (value) {
-      g_object_set_property(G_OBJECT (self), "emergency-numbers", value);
-    }
-
-    if (DEBUGGING) {
-      char *key;
-      GHashTableIter iter[1];
-
-      for (g_hash_table_iter_init(iter, properties);
-           g_hash_table_iter_next(iter, (gpointer)&key, (gpointer)&value);) {
-        char *s = g_strdup_value_contents(value);
-        DEBUG("%s = %s", key, s);
-        g_free(s);
-      }
+  ModemCallService *self = MODEM_CALL_SERVICE (_self);
+
+  DEBUG ("enter");
+
+  if (!error)
+    {
+      GValue *value;
+
+      value = g_hash_table_lookup (properties, "EmergencyNumbers");
+      if (value)
+        {
+          g_object_set_property (G_OBJECT (self), "emergency-numbers", value);
+        }
+
+      if (DEBUGGING)
+        {
+          char *key;
+          GHashTableIter iter[1];
+
+          for (g_hash_table_iter_init (iter, properties);
+               g_hash_table_iter_next (iter, (gpointer)&key, (gpointer)&value);)
+            {
+              char *s = g_strdup_value_contents (value);
+              DEBUG ("%s = %s", key, s);
+              g_free (s);
+            }
+        }
     }
-  }
 
-  modem_call_service_check_connected(self, request, error);
+  modem_call_service_check_connected (self, request, error);
 }
 
 static void
-on_manager_call_added(DBusGProxy *proxy,
-                      char const *path,
-                      GHashTable *properties,
-                      gpointer user_data)
+on_manager_call_added (DBusGProxy *proxy,
+                       char const *path,
+                       GHashTable *properties,
+                       gpointer user_data)
 {
-  ModemCallService *self = MODEM_CALL_SERVICE(user_data);
+  ModemCallService *self = MODEM_CALL_SERVICE (user_data);
 
-  DEBUG("%s", path);
+  DEBUG ("%s", path);
 
-  modem_call_service_ensure_instance(self, path, properties);
+  modem_call_service_ensure_instance (self, path, properties);
 }
 
 static void
-reply_to_call_manager_get_calls(gpointer _self,
-                                ModemRequest *request,
-                                GPtrArray *array,
-                                GError const *error,
-                                gpointer user_data)
+reply_to_call_manager_get_calls (gpointer _self,
+                                 ModemRequest *request,
+                                 GPtrArray *array,
+                                 GError const *error,
+                                 gpointer user_data)
 {
   ModemCallService *self = _self;
 
-  DEBUG("enter");
+  DEBUG ("enter");
 
-  if (!error) {
-    guint i;
+  if (!error)
+    {
+      guint i;
 
-    for (i = 0; i < array->len; i++) {
-      GValueArray *va = g_ptr_array_index(array, i);
-      char const *path = g_value_get_boxed(va->values + 0);
-      GHashTable *properties = g_value_get_boxed(va->values + 1);
+      for (i = 0; i < array->len; i++)
+        {
+          GValueArray *va = g_ptr_array_index (array, i);
+          char const *path = g_value_get_boxed (va->values + 0);
+          GHashTable *properties = g_value_get_boxed (va->values + 1);
 
-      modem_call_service_ensure_instance(self, path, properties);
+          modem_call_service_ensure_instance (self, path, properties);
+        }
     }
-  }
 
-  modem_call_service_check_connected(self, request, error);
+  modem_call_service_check_connected (self, request, error);
 }
 
 static void
-modem_call_service_check_connected(ModemCallService *self,
-  ModemRequest *request,
-  GError const *error)
+modem_call_service_check_connected (ModemCallService *self,
+                                    ModemRequest *request,
+                                    GError const *error)
 {
   ModemCallServicePrivate *priv = self->priv;
 
-  if (g_queue_find(priv->connecting.queue, request)) {
-    g_queue_remove(priv->connecting.queue, request);
-
-    if (error) {
-      if (!priv->connecting.error ||
-        priv->connecting.error->domain == DBUS_GERROR) {
-        g_clear_error(&priv->connecting.error);
-        g_set_error(&priv->connecting.error,
-          error->domain, error->code,
-          "%s", error->message);
-      }
-
-      modem_critical(MODEM_SERVICE_CALL, GERROR_MSG_FMT,
-        GERROR_MSG_CODE(priv->connecting.error));
-    }
-
-    if (g_queue_is_empty(priv->connecting.queue)) {
-      priv->connected = priv->connecting.error == NULL;
-      DEBUG("emit \"connected\"(%s)", priv->connected ? "TRUE" : "FALSE");
-      g_signal_emit(self, signals[SIGNAL_CONNECTED], 0);
+  if (g_queue_find (priv->connecting.queue, request))
+    {
+      g_queue_remove (priv->connecting.queue, request);
+
+      if (error)
+        {
+          if (!priv->connecting.error ||
+              priv->connecting.error->domain == DBUS_GERROR)
+            {
+              g_clear_error (&priv->connecting.error);
+              g_set_error (&priv->connecting.error,
+                  error->domain, error->code,
+                  "%s", error->message);
+            }
+
+          modem_critical (MODEM_SERVICE_CALL, GERROR_MSG_FMT,
+              GERROR_MSG_CODE (priv->connecting.error));
+        }
+
+      if (g_queue_is_empty (priv->connecting.queue))
+        {
+          priv->connected = priv->connecting.error == NULL;
+          DEBUG ("emit \"connected\"(%s)", priv->connected ? "TRUE" : "FALSE");
+          g_signal_emit (self, signals[SIGNAL_CONNECTED], 0);
+        }
     }
-  }
 }
 
 /** Disconnect from call service */
 void
-modem_call_service_disconnect(ModemCallService *self)
+modem_call_service_disconnect (ModemCallService *self)
 {
-  DEBUG("(%p): enter", self);
+  DEBUG ("(%p): enter", self);
 
   ModemCallServicePrivate *priv = self->priv;
   unsigned was_connected = priv->connected;
 
-  g_return_if_fail(!priv->dispose_has_run);
+  g_return_if_fail (!priv->dispose_has_run);
 
   if (priv->disconnected)
     return;
@@ -738,50 +760,53 @@ modem_call_service_disconnect(ModemCallService *self)
   priv->connected = FALSE;
   priv->disconnected = TRUE;
 
-  while (!g_queue_is_empty(priv->connecting.queue)) {
-    ModemRequest *request = g_queue_pop_head(priv->connecting.queue);
-    modem_request_cancel(request);
-  }
+  while (!g_queue_is_empty (priv->connecting.queue))
+    {
+      ModemRequest *request = g_queue_pop_head (priv->connecting.queue);
+      modem_request_cancel (request);
+    }
 
-  while (!g_queue_is_empty(priv->dialing.queue)) {
-    ModemRequest *request = g_queue_pop_head(priv->connecting.queue);
-    modem_request_cancel(request);
-  }
+  while (!g_queue_is_empty (priv->dialing.queue))
+    {
+      ModemRequest *request = g_queue_pop_head (priv->connecting.queue);
+      modem_request_cancel (request);
+    }
 
-  if (priv->signals) {
-    priv->signals = FALSE;
+  if (priv->signals)
+    {
+      priv->signals = FALSE;
 
-    modem_ofono_proxy_disconnect_from_property_changed(
-      priv->proxy, on_manager_property_changed, self);
+      modem_ofono_proxy_disconnect_from_property_changed (
+          priv->proxy, on_manager_property_changed, self);
 
-    dbus_g_proxy_disconnect_signal(priv->proxy, "CallAdded",
-      G_CALLBACK(on_manager_call_added), self);
-  }
+      dbus_g_proxy_disconnect_signal (priv->proxy, "CallAdded",
+          G_CALLBACK (on_manager_call_added), self);
+    }
 
-  g_clear_error(&priv->connecting.error);
+  g_clear_error (&priv->connecting.error);
 
   if (was_connected)
-    g_signal_emit(self, signals[SIGNAL_CONNECTED], 0);
+    g_signal_emit (self, signals[SIGNAL_CONNECTED], 0);
 }
 
 gboolean
-modem_call_service_is_connected(ModemCallService const *self)
+modem_call_service_is_connected (ModemCallService const *self)
 {
-  return MODEM_IS_CALL_SERVICE(self) && self->priv->connected;
+  return MODEM_IS_CALL_SERVICE (self) && self->priv->connected;
 }
 
 gboolean
-modem_call_service_is_connecting(ModemCallService const *self)
+modem_call_service_is_connecting (ModemCallService const *self)
 {
-  return MODEM_IS_CALL_SERVICE(self)
-    && !g_queue_is_empty(self->priv->connecting.queue);
+  return MODEM_IS_CALL_SERVICE (self)
+    && !g_queue_is_empty (self->priv->connecting.queue);
 }
 
 
 void
-modem_call_service_resume(ModemCallService *self)
+modem_call_service_resume (ModemCallService *self)
 {
-  DEBUG("enter");
+  DEBUG ("enter");
 
   GHashTableIter iter[1];
   ModemCall *membercall = NULL;
@@ -793,71 +818,75 @@ modem_call_service_resume(ModemCallService *self)
   if (!self->priv->connected)
     return;
 
-  g_signal_emit(self, signals[SIGNAL_EMERGENCY_NUMBERS_CHANGED], 0,
-    modem_call_get_emergency_numbers(self));
-
-  g_hash_table_iter_init(iter, self->priv->instances);
-  while (g_hash_table_iter_next(iter, NULL, (gpointer)&ci)) {
-    char *remote;
-    gboolean terminating = FALSE, member = FALSE;
-    ModemCallState state;
-
-    g_object_get(ci,
-      "state", &state,
-      "member", &member,
-      "remote", &remote,
-      "terminating", &terminating,
-      NULL);
-
-    if (member)
-      membercall = ci;
-
-    if (state != MODEM_CALL_STATE_DISCONNECTED &&
-      state != MODEM_CALL_STATE_INVALID) {
-
-      /* XXX - atm the value of 'terminating' cannot be trusted.
-       * oFono should probably provide the direction as a property
-       * since we cannot rely on the call state here. */
-      if (terminating) {
-        modem_message(MODEM_SERVICE_CALL,
-          "incoming [with state %s] call from \"%s\"",
-          modem_call_get_state_name(state), remote);
-        DEBUG("emit \"incoming\"(%s (%p), %s)",
-          modem_call_get_name(ci), ci, remote);
-        g_signal_emit(self, signals[SIGNAL_INCOMING], 0, ci, remote);
-      }
-      else {
-        modem_message(MODEM_SERVICE_CALL,
-          "created [with state %s] call to \"%s\"",
-          modem_call_get_state_name(state), remote);
-        DEBUG("emit \"created\"(%s (%p), %s)",
-          modem_call_get_name(ci), ci, remote);
-        g_signal_emit(self, signals[SIGNAL_CREATED], 0, ci, remote);
-      }
-
-      g_signal_emit_by_name(ci, "state", state, 0, 0);
+  g_signal_emit (self, signals[SIGNAL_EMERGENCY_NUMBERS_CHANGED], 0,
+      modem_call_get_emergency_numbers (self));
+
+  g_hash_table_iter_init (iter, self->priv->instances);
+  while (g_hash_table_iter_next (iter, NULL, (gpointer)&ci))
+    {
+      char *remote;
+      gboolean terminating = FALSE, member = FALSE;
+      ModemCallState state;
+
+      g_object_get (ci,
+          "state", &state,
+          "member", &member,
+          "remote", &remote,
+          "terminating", &terminating,
+          NULL);
+
+      if (member)
+        membercall = ci;
+
+      if (state != MODEM_CALL_STATE_DISCONNECTED &&
+          state != MODEM_CALL_STATE_INVALID)
+        {
+
+          /* XXX - atm the value of 'terminating' cannot be trusted.
+           * oFono should probably provide the direction as a property
+           * since we cannot rely on the call state here. */
+          if (terminating)
+            {
+              modem_message (MODEM_SERVICE_CALL,
+                  "incoming [with state %s] call from \"%s\"",
+                  modem_call_get_state_name (state), remote);
+              DEBUG ("emit \"incoming\"(%s (%p), %s)",
+                  modem_call_get_name (ci), ci, remote);
+              g_signal_emit (self, signals[SIGNAL_INCOMING], 0, ci, remote);
+            }
+          else {
+            modem_message (MODEM_SERVICE_CALL,
+                "created [with state %s] call to \"%s\"",
+                modem_call_get_state_name (state), remote);
+            DEBUG ("emit \"created\"(%s (%p), %s)",
+                modem_call_get_name (ci), ci, remote);
+            g_signal_emit (self, signals[SIGNAL_CREATED], 0, ci, remote);
+          }
+
+          g_signal_emit_by_name (ci, "state", state, 0, 0);
+        }
+
+      g_free (remote);
     }
 
-    g_free(remote);
-  }
-
 #if nomore
   mcc = self->priv->conference.conference;
 
-  for (i = 0; i < MODEM_MAX_CALLS; i++) {
-    ModemCall *ci = self->priv->instances[i].instance;
-    gboolean member = FALSE;
+  for (i = 0; i < MODEM_MAX_CALLS; i++)
+    {
+      ModemCall *ci = self->priv->instances[i].instance;
+      gboolean member = FALSE;
 
-    g_object_get(ci, "member", &member, NULL);
+      g_object_get (ci, "member", &member, NULL);
 
-    if (!member)
-      continue;
+      if (!member)
+        continue;
 
-    g_signal_emit_by_name(mcc, "joined", ci);
-  }
+      g_signal_emit_by_name (mcc, "joined", ci);
+    }
 
-  g_signal_emit_by_name(mcc, "state",
-    modem_call_get_state(MODEM_CALL(mcc)), 0, 0);
+  g_signal_emit_by_name (mcc, "state",
+      modem_call_get_state (MODEM_CALL (mcc)), 0, 0);
 #endif
 }
 
@@ -868,52 +897,54 @@ static char const modem_call_sos[] = "urn:service:sos";
 
 /** Get currently cached list of emergency numbers. */
 char const * const *
-modem_call_get_emergency_numbers(ModemCallService *self)
+modem_call_get_emergency_numbers (ModemCallService *self)
 {
   static char const * const default_numbers[] = {
     "112", "911", "118", "119", "000", "110", "08", "999", NULL
   };
 
-  if (MODEM_IS_CALL_SERVICE(self) && self->priv->emergency_numbers) {
-    return (char const * const *)self->priv->emergency_numbers;
-  }
+  if (MODEM_IS_CALL_SERVICE (self) && self->priv->emergency_numbers)
+    {
+      return (char const * const *)self->priv->emergency_numbers;
+    }
 
   return default_numbers;
 }
 
 /** Get emergency service corresponding to number. */
 char const *
-modem_call_get_emergency_service(ModemCallService *self,
-  char const *destination)
+modem_call_get_emergency_service (ModemCallService *self,
+                                  char const *destination)
 {
   char const * const *numbers;
 
   if (destination == NULL)
     return NULL;
 
-  if (modem_call_get_valid_emergency_urn(destination))
-    return modem_call_get_valid_emergency_urn(destination);
+  if (modem_call_get_valid_emergency_urn (destination))
+    return modem_call_get_valid_emergency_urn (destination);
 
-  numbers = modem_call_get_emergency_numbers(self);
+  numbers = modem_call_get_emergency_numbers (self);
 
-  for (; *numbers; numbers++) {
-    size_t n = strlen(*numbers);
+  for (; *numbers; numbers++)
+    {
+      size_t n = strlen (*numbers);
 
-    if (!g_str_has_prefix(destination, *numbers))
-      continue;
+      if (!g_str_has_prefix (destination, *numbers))
+        continue;
 
-    if (destination[n] && destination[n] != 'p' && destination[n] != 'w')
-      continue;
+      if (destination[n] && destination[n] != 'p' && destination[n] != 'w')
+        continue;
 
-    return modem_call_sos;
-  }
+      return modem_call_sos;
+    }
 
   return NULL;
 }
 
 /** Check if @urn is an emergency service. */
 char const *
-modem_call_get_valid_emergency_urn(char const *urn)
+modem_call_get_valid_emergency_urn (char const *urn)
 {
   /* urn:service:sos see RFC 5031
    *
@@ -933,7 +964,7 @@ modem_call_get_valid_emergency_urn(char const *urn)
   if (urn == NULL)
     return NULL;
 
-  if (g_ascii_strncasecmp(urn, modem_call_sos, n))
+  if (g_ascii_strncasecmp (urn, modem_call_sos, n))
     return NULL;
 
   sos = urn + n;
@@ -944,74 +975,80 @@ modem_call_get_valid_emergency_urn(char const *urn)
   if (sos[0] != '.')
     return NULL;                /* Not a sos. subservice */
 
-  for (i = 1, dot = 0, hyp = -2; ; i++) {
-    /* A-Z a-z 0-9 - . */
-    if (sos[i] == '\0') {
-      if (i > hyp + 1 && i > dot + 1)
-        return urn;
-    }
-    if (('a' <= sos[i] && sos[i] <= 'z') ||
-      ('0' <= sos[i] && sos[i] <= '9') ||
-      ('A' <= sos[i] && sos[i] <= 'Z'))
-      continue;
-    else if (sos[i] == '-') {
-      if (i > dot + 1) {
-        hyp = i;
-        continue;
-      }
-    }
-    else if (sos[i] == '.') {
-      if (i > dot + 1 && i > hyp + 1) {
-        dot = i;
+  for (i = 1, dot = 0, hyp = -2; ; i++)
+    {
+      /* A-Z a-z 0-9 - . */
+      if (sos[i] == '\0')
+        {
+          if (i > hyp + 1 && i > dot + 1)
+            return urn;
+        }
+      if (('a' <= sos[i] && sos[i] <= 'z') ||
+          ('0' <= sos[i] && sos[i] <= '9') ||
+          ('A' <= sos[i] && sos[i] <= 'Z'))
         continue;
-      }
+      else if (sos[i] == '-')
+        {
+          if (i > dot + 1)
+            {
+              hyp = i;
+              continue;
+            }
+        }
+      else if (sos[i] == '.')
+        {
+          if (i > dot + 1 && i > hyp + 1)
+            {
+              dot = i;
+              continue;
+            }
+        }
+
+      return modem_call_sos;      /* Invalid syntax */
     }
-
-    return modem_call_sos;      /* Invalid syntax */
-  }
 }
 
 /* ---------------------------------------------------------------------- */
 
 #if nomore
 static void
-on_user_connection(DBusGProxy *proxy,
-  gboolean attached,
-  ModemCallService *self)
+on_user_connection (DBusGProxy *proxy,
+                    gboolean attached,
+                    ModemCallService *self)
 {
-  DEBUG("(%p, %d, %p): enter", proxy, attached, self);
+  DEBUG ("(%p, %d, %p): enter", proxy, attached, self);
 
-  MODEM_CALL_SERVICE(self)->priv->user_connection = attached;
+  MODEM_CALL_SERVICE (self)->priv->user_connection = attached;
 
-  g_signal_emit(self, signals[SIGNAL_USER_CONNECTION], 0,
-    attached);
+  g_signal_emit (self, signals[SIGNAL_USER_CONNECTION], 0,
+      attached);
 }
 #endif
 
-static void request_notify_cancel(gpointer data);
+static void request_notify_cancel (gpointer data);
 
 ModemRequest *
-modem_call_request_dial(ModemCallService *self,
-  char const *destination,
-  ModemClirOverride clir,
-  ModemCallRequestDialReply callback,
-  gpointer user_data)
+modem_call_request_dial (ModemCallService *self,
+                         char const *destination,
+                         ModemClirOverride clir,
+                         ModemCallRequestDialReply callback,
+                         gpointer user_data)
 {
   char const *clir_str;
   ModemRequest *request;
   ModemCallServicePrivate *priv = self->priv;
 
-  RETURN_NULL_IF_NOT_VALID(self);
+  RETURN_NULL_IF_NOT_VALID (self);
 
-  DEBUG("called");
+  DEBUG ("called");
 
-  g_return_val_if_fail(priv->connected, NULL);
-  g_return_val_if_fail(destination != NULL, NULL);
-  g_return_val_if_fail(callback != NULL, NULL);
+  g_return_val_if_fail (priv->connected, NULL);
+  g_return_val_if_fail (destination != NULL, NULL);
+  g_return_val_if_fail (callback != NULL, NULL);
 
-  modem_message(MODEM_SERVICE_CALL,
-    "trying to create call to \"%s\"",
-    destination);
+  modem_message (MODEM_SERVICE_CALL,
+      "trying to create call to \"%s\"",
+      destination);
 
   if (clir == MODEM_CLIR_OVERRIDE_DISABLED)
     clir_str = "disabled";
@@ -1020,135 +1057,140 @@ modem_call_request_dial(ModemCallService *self,
   else
     clir_str = "";
 
-  request = modem_request_begin(self, priv->proxy,
-            "Dial", modem_call_request_dial_reply,
-            G_CALLBACK(callback), user_data,
-            G_TYPE_STRING, destination,
-            G_TYPE_STRING, clir_str,
-            G_TYPE_INVALID);
+  request = modem_request_begin (self, priv->proxy,
+      "Dial", modem_call_request_dial_reply,
+      G_CALLBACK (callback), user_data,
+      G_TYPE_STRING, destination,
+      G_TYPE_STRING, clir_str,
+      G_TYPE_INVALID);
 
 
-  modem_request_add_cancel_notify(request, request_notify_cancel);
+  modem_request_add_cancel_notify (request, request_notify_cancel);
 
-  modem_request_add_data_full(request,
-    "call-destination",
-    g_strdup(destination),
-    g_free);
+  modem_request_add_data_full (request,
+      "call-destination",
+      g_strdup (destination),
+      g_free);
 
-  g_queue_push_tail(priv->dialing.queue, request);
+  g_queue_push_tail (priv->dialing.queue, request);
 
   return request;
 }
 
 static void
-request_notify_cancel(gpointer _request)
+request_notify_cancel (gpointer _request)
 {
-  modem_request_add_qdata(_request,
-    g_quark_from_static_string("call-canceled"),
-    GUINT_TO_POINTER(1));
+  modem_request_add_qdata (_request,
+      g_quark_from_static_string ("call-canceled"),
+      GUINT_TO_POINTER (1));
 }
 
 static void
-modem_call_request_dial_reply(DBusGProxy *proxy,
-  DBusGProxyCall *call,
-  void *_request)
+modem_call_request_dial_reply (DBusGProxy *proxy,
+                               DBusGProxyCall *call,
+                               void *_request)
 {
-  DEBUG("enter");
+  DEBUG ("enter");
 
   ModemRequest *request = _request;
-  ModemCallService *self = MODEM_CALL_SERVICE(modem_request_object(request));
+  ModemCallService *self = MODEM_CALL_SERVICE (modem_request_object (request));
   ModemCallServicePrivate *priv = self->priv;
-  ModemCallRequestDialReply *callback = modem_request_callback(request);
-  gpointer user_data = modem_request_user_data(request);
-  char *destination = modem_request_get_data(request, "call-destination");
+  ModemCallRequestDialReply *callback = modem_request_callback (request);
+  gpointer user_data = modem_request_user_data (request);
+  char *destination = modem_request_get_data (request, "call-destination");
   GError *error = NULL;
   ModemCall *ci = NULL;
   char *object_path = NULL;
 
-  if (dbus_g_proxy_end_call(proxy, call, &error,
-      DBUS_TYPE_G_OBJECT_PATH, &object_path,
-      G_TYPE_INVALID)) {
-    ci = modem_call_service_get_dialed(self, object_path, destination);
-  }
+  if (dbus_g_proxy_end_call (proxy, call, &error,
+          DBUS_TYPE_G_OBJECT_PATH, &object_path,
+          G_TYPE_INVALID))
+    {
+      ci = modem_call_service_get_dialed (self, object_path, destination);
+    }
   else {
     object_path = NULL;
-    modem_error_fix(&error);
+    modem_error_fix (&error);
   }
 
-  if (ci) {
-    DEBUG("%s: instance %s (%p)", OFONO_IFACE_CALL_MANAGER ".Dial",
-      object_path, (void *)ci);
+  if (ci)
+    {
+      DEBUG ("%s: instance %s (%p)", OFONO_IFACE_CALL_MANAGER ".Dial",
+          object_path, (void *)ci);
 
-    modem_message(MODEM_SERVICE_CALL,
-      "call create request to \"%s\" successful",
-      destination);
-  }
+      modem_message (MODEM_SERVICE_CALL,
+          "call create request to \"%s\" successful",
+          destination);
+    }
   else {
     char ebuffer[32];
 
-    modem_message(MODEM_SERVICE_CALL,
-      "call create request to \"%s\" failed: %s.%s: %s",
-      destination,
-      modem_error_domain_prefix(error->domain),
-      modem_error_name(error, ebuffer, sizeof ebuffer),
-      error->message);
+    modem_message (MODEM_SERVICE_CALL,
+        "call create request to \"%s\" failed: %s.%s: %s",
+        destination,
+        modem_error_domain_prefix (error->domain),
+        modem_error_name (error, ebuffer, sizeof ebuffer),
+        error->message);
 
-    DEBUG("%s: " GERROR_MSG_FMT, OFONO_IFACE_CALL_MANAGER ".Dial",
-      GERROR_MSG_CODE(error));
+    DEBUG ("%s: " GERROR_MSG_FMT, OFONO_IFACE_CALL_MANAGER ".Dial",
+        GERROR_MSG_CODE (error));
   }
 
-  if (modem_request_get_data(request, "call-canceled")) {
-    if (ci)
-      modem_call_request_release(ci, NULL, NULL);
-  }
+  if (modem_request_get_data (request, "call-canceled"))
+    {
+      if (ci)
+        modem_call_request_release (ci, NULL, NULL);
+    }
   else {
-    g_assert(ci || error);
-    callback(self, request, ci, error, user_data);
+    g_assert (ci || error);
+    callback (self, request, ci, error, user_data);
   }
 
-  if (g_queue_find(priv->dialing.queue, request))
-    g_queue_remove(priv->dialing.queue, request);
+  if (g_queue_find (priv->dialing.queue, request))
+    g_queue_remove (priv->dialing.queue, request);
 
-  while (g_queue_is_empty(priv->dialing.queue) &&
-      !g_queue_is_empty(priv->dialing.created)) {
-    char *remote;
+  while (g_queue_is_empty (priv->dialing.queue) &&
+      !g_queue_is_empty (priv->dialing.created))
+    {
+      char *remote;
 
-    ci = g_queue_pop_head(priv->dialing.created);
+      ci = g_queue_pop_head (priv->dialing.created);
 
-    g_object_get(ci, "remote", &remote, NULL);
+      g_object_get (ci, "remote", &remote, NULL);
 
-    g_signal_emit(self, signals[SIGNAL_CREATED], 0, ci, remote);
+      g_signal_emit (self, signals[SIGNAL_CREATED], 0, ci, remote);
 
-    g_free(remote);
-  }
+      g_free (remote);
+    }
 
-  g_free(object_path);
-  g_clear_error(&error);
+  g_free (object_path);
+  g_clear_error (&error);
 }
 
 static void
-on_modem_call_state(ModemCall *ci,
-  ModemCallState state,
-  ModemCallService *self)
+on_modem_call_state (ModemCall *ci,
+                     ModemCallState state,
+                     ModemCallService *self)
 {
-  ModemCallServicePrivate *priv = MODEM_CALL_SERVICE(self)->priv;
+  ModemCallServicePrivate *priv = MODEM_CALL_SERVICE (self)->priv;
   gboolean releasing = FALSE;
 
   if (priv->disconnected)
     return;
 
-  switch (state) {
+  switch (state)
+    {
     case MODEM_CALL_STATE_ACTIVE:
       if (priv->hold == ci)
         priv->hold = NULL;
-      if (!modem_call_is_member(ci))
+      if (!modem_call_is_member (ci))
         priv->active = ci;
       break;
 
     case MODEM_CALL_STATE_HELD:
       if (priv->active == ci)
         priv->active = NULL;
-      if (!modem_call_is_member(ci))
+      if (!modem_call_is_member (ci))
         priv->hold = ci;
       break;
 
@@ -1164,125 +1206,130 @@ on_modem_call_state(ModemCall *ci,
 
     default:
       break;
-  }
+    }
 
 #if nomore
-  if (releasing) {
-    GError *error = modem_call_new_error(causetype, cause, NULL);
-    gboolean originating;
-    char *remote;
-    char const *what;
-
-    g_object_get(ci,
-      "originating", &originating,
-      "remote", &remote,
-      NULL);
-
-    switch (state) {
-      case MODEM_CALL_STATE_MO_RELEASE:
-        what = "mo-released";
-        break;
-      case MODEM_CALL_STATE_MT_RELEASE:
-        what = "mt-released";
-        break;
-      default:
-        what = "terminated";
+  if (releasing)
+    {
+      GError *error = modem_call_new_error (causetype, cause, NULL);
+      gboolean originating;
+      char *remote;
+      char const *what;
+
+      g_object_get (ci,
+          "originating", &originating,
+          "remote", &remote,
+          NULL);
+
+      switch (state)
+        {
+        case MODEM_CALL_STATE_MO_RELEASE:
+          what = "mo-released";
+          break;
+        case MODEM_CALL_STATE_MT_RELEASE:
+          what = "mt-released";
+          break;
+        default:
+          what = "terminated";
+        }
+
+      gboolean mpty = MODEM_IS_CALL_CONFERENCE (ci);
+
+      modem_message (MODEM_SERVICE_CALL,
+          "%s %s %s%s%s %s.%s: %s",
+          what,
+          mpty ? "conference"
+          : originating ? "outgoing call to"
+          : "incoming call from",
+          mpty ? "" : "'",
+          mpty ? "call" : remote,
+          mpty ? "" : "'",
+          modem_error_domain_prefix (error->domain),
+          modem_error_name (error, NULL, 0),
+          error->message);
+
+      g_free (remote);
+      g_error_free (error);
     }
-
-    gboolean mpty = MODEM_IS_CALL_CONFERENCE(ci);
-
-    modem_message(MODEM_SERVICE_CALL,
-      "%s %s %s%s%s %s.%s: %s",
-      what,
-      mpty ? "conference"
-      : originating ? "outgoing call to"
-      : "incoming call from",
-      mpty ? "" : "'",
-      mpty ? "call" : remote,
-      mpty ? "" : "'",
-      modem_error_domain_prefix(error->domain),
-      modem_error_name(error, NULL, 0),
-      error->message);
-
-    g_free(remote);
-    g_error_free(error);
-  }
 #endif
 }
 
 static void
-on_modem_call_terminated(ModemCall *ci,
-  ModemCallService *self)
+on_modem_call_terminated (ModemCall *ci,
+                          ModemCallService *self)
 {
   char const *path;
   ModemCallServicePrivate *priv = self->priv;
 
-  path = modem_call_get_path(ci);
+  path = modem_call_get_path (ci);
   if (path)
     g_hash_table_remove (priv->instances, path);
 }
 
 ModemRequest *
-modem_call_request_conference(ModemCallService *self,
-  ModemCallServiceReply *callback,
-  gpointer user_data)
+modem_call_request_conference (ModemCallService *self,
+                               ModemCallServiceReply *callback,
+                               gpointer user_data)
 {
-  RETURN_NULL_IF_NOT_VALID(self);
+  RETURN_NULL_IF_NOT_VALID (self);
 
-  return modem_request(MODEM_CALL_SERVICE(self), self->priv->proxy,
-    "CreateMultiparty",
-    modem_call_conference_request_reply,
-    G_CALLBACK(callback), user_data,
-    G_TYPE_INVALID);
+  return modem_request (MODEM_CALL_SERVICE (self), self->priv->proxy,
+      "CreateMultiparty",
+      modem_call_conference_request_reply,
+      G_CALLBACK (callback), user_data,
+      G_TYPE_INVALID);
 }
 
 static void
-modem_call_conference_request_reply(DBusGProxy *proxy,
-  DBusGProxyCall *call,
-  void *_request)
+modem_call_conference_request_reply (DBusGProxy *proxy,
+                                     DBusGProxyCall *call,
+                                     void *_request)
 {
-  DEBUG("enter");
+  DEBUG ("enter");
 
   GPtrArray *paths;
   ModemRequest *request = _request;
-  ModemCallService *self = modem_request_object(request);
-  ModemCallServiceReply *callback = modem_request_callback(request);
-  gpointer user_data = modem_request_user_data(request);
+  ModemCallService *self = modem_request_object (request);
+  ModemCallServiceReply *callback = modem_request_callback (request);
+  gpointer user_data = modem_request_user_data (request);
   GError *error = NULL;
 
-  if (dbus_g_proxy_end_call(proxy, call, &error,
-      MODEM_TYPE_ARRAY_OF_PATHS, &paths,
-      G_TYPE_INVALID)) {
-
-    guint i;
-    char const *path;
-    ModemCall *ci;
-
-    for (i = 0; i < paths->len; i++) {
-      path = g_ptr_array_index(paths, i);
-      ci = g_hash_table_lookup(self->priv->instances, path);
-      if (ci != NULL) {
-        g_object_set(ci, "member", TRUE, NULL);
-      }
+  if (dbus_g_proxy_end_call (proxy, call, &error,
+          MODEM_TYPE_ARRAY_OF_PATHS, &paths,
+          G_TYPE_INVALID))
+    {
+
+      guint i;
+      char const *path;
+      ModemCall *ci;
+
+      for (i = 0; i < paths->len; i++)
+        {
+          path = g_ptr_array_index (paths, i);
+          ci = g_hash_table_lookup (self->priv->instances, path);
+          if (ci != NULL)
+            {
+              g_object_set (ci, "member", TRUE, NULL);
+            }
+        }
+
+      g_boxed_free (MODEM_TYPE_ARRAY_OF_PATHS, paths);
     }
-
-    g_boxed_free(MODEM_TYPE_ARRAY_OF_PATHS, paths);
-  }
   else {
-    modem_error_fix(&error);
+    modem_error_fix (&error);
   }
 
-  callback(self, request, error, user_data);
-  g_clear_error(&error);
+  callback (self, request, error, user_data);
+  g_clear_error (&error);
 }
 
 
 ModemCall *
-modem_call_service_get_call(ModemCallService *self, char const *object_path)
+modem_call_service_get_call (ModemCallService *self, char const *object_path)
 {
   ModemCallServicePrivate *priv = self->priv;
 
-  return g_hash_table_lookup(priv->instances, object_path);
+  return g_hash_table_lookup (priv->instances, object_path);
 }
 
 /**
@@ -1292,33 +1339,34 @@ modem_call_service_get_call(ModemCallService *self, char const *object_path)
  * Obtains NULL-terminated list of ordinary ModemCall objects. Note that the
  * reference count of ModemCall objects is not incremented and object
  * pointers are valid only during the lifetime of the ModemCallService object.
- * The returned list can be reclaimed with g_free().
+ * The returned list can be reclaimed with g_free ().
  *
  * Returns: NULL-terminated list of pointers to ModemCall objects.
  */
 ModemCall **
-modem_call_service_get_calls(ModemCallService *self)
+modem_call_service_get_calls (ModemCallService *self)
 {
   ModemCall *ci;
   GPtrArray *calls;
   GHashTableIter iter[1];
 
-  calls = g_ptr_array_sized_new(MODEM_MAX_CALLS + 1);
+  calls = g_ptr_array_sized_new (MODEM_MAX_CALLS + 1);
 
-  g_hash_table_iter_init(iter, self->priv->instances);
-  while (g_hash_table_iter_next(iter, NULL, (gpointer)&ci)) {
-    g_ptr_array_add(calls, ci);
-  }
+  g_hash_table_iter_init (iter, self->priv->instances);
+  while (g_hash_table_iter_next (iter, NULL, (gpointer)&ci))
+    {
+      g_ptr_array_add (calls, ci);
+    }
 
-  g_ptr_array_add(calls, NULL);
+  g_ptr_array_add (calls, NULL);
 
-  return (ModemCall **)g_ptr_array_free(calls, FALSE);
+  return (ModemCall **)g_ptr_array_free (calls, FALSE);
 }
 
 ModemCallConference *
-modem_call_service_get_conference(ModemCallService *self)
+modem_call_service_get_conference (ModemCallService *self)
 {
-  return MODEM_IS_CALL_SERVICE(self)
+  return MODEM_IS_CALL_SERVICE (self)
     ? self->priv->conference.conference
     : NULL;
 }
@@ -1326,7 +1374,7 @@ modem_call_service_get_conference(ModemCallService *self)
 /* ------------------------------------------------------------------------- */
 
 static char const *
-_modem_call_validate_address(char const *address)
+_modem_call_validate_address (char const *address)
 {
   size_t n, m;
 
@@ -1335,28 +1383,30 @@ _modem_call_validate_address(char const *address)
 
   n = (sizeof modem_call_sos) - 1;
 
-  if (g_ascii_strncasecmp(address, modem_call_sos, n) == 0) {
-    if (address[n] != '\0' && address[n] != '.')
-      return "invalid service urn";
-    return NULL;
-  }
+  if (g_ascii_strncasecmp (address, modem_call_sos, n) == 0)
+    {
+      if (address[n] != '\0' && address[n] != '.')
+        return "invalid service urn";
+      return NULL;
+    }
 
   /* Remove regocnized service prefixes */
-  if (g_str_has_prefix(address, "*31#"))
+  if (g_str_has_prefix (address, "*31#"))
     address += 4;
-  else if (g_str_has_prefix(address, "#31#"))
+  else if (g_str_has_prefix (address, "#31#"))
     address += 4;
 
   if (*address == '+')
     address++;
 
-  n = strspn(address, "0123456789abc*#");
-  if (n == 0) {
-    if (address[n])
-      return "not a phone number";
-    else
-      return "too short";
-  }
+  n = strspn (address, "0123456789abc*#");
+  if (n == 0)
+    {
+      if (address[n])
+        return "not a phone number";
+      else
+        return "too short";
+    }
   if (n > 20)
     return "too long";
 
@@ -1364,13 +1414,14 @@ _modem_call_validate_address(char const *address)
     return "invalid service code";
 
   /* Possible dialstring */
-  m = strspn(address + n, "0123456789abc*#pwPW");
-  if (address[n + m] != '\0') {
-    if (m == 0)
-      return "invalid address";
-    else
-      return "invalid dial string";
-  }
+  m = strspn (address + n, "0123456789abc*#pwPW");
+  if (address[n + m] != '\0')
+    {
+      if (m == 0)
+        return "invalid address";
+      else
+        return "invalid dial string";
+    }
 
   if (m == 1)
     return "invalid dial string";
@@ -1380,62 +1431,66 @@ _modem_call_validate_address(char const *address)
 }
 
 gboolean
-modem_call_is_valid_address(char const *address)
+modem_call_is_valid_address (char const *address)
 {
-  return _modem_call_validate_address(address) == NULL;
+  return _modem_call_validate_address (address) == NULL;
 }
 
 gboolean
-modem_call_validate_address(char const *address, GError **error)
+modem_call_validate_address (char const *address, GError **error)
 {
-  char const *message = _modem_call_validate_address(address);
+  char const *message = _modem_call_validate_address (address);
 
-  if (message) {
-    g_set_error_literal(error,
-      MODEM_CALL_ERRORS, MODEM_CALL_ERROR_INVALID_ADDRESS, message);
-    return FALSE;
-  }
+  if (message)
+    {
+      g_set_error_literal (error,
+          MODEM_CALL_ERRORS, MODEM_CALL_ERROR_INVALID_ADDRESS, message);
+      return FALSE;
+    }
 
   return TRUE;
 }
 
 void
-modem_call_split_address(char const *address,
-  char **return_address,
-  char **return_dialstring,
-  ModemClirOverride *return_clir)
+modem_call_split_address (char const *address,
+                          char **return_address,
+                          char **return_dialstring,
+                          ModemClirOverride *return_clir)
 {
   char const *emergency;
   size_t nan;
 
-  g_return_if_fail(address != NULL);
-  g_return_if_fail(return_address != NULL);
-  g_return_if_fail(return_dialstring != NULL);
-  g_return_if_fail(return_clir);
-
-  emergency = modem_call_get_valid_emergency_urn(address);
-  if (emergency) {
-    *return_address = g_strdup(emergency);
-    *return_dialstring = NULL;
-    *return_clir = MODEM_CLIR_OVERRIDE_DEFAULT;
-    return;
-  }
+  g_return_if_fail (address != NULL);
+  g_return_if_fail (return_address != NULL);
+  g_return_if_fail (return_dialstring != NULL);
+  g_return_if_fail (return_clir);
+
+  emergency = modem_call_get_valid_emergency_urn (address);
+  if (emergency)
+    {
+      *return_address = g_strdup (emergency);
+      *return_dialstring = NULL;
+      *return_clir = MODEM_CLIR_OVERRIDE_DEFAULT;
+      return;
+    }
 
-  if (g_str_has_prefix(address, "*31#")) {
-    address += strlen("*31#");
-    /* According to 3GPP 22.030, *31# suppresses CLIR */
-    *return_clir = MODEM_CLIR_OVERRIDE_DISABLED;
-  }
+  if (g_str_has_prefix (address, "*31#"))
+    {
+      address += strlen ("*31#");
+      /* According to 3GPP 22.030, *31# suppresses CLIR */
+      *return_clir = MODEM_CLIR_OVERRIDE_DISABLED;
+    }
 
-  if (g_str_has_prefix(address, "#31#")) {
-    /* According to 3GPP 22.030, #31# invokes CLIR */
-    address += strlen("#31#");
-    *return_clir = MODEM_CLIR_OVERRIDE_ENABLED;
-  }
+  if (g_str_has_prefix (address, "#31#"))
+    {
+      /* According to 3GPP 22.030, #31# invokes CLIR */
+      address += strlen ("#31#");
+      *return_clir = MODEM_CLIR_OVERRIDE_ENABLED;
+    }
 
-  nan = strspn(address, "+0123456789*#ABCabc");
+  nan = strspn (address, "+0123456789*#ABCabc");
 
-  *return_address = g_strndup(address, nan);
+  *return_address = g_strndup (address, nan);
   if (address[nan])
-    *return_dialstring = g_strdup(address + nan);
+    *return_dialstring = g_strdup (address + nan);
 }
diff --git a/modem/call.c b/modem/call.c
index 61deb48..75db1dd 100644
--- a/modem/call.c
+++ b/modem/call.c
@@ -40,7 +40,7 @@
 #include <stdio.h>
 #include <errno.h>
 
-G_DEFINE_TYPE(ModemCall, modem_call, G_TYPE_OBJECT);
+G_DEFINE_TYPE (ModemCall, modem_call, G_TYPE_OBJECT);
 
 struct _ModemCallPrivate
 {
@@ -79,7 +79,8 @@ enum
 };
 
 /* Signals */
-enum {
+enum
+{
   SIGNAL_STATE,
   SIGNAL_WAITING,
   SIGNAL_MULTIPARTY,
@@ -96,231 +97,234 @@ static guint call_signals[N_SIGNALS];
 
 /* ---------------------------------------------------------------------- */
 
-extern DBusGProxy *_modem_call_service_proxy(ModemCallService *self);
+extern DBusGProxy *_modem_call_service_proxy (ModemCallService *self);
 
 static void
-reply_to_instance_request(DBusGProxy *proxy,
-  DBusGProxyCall *call,
-  void *_request);
+reply_to_instance_request (DBusGProxy *proxy,
+                           DBusGProxyCall *call,
+                           void *_request);
 
 #if nomore /* Ofono does not provide this information */
-static void on_on_hold(DBusGProxy *, gboolean onhold, ModemCall*);
-static void on_forwarded(DBusGProxy *, ModemCall *);
-static void on_waiting(DBusGProxy *proxy, ModemCall *);
-static void on_multiparty(DBusGProxy *, ModemCall *);
-static void on_emergency(DBusGProxy *proxy,
-  char const *service, ModemCall *);
-
-static void on_sending_dtmf(DBusGProxy *proxy,
-  char const *dialstring, ModemCall *);
-static void on_stopped_dtmf(DBusGProxy *proxy, ModemCall *);
+static void on_on_hold (DBusGProxy *, gboolean onhold, ModemCall*);
+static void on_forwarded (DBusGProxy *, ModemCall *);
+static void on_waiting (DBusGProxy *proxy, ModemCall *);
+static void on_multiparty (DBusGProxy *, ModemCall *);
+static void on_emergency (DBusGProxy *proxy,
+    char const *service, ModemCall *);
+
+static void on_sending_dtmf (DBusGProxy *proxy,
+    char const *dialstring, ModemCall *);
+static void on_stopped_dtmf (DBusGProxy *proxy, ModemCall *);
 #endif
 
-static void reply_to_stop_dtmf(DBusGProxy *proxy,
-  DBusGProxyCall *call,
-  void *_request);
+static void reply_to_stop_dtmf (DBusGProxy *proxy,
+    DBusGProxyCall *call,
+    void *_request);
 
-static void on_call_property_changed(DBusGProxy *proxy,
-  char const *property,
-  GValue const *value,
-  gpointer user_data);
+static void on_call_property_changed (DBusGProxy *proxy,
+    char const *property,
+    GValue const *value,
+    gpointer user_data);
 
 /* ---------------------------------------------------------------------- */
 
 static void
-modem_call_init(ModemCall *self)
+modem_call_init (ModemCall *self)
 {
-  self->priv = G_TYPE_INSTANCE_GET_PRIVATE(
-    self, MODEM_TYPE_CALL, ModemCallPrivate);
+  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, MODEM_TYPE_CALL,
+      ModemCallPrivate);
 }
 
 static void
-modem_call_constructed(GObject *object)
+modem_call_constructed (GObject *object)
 {
-  ModemCall *self = MODEM_CALL(object);
+  ModemCall *self = MODEM_CALL (object);
   ModemCallPrivate *priv = self->priv;
 
-  if (G_OBJECT_CLASS(modem_call_parent_class)->constructed)
-    G_OBJECT_CLASS(modem_call_parent_class)->constructed(object);
+  if (G_OBJECT_CLASS (modem_call_parent_class)->constructed)
+    G_OBJECT_CLASS (modem_call_parent_class)->constructed (object);
 
-  priv->proxy = modem_ofono_proxy(priv->object_path, OFONO_IFACE_CALL);
+  priv->proxy = modem_ofono_proxy (priv->object_path, OFONO_IFACE_CALL);
 
-  modem_ofono_proxy_connect_to_property_changed(
-    priv->proxy, on_call_property_changed, self);
+  modem_ofono_proxy_connect_to_property_changed (priv->proxy,
+      on_call_property_changed, self);
 
-  DEBUG("ModemCall for %s on %s",
-    self->priv->object_path, OFONO_IFACE_CALL);
+  DEBUG ("ModemCall for %s on %s",
+      self->priv->object_path, OFONO_IFACE_CALL);
 }
 
 static void
-modem_call_dispose(GObject *object)
+modem_call_dispose (GObject *object)
 {
-  ModemCall *self = MODEM_CALL(object);
+  ModemCall *self = MODEM_CALL (object);
   ModemCallPrivate *priv = self->priv;
 
   if (priv->dispose_has_run)
     return;
   priv->dispose_has_run = TRUE;
 
-  modem_ofono_proxy_disconnect_from_property_changed
-    (priv->proxy, on_call_property_changed, self);
+  modem_ofono_proxy_disconnect_from_property_changed (priv->proxy,
+      on_call_property_changed, self);
 
-  g_object_run_dispose(G_OBJECT(priv->proxy));
+  g_object_run_dispose (G_OBJECT (priv->proxy));
 
-  if (G_OBJECT_CLASS(modem_call_parent_class)->dispose)
-    G_OBJECT_CLASS(modem_call_parent_class)->dispose(object);
+  if (G_OBJECT_CLASS (modem_call_parent_class)->dispose)
+    G_OBJECT_CLASS (modem_call_parent_class)->dispose (object);
 }
 
 static void
-modem_call_finalize(GObject *object)
+modem_call_finalize (GObject *object)
 {
-  ModemCall *self = MODEM_CALL(object);
+  ModemCall *self = MODEM_CALL (object);
   ModemCallPrivate *priv = self->priv;
 
-  g_free(priv->object_path), priv->object_path = NULL;
+  g_free (priv->object_path), priv->object_path = NULL;
   priv->service = NULL;
-  if (priv->proxy) g_object_unref(priv->proxy), priv->proxy = NULL;
-  g_free(priv->remote), priv->remote = NULL;
-  g_free(priv->emergency), priv->emergency = NULL;
+  if (priv->proxy)
+    g_object_unref (priv->proxy), priv->proxy = NULL;
+  g_free (priv->remote), priv->remote = NULL;
+  g_free (priv->emergency), priv->emergency = NULL;
 
-  G_OBJECT_CLASS(modem_call_parent_class)->finalize(object);
+  G_OBJECT_CLASS (modem_call_parent_class)->finalize (object);
 }
 
 static void
-modem_call_get_property(GObject *object,
-  guint property_id,
-  GValue *value,
-  GParamSpec *pspec)
+modem_call_get_property (GObject *object,
+                         guint property_id,
+                         GValue *value,
+                         GParamSpec *pspec)
 {
-  ModemCall *self = MODEM_CALL(object);
+  ModemCall *self = MODEM_CALL (object);
   ModemCallPrivate *priv = self->priv;
 
-  switch(property_id) {
+  switch (property_id)
+    {
     case PROP_OBJECT_PATH:
-      g_value_set_string(value, priv->object_path);
+      g_value_set_string (value, priv->object_path);
       break;
 
     case PROP_SERVICE:
-      g_value_set_object(value, priv->service);
+      g_value_set_object (value, priv->service);
       break;
 
     case PROP_STATE:
-      g_value_set_uint(value, priv->state);
+      g_value_set_uint (value, priv->state);
       break;
 
     case PROP_CAUSE:
-      g_value_set_uint(value, priv->cause);
+      g_value_set_uint (value, priv->cause);
       break;
 
     case PROP_CAUSETYPE:
-      g_value_set_uint(value, priv->causetype);
+      g_value_set_uint (value, priv->causetype);
       break;
 
     case PROP_ORIGINATING:
-      g_value_set_boolean(value, priv->originating);
+      g_value_set_boolean (value, priv->originating);
       break;
 
     case PROP_TERMINATING:
-      g_value_set_boolean(value, priv->terminating);
+      g_value_set_boolean (value, priv->terminating);
       break;
 
     case PROP_EMERGENCY:
-      g_value_set_string(value, priv->emergency);
+      g_value_set_string (value, priv->emergency);
       break;
 
     case PROP_ONHOLD:
-      g_value_set_boolean(value, priv->onhold);
+      g_value_set_boolean (value, priv->onhold);
       break;
 
     case PROP_MEMBER:
-      g_value_set_boolean(value, priv->member);
+      g_value_set_boolean (value, priv->member);
       break;
 
     case PROP_REMOTE:
-      g_value_set_string(value, priv->remote);
+      g_value_set_string (value, priv->remote);
       break;
 
     default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
       break;
-  }
+    }
 }
 
 static void
-modem_call_set_property(GObject *obj,
-  guint property_id,
-  const GValue *value,
-  GParamSpec *pspec)
+modem_call_set_property (GObject *obj,
+                         guint property_id,
+                         const GValue *value,
+                         GParamSpec *pspec)
 {
-  ModemCall *self = MODEM_CALL(obj);
+  ModemCall *self = MODEM_CALL (obj);
   ModemCallPrivate *priv = self->priv;
   char *tbf;
 
-  switch (property_id) {
+  switch (property_id)
+    {
     case PROP_OBJECT_PATH:
-      priv->object_path = g_value_dup_string(value);
+      priv->object_path = g_value_dup_string (value);
       break;
 
     case PROP_SERVICE:
-      priv->service = g_value_get_object(value);
+      priv->service = g_value_get_object (value);
       break;
 
     case PROP_STATE:
-      priv->state = g_value_get_uint(value);
+      priv->state = g_value_get_uint (value);
       break;
 
     case PROP_CAUSE:
-      priv->cause = g_value_get_uint(value);
+      priv->cause = g_value_get_uint (value);
       break;
 
     case PROP_CAUSETYPE:
-      priv->causetype = g_value_get_uint(value);
+      priv->causetype = g_value_get_uint (value);
       break;
 
     case PROP_ORIGINATING:
-      priv->originating = g_value_get_boolean(value);
+      priv->originating = g_value_get_boolean (value);
       if (priv->originating)
         priv->terminating = FALSE;
       break;
 
     case PROP_TERMINATING:
-      priv->terminating = g_value_get_boolean(value);
+      priv->terminating = g_value_get_boolean (value);
       if (priv->terminating)
         priv->originating = FALSE;
       break;
 
     case PROP_EMERGENCY:
       tbf = priv->emergency;
-      priv->emergency = g_value_dup_string(value);
-      g_free(tbf);
+      priv->emergency = g_value_dup_string (value);
+      g_free (tbf);
       break;
 
     case PROP_ONHOLD:
-      priv->onhold = g_value_get_boolean(value);
+      priv->onhold = g_value_get_boolean (value);
       break;
 
     case PROP_MEMBER:
-      priv->member = g_value_get_boolean(value);
+      priv->member = g_value_get_boolean (value);
       break;
 
     case PROP_REMOTE:
       tbf = priv->remote;
-      priv->remote = g_value_dup_string(value);
-      g_free(tbf);
+      priv->remote = g_value_dup_string (value);
+      g_free (tbf);
       break;
 
     default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, property_id, pspec);
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec);
       break;
-  }
+    }
 }
 
 static void
-modem_call_class_init(ModemCallClass *klass)
+modem_call_class_init (ModemCallClass *klass)
 {
-  GObjectClass *object_class = G_OBJECT_CLASS(klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-  g_type_class_add_private(klass, sizeof (ModemCallPrivate));
+  g_type_class_add_private (klass, sizeof (ModemCallPrivate));
 
   object_class->constructed = modem_call_constructed;
   object_class->dispose = modem_call_dispose;
@@ -329,206 +333,185 @@ modem_call_class_init(ModemCallClass *klass)
   object_class->set_property = modem_call_set_property;
 
   /* Properties */
-  g_object_class_install_property(
-    object_class, PROP_OBJECT_PATH,
-    g_param_spec_string("object-path",
-      "Object Path",
-      "Unique identifier for this object",
-      "", /* default value */
-      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
-      G_PARAM_STATIC_STRINGS));
-
-  g_object_class_install_property(
-    object_class, PROP_SERVICE,
-    g_param_spec_object("call-service",
-      "Call service",
-      "The call service object that owns "
-      "the modem call object",
-      MODEM_TYPE_CALL_SERVICE,
-      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
-      G_PARAM_STATIC_STRINGS));
-
-  g_object_class_install_property(
-    object_class, PROP_STATE,
-    g_param_spec_uint("state",
-      "Call state",
-      "State of the call instance",
-      MODEM_CALL_STATE_INVALID,
-      MODEM_CALL_STATE_DISCONNECTED,
-      MODEM_CALL_STATE_INVALID,
-      G_PARAM_READWRITE |
-      G_PARAM_STATIC_STRINGS));
-
-  g_object_class_install_property(
-    object_class, PROP_CAUSE,
-    g_param_spec_uint("cause",
-      "Call cause",
-      "Cause of the latest state transition",
-      0, 255, 0,
-      G_PARAM_READWRITE |
-      G_PARAM_STATIC_STRINGS));
-
-  g_object_class_install_property(
-    object_class, PROP_CAUSETYPE,
-    g_param_spec_uint("causetype",
-      "Call cause type",
-      "Source of the latest state transition",
-      0, MODEM_CALL_CAUSE_TYPE_UNKNOWN, 0,
-      G_PARAM_READWRITE |
-      G_PARAM_STATIC_STRINGS));
-
-  g_object_class_install_property(
-    object_class, PROP_ORIGINATING,
-    g_param_spec_boolean("originating",
-      "Originated Call",
-      "Terminal is originating this call",
-      FALSE,
-      G_PARAM_READWRITE |
-      G_PARAM_STATIC_STRINGS));
-
-  g_object_class_install_property(
-    object_class, PROP_TERMINATING,
-    g_param_spec_boolean("terminating",
-      "Terminating Call",
-      "Terminal is terminating this call",
-      FALSE,
-      G_PARAM_READWRITE |
-      G_PARAM_STATIC_STRINGS));
-
-  g_object_class_install_property(
-    object_class, PROP_EMERGENCY,
-    g_param_spec_string("emergency",
-      "Emergency Service",
-      "Emergency Service for this call",
-      NULL,
-      G_PARAM_READWRITE |
-      G_PARAM_STATIC_STRINGS));
-
-  g_object_class_install_property(
-    object_class, PROP_ONHOLD,
-    g_param_spec_boolean("onhold",
-      "Call is On Hold",
-      "This call has been put on hold by remote party",
-      FALSE,
-      G_PARAM_READWRITE |
-      G_PARAM_STATIC_STRINGS));
-
-  g_object_class_install_property(
-    object_class, PROP_MEMBER,
-    g_param_spec_boolean("member",
-      "Conference Member",
-      "This instance is a member of a conference call",
-      FALSE,
-      G_PARAM_READWRITE |
-      G_PARAM_STATIC_STRINGS));
-
-
-  g_object_class_install_property(
-    object_class, PROP_REMOTE,
-    g_param_spec_string("remote",
-      "Remote Party Address",
-      "Address of remote party associated with this call",
-      NULL,
-      G_PARAM_READWRITE |
-      G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (object_class, PROP_OBJECT_PATH,
+      g_param_spec_string ("object-path",
+          "Object Path",
+          "Unique identifier for this object",
+          "", /* default value */
+          G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
+          G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (object_class, PROP_SERVICE,
+      g_param_spec_object ("call-service",
+          "Call service",
+          "The call service object that owns "
+          "the modem call object",
+          MODEM_TYPE_CALL_SERVICE,
+          G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
+          G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (object_class, PROP_STATE,
+      g_param_spec_uint ("state",
+          "Call state",
+          "State of the call instance",
+          MODEM_CALL_STATE_INVALID,
+          MODEM_CALL_STATE_DISCONNECTED,
+          MODEM_CALL_STATE_INVALID,
+          G_PARAM_READWRITE |
+          G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (object_class, PROP_CAUSE,
+      g_param_spec_uint ("cause",
+          "Call cause",
+          "Cause of the latest state transition",
+          0, 255, 0,
+          G_PARAM_READWRITE |
+          G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (object_class, PROP_CAUSETYPE,
+      g_param_spec_uint ("causetype",
+          "Call cause type",
+          "Source of the latest state transition",
+          0, MODEM_CALL_CAUSE_TYPE_UNKNOWN, 0,
+          G_PARAM_READWRITE |
+          G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (object_class, PROP_ORIGINATING,
+      g_param_spec_boolean ("originating",
+          "Originated Call",
+          "Terminal is originating this call",
+          FALSE,
+          G_PARAM_READWRITE |
+          G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (object_class, PROP_TERMINATING,
+      g_param_spec_boolean ("terminating",
+          "Terminating Call",
+          "Terminal is terminating this call",
+          FALSE,
+          G_PARAM_READWRITE |
+          G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (object_class, PROP_EMERGENCY,
+      g_param_spec_string ("emergency",
+          "Emergency Service",
+          "Emergency Service for this call",
+          NULL,
+          G_PARAM_READWRITE |
+          G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (object_class, PROP_ONHOLD,
+      g_param_spec_boolean ("onhold",
+          "Call is On Hold",
+          "This call has been put on hold by remote party",
+          FALSE,
+          G_PARAM_READWRITE |
+          G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (object_class, PROP_MEMBER,
+      g_param_spec_boolean ("member",
+          "Conference Member",
+          "This instance is a member of a conference call",
+          FALSE,
+          G_PARAM_READWRITE |
+          G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (object_class, PROP_REMOTE,
+      g_param_spec_string ("remote",
+          "Remote Party Address",
+          "Address of remote party associated with this call",
+          NULL,
+          G_PARAM_READWRITE |
+          G_PARAM_STATIC_STRINGS));
 
   call_signals[SIGNAL_STATE] =
-    g_signal_new("state",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      g_cclosure_marshal_VOID__UINT,
-      G_TYPE_NONE, 1,
-      G_TYPE_UINT);
+    g_signal_new ("state", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        g_cclosure_marshal_VOID__UINT,
+        G_TYPE_NONE, 1,
+        G_TYPE_UINT);
 
   call_signals[SIGNAL_WAITING] =
-    g_signal_new("waiting",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      g_cclosure_marshal_VOID__VOID,
-      G_TYPE_NONE, 0);
+    g_signal_new ("waiting", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        g_cclosure_marshal_VOID__VOID,
+        G_TYPE_NONE, 0);
 
   call_signals[SIGNAL_MULTIPARTY] =
-    g_signal_new("multiparty",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      g_cclosure_marshal_VOID__VOID,
-      G_TYPE_NONE, 0);
+    g_signal_new ("multiparty", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        g_cclosure_marshal_VOID__VOID,
+        G_TYPE_NONE, 0);
 
   call_signals[SIGNAL_EMERGENCY] =
-    g_signal_new("emergency",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      g_cclosure_marshal_VOID__STRING,
-      G_TYPE_NONE, 1,
-      G_TYPE_STRING);
+    g_signal_new ("emergency", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        g_cclosure_marshal_VOID__STRING,
+        G_TYPE_NONE, 1,
+        G_TYPE_STRING);
 
   call_signals[SIGNAL_TERMINATED] =
-    g_signal_new("terminated",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      g_cclosure_marshal_VOID__VOID,
-      G_TYPE_NONE, 0);
+    g_signal_new ("terminated", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        g_cclosure_marshal_VOID__VOID,
+        G_TYPE_NONE, 0);
 
   call_signals[SIGNAL_ON_HOLD] =
-    g_signal_new("on-hold",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      g_cclosure_marshal_VOID__BOOLEAN,
-      G_TYPE_NONE, 1,
-      G_TYPE_BOOLEAN);
+    g_signal_new ("on-hold", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        g_cclosure_marshal_VOID__BOOLEAN,
+        G_TYPE_NONE, 1,
+        G_TYPE_BOOLEAN);
 
   call_signals[SIGNAL_FORWARDED] =
-    g_signal_new("forwarded",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      g_cclosure_marshal_VOID__VOID,
-      G_TYPE_NONE, 0);
+    g_signal_new ("forwarded", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        g_cclosure_marshal_VOID__VOID,
+        G_TYPE_NONE, 0);
 
   call_signals[SIGNAL_DIALSTRING] =
-    g_signal_new("dialstring",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      g_cclosure_marshal_VOID__STRING,
-      G_TYPE_NONE, 1,
-      G_TYPE_STRING);
+    g_signal_new ("dialstring", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        g_cclosure_marshal_VOID__STRING,
+        G_TYPE_NONE, 1,
+        G_TYPE_STRING);
 
   call_signals[SIGNAL_DTMF_TONE] =
-    g_signal_new("dtmf-tone",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      g_cclosure_marshal_VOID__INT,
-      G_TYPE_NONE, 1,
-      G_TYPE_INT);
+    g_signal_new ("dtmf-tone", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        g_cclosure_marshal_VOID__INT,
+        G_TYPE_NONE, 1,
+        G_TYPE_INT);
 }
 
 /* ---------------------------------------------------------------------- */
 /* ModemCall interface */
 
 char const *
-modem_call_get_name(ModemCall const *self)
+modem_call_get_name (ModemCall const *self)
 {
   if (self == NULL)
     return "<nil>";
 
-  char *last = strrchr(self->priv->object_path, '/');
+  char *last = strrchr (self->priv->object_path, '/');
   if (last)
     return last + 1;
 
@@ -536,15 +519,16 @@ modem_call_get_name(ModemCall const *self)
 }
 
 char const *
-modem_call_get_path(ModemCall const *self)
+modem_call_get_path (ModemCall const *self)
 {
   return self->priv->object_path;
 }
 
 char const *
-modem_call_get_state_name(int state)
+modem_call_get_state_name (int state)
 {
-  switch (state) {
+  switch (state)
+    {
     case MODEM_CALL_STATE_INVALID: return "INVALID";
     case MODEM_CALL_STATE_DIALING: return "DIALING";
     case MODEM_CALL_STATE_ALERTING: return "ALERTING";
@@ -554,452 +538,465 @@ modem_call_get_state_name(int state)
     case MODEM_CALL_STATE_HELD: return "HELD";
     case MODEM_CALL_STATE_DISCONNECTED: return "DISCONNECTED";
     default: return "UNKNOWN";
-  }
+    }
 }
 
 ModemCallState
-modem_call_get_state(ModemCall const *self)
+modem_call_get_state (ModemCall const *self)
 {
-  return MODEM_IS_CALL(self) ? self->priv->state : MODEM_CALL_STATE_INVALID;
+  return MODEM_IS_CALL (self) ? self->priv->state : MODEM_CALL_STATE_INVALID;
 }
 
 gboolean
-modem_call_has_path(ModemCall const *self,
-  char const *object_path)
+modem_call_has_path (ModemCall const *self,
+                     char const *object_path)
 {
-  return object_path && strcmp(self->priv->object_path, object_path) == 0;
+  return object_path && strcmp (self->priv->object_path, object_path) == 0;
 }
 
 gboolean
-modem_call_try_set_handler(ModemCall *self,
-  gpointer handler)
+modem_call_try_set_handler (ModemCall *self,
+                            gpointer handler)
 {
-  if (!MODEM_IS_CALL(self))
+  if (!MODEM_IS_CALL (self))
     return FALSE;
 
   ModemCallPrivate *priv = self->priv;
 
-  if (handler) {
-    if (priv->handler != NULL && priv->handler != handler) {
-      return FALSE;
+  if (handler)
+    {
+      if (priv->handler != NULL && priv->handler != handler)
+        {
+          return FALSE;
+        }
     }
-  }
   priv->handler = handler;
   return TRUE;
 }
 
 void
-modem_call_set_handler(ModemCall *self,
-  gpointer handler)
+modem_call_set_handler (ModemCall *self,
+                        gpointer handler)
 {
-  gboolean success = modem_call_try_set_handler(self, handler);
-  g_assert(success);
+  gboolean success = modem_call_try_set_handler (self, handler);
+  g_assert (success);
 }
 
 gpointer
-modem_call_get_handler(ModemCall *self)
+modem_call_get_handler (ModemCall *self)
 {
-  return MODEM_IS_CALL(self) ? self->priv->handler : NULL;
+  return MODEM_IS_CALL (self) ? self->priv->handler : NULL;
 }
 
 gboolean
-modem_call_is_member(ModemCall const *self)
+modem_call_is_member (ModemCall const *self)
 {
-  return MODEM_IS_CALL(self) && self->priv->member;
+  return MODEM_IS_CALL (self) && self->priv->member;
 }
 
 gboolean
-modem_call_is_originating(ModemCall const *self)
+modem_call_is_originating (ModemCall const *self)
 {
-  return MODEM_IS_CALL(self) && self->priv->originating;
+  return MODEM_IS_CALL (self) && self->priv->originating;
 }
 
 gboolean
-modem_call_is_terminating(ModemCall const *self)
+modem_call_is_terminating (ModemCall const *self)
 {
-  return MODEM_IS_CALL(self) && self->priv->terminating;
+  return MODEM_IS_CALL (self) && self->priv->terminating;
 }
 
 gboolean
-modem_call_is_active(ModemCall const *self)
+modem_call_is_active (ModemCall const *self)
 {
-  return MODEM_IS_CALL(self) &&
+  return MODEM_IS_CALL (self) &&
     self->priv->state == MODEM_CALL_STATE_ACTIVE;
 }
 
 gboolean
-modem_call_is_held(ModemCall const *self)
+modem_call_is_held (ModemCall const *self)
 {
   return self &&
     self->priv->state == MODEM_CALL_STATE_HELD;
 }
 
 ModemCallState
-modem_call_state_from_ofono_state(const char *state)
+modem_call_state_from_ofono_state (const char *state)
 {
   if (G_UNLIKELY (!state))
     return MODEM_CALL_STATE_INVALID;
-  else if (!strcmp(state, "active"))
+  else if (!strcmp (state, "active"))
     return MODEM_CALL_STATE_ACTIVE;
-  else if (!strcmp(state, "held"))
+  else if (!strcmp (state, "held"))
     return MODEM_CALL_STATE_HELD;
-  else if (!strcmp(state, "dialing"))
+  else if (!strcmp (state, "dialing"))
     return MODEM_CALL_STATE_DIALING;
-  else if (!strcmp(state, "alerting"))
+  else if (!strcmp (state, "alerting"))
     return MODEM_CALL_STATE_ALERTING;
-  else if (!strcmp(state, "incoming"))
+  else if (!strcmp (state, "incoming"))
     return MODEM_CALL_STATE_INCOMING;
-  else if (!strcmp(state, "waiting"))
+  else if (!strcmp (state, "waiting"))
     return MODEM_CALL_STATE_WAITING;
-  else if (!strcmp(state, "disconnected"))
+  else if (!strcmp (state, "disconnected"))
     return MODEM_CALL_STATE_DISCONNECTED;
 
   return MODEM_CALL_STATE_INVALID;
 }
 
 static void
-on_call_property_changed(DBusGProxy *proxy,
-  char const *property,
-  GValue const *value,
-  gpointer user_data)
+on_call_property_changed (DBusGProxy *proxy,
+                          char const *property,
+                          GValue const *value,
+                          gpointer user_data)
 {
   char *s;
   ModemCall *self = MODEM_CALL (user_data);
 
-  DEBUG("enter");
+  DEBUG ("enter");
 
-  s = g_strdup_value_contents(value);
-  DEBUG("%s = %s", property, s);
-  g_free(s);
+  s = g_strdup_value_contents (value);
+  DEBUG ("%s = %s", property, s);
+  g_free (s);
 
-  if (!strcmp(property, "State")) {
-    ModemCallState state;
+  if (!strcmp (property, "State"))
+    {
+      ModemCallState state;
 
-    state = modem_call_state_from_ofono_state(
-      g_value_get_string(value));
+      state = modem_call_state_from_ofono_state (
+          g_value_get_string (value));
 
-    if (state != self->priv->state) {
-      g_object_set(self, "state", state, NULL);
-      g_signal_emit(self, call_signals[SIGNAL_STATE], 0, state);
+      if (state != self->priv->state)
+        {
+          g_object_set (self, "state", state, NULL);
+          g_signal_emit (self, call_signals[SIGNAL_STATE], 0, state);
 
-      /* Ofono does not have a separate 'terminated' state, so
-       * we fake it here for now */
-      if (state == MODEM_CALL_STATE_DISCONNECTED)
-        g_signal_emit(self, call_signals[SIGNAL_TERMINATED], 0);
+          /* Ofono does not have a separate 'terminated' state, so
+           * we fake it here for now */
+          if (state == MODEM_CALL_STATE_DISCONNECTED)
+            g_signal_emit (self, call_signals[SIGNAL_TERMINATED], 0);
+        }
     }
-  }
 }
 
 #if nomore
 static void
-on_call_state(DBusGProxy *proxy,
-  guint state,
-  guint causetype,
-  guint cause,
-  ModemCall *self)
+on_call_state (DBusGProxy *proxy,
+               guint state,
+               guint causetype,
+               guint cause,
+               ModemCall *self)
 {
   ModemCallPrivate *priv = self->priv;
 
-  g_assert(proxy); g_assert(self); g_assert(priv->proxy == proxy);
+  g_assert (proxy); g_assert (self); g_assert (priv->proxy == proxy);
 
-  DEBUG("CallState(%s (%u), %u, %u) from %s%s",
-    modem_call_get_state_name(state),
-    state, causetype, cause, dbus_g_proxy_get_path(proxy),
-    priv->handler ? "" : " (no channel)");
+  DEBUG ("CallState (%s (%u), %u, %u) from %s%s",
+      modem_call_get_state_name (state),
+      state, causetype, cause, dbus_g_proxy_get_path (proxy),
+      priv->handler ? "" : " (no channel)");
 
-  g_object_set(self, "state", state,
-    causetype > MODEM_CALL_CAUSE_TYPE_NETWORK
-    /* Unknown causetype, ignore */
-    ? NULL
-    : "causetype", causetype,
-    "cause", cause,
-    NULL);
+  g_object_set (self, "state", state,
+      causetype > MODEM_CALL_CAUSE_TYPE_NETWORK
+      /* Unknown causetype, ignore */
+      ? NULL
+      : "causetype", causetype,
+      "cause", cause,
+      NULL);
 
-  switch (state) {
+  switch (state)
+    {
     case MODEM_CALL_STATE_INCOMING:
-      g_object_set(self, "terminating", TRUE, NULL);
+      g_object_set (self, "terminating", TRUE, NULL);
       break;
     case MODEM_CALL_STATE_DIALING:
-      g_object_set(self, "originating", TRUE, NULL);
+      g_object_set (self, "originating", TRUE, NULL);
       break;
 
     case MODEM_CALL_STATE_INVALID:
-      g_object_set(self,
-        "remote", NULL,
-        "emergency", NULL,
-        "originating", FALSE,
-        "terminating", FALSE,
-        "onhold", FALSE,
-        "member", FALSE,
-        NULL);
+      g_object_set (self,
+          "remote", NULL,
+          "emergency", NULL,
+          "originating", FALSE,
+          "terminating", FALSE,
+          "onhold", FALSE,
+          "member", FALSE,
+          NULL);
       break;
-  }
-
-  if (priv->handler == NULL) {
-    switch (state) {
-      case MODEM_CALL_STATE_DIALING:
-      case MODEM_CALL_STATE_ALERTING:
-      case MODEM_CALL_STATE_INCOMING:
-      case MODEM_CALL_STATE_WAITING:
-      case MODEM_CALL_STATE_ACTIVE:
-      case MODEM_CALL_STATE_HELD:
-      {
-        char const *remote = priv->remote ? priv->remote : "";
-        if (priv->terminating)
-          g_signal_emit_by_name(priv->service, "incoming", self, remote);
-        else if (priv->originating)
-          g_signal_emit_by_name(priv->service, "created", self, remote);
-      }
-      break;
-      default:
-        break;
     }
-  }
 
-  g_signal_emit(self, call_signals[SIGNAL_STATE], 0, state, causetype, cause);
+  if (priv->handler == NULL)
+    {
+      switch (state)
+        {
+        case MODEM_CALL_STATE_DIALING:
+        case MODEM_CALL_STATE_ALERTING:
+        case MODEM_CALL_STATE_INCOMING:
+        case MODEM_CALL_STATE_WAITING:
+        case MODEM_CALL_STATE_ACTIVE:
+        case MODEM_CALL_STATE_HELD:
+          {
+            char const *remote = priv->remote ? priv->remote : "";
+            if (priv->terminating)
+              g_signal_emit_by_name (priv->service, "incoming", self, remote);
+            else if (priv->originating)
+              g_signal_emit_by_name (priv->service, "created", self, remote);
+          }
+          break;
+        default:
+          break;
+        }
+    }
 
-  if (state == MODEM_CALL_STATE_TERMINATED) {
-    g_object_set(self,
-      "remote", NULL,
-      "emergency", NULL,
-      "originating", FALSE,
-      "terminating", FALSE,
-      "onhold", FALSE,
-      "member", FALSE,
-      NULL);
-  }
+  g_signal_emit (self, call_signals[SIGNAL_STATE], 0, state, causetype, cause);
+
+  if (state == MODEM_CALL_STATE_TERMINATED)
+    {
+      g_object_set (self,
+          "remote", NULL,
+          "emergency", NULL,
+          "originating", FALSE,
+          "terminating", FALSE,
+          "onhold", FALSE,
+          "member", FALSE,
+          NULL);
+    }
 }
 #endif
 
 ModemRequest *
-modem_call_request_answer(ModemCall *self,
-  ModemCallReply callback,
-  gpointer user_data)
+modem_call_request_answer (ModemCall *self,
+                           ModemCallReply callback,
+                           gpointer user_data)
 {
-  DEBUG("enter");
-  g_return_val_if_fail(self != NULL, NULL);
-  g_return_val_if_fail(!MODEM_CALL(self)->priv->dispose_has_run, NULL);
-
-  if (self->priv->state != MODEM_CALL_STATE_WAITING) {
-    DEBUG("%s.%s(%s)", OFONO_IFACE_CALL, "Answer",
-      self ? self->priv->object_path : "NULL");
-    return modem_request(MODEM_CALL(self), self->priv->proxy,
-      "Answer", reply_to_instance_request,
-      G_CALLBACK(callback), user_data,
-      G_TYPE_INVALID);
-  }
+  DEBUG ("enter");
+  g_return_val_if_fail (self != NULL, NULL);
+  g_return_val_if_fail (!MODEM_CALL (self)->priv->dispose_has_run, NULL);
+
+  if (self->priv->state != MODEM_CALL_STATE_WAITING)
+    {
+      DEBUG ("%s.%s (%s)", OFONO_IFACE_CALL, "Answer",
+          self ? self->priv->object_path : "NULL");
+      return modem_request (MODEM_CALL (self), self->priv->proxy,
+          "Answer", reply_to_instance_request,
+          G_CALLBACK (callback), user_data,
+          G_TYPE_INVALID);
+    }
   else {
-    DEBUG("%s.%s(%s)", OFONO_IFACE_CALL_MANAGER, "HoldAndAnswer",
-      self ? self->priv->object_path : "NULL");
-    return modem_request(MODEM_CALL(self),
-      _modem_call_service_proxy(self->priv->service),
-      "HoldAndAnswer", reply_to_instance_request,
-      G_CALLBACK(callback), user_data,
-      G_TYPE_INVALID);
+    DEBUG ("%s.%s (%s)", OFONO_IFACE_CALL_MANAGER, "HoldAndAnswer",
+        self ? self->priv->object_path : "NULL");
+    return modem_request (MODEM_CALL (self),
+        _modem_call_service_proxy (self->priv->service),
+        "HoldAndAnswer", reply_to_instance_request,
+        G_CALLBACK (callback), user_data,
+        G_TYPE_INVALID);
   }
 }
 
 ModemRequest *
-modem_call_request_release(ModemCall *self,
-  ModemCallReply callback,
-  gpointer user_data)
+modem_call_request_release (ModemCall *self,
+                            ModemCallReply callback,
+                            gpointer user_data)
 {
-  DEBUG("%s.%s(%s)", OFONO_IFACE_CALL, "Hangup",
-    self ? self->priv->object_path : "NULL");
-  g_return_val_if_fail(self != NULL, NULL);
-  g_return_val_if_fail(!MODEM_CALL(self)->priv->dispose_has_run, NULL);
-  return modem_request(MODEM_CALL(self), self->priv->proxy,
-    "Hangup", reply_to_instance_request,
-    G_CALLBACK(callback), user_data,
-    G_TYPE_INVALID);
+  DEBUG ("%s.%s (%s)", OFONO_IFACE_CALL, "Hangup",
+      self ? self->priv->object_path : "NULL");
+  g_return_val_if_fail (self != NULL, NULL);
+  g_return_val_if_fail (!MODEM_CALL (self)->priv->dispose_has_run, NULL);
+  return modem_request (MODEM_CALL (self), self->priv->proxy,
+      "Hangup", reply_to_instance_request,
+      G_CALLBACK (callback), user_data,
+      G_TYPE_INVALID);
 }
 
 
 ModemRequest *
-modem_call_request_split(ModemCall *self,
-  ModemCallReply callback,
-  gpointer user_data)
+modem_call_request_split (ModemCall *self,
+                          ModemCallReply callback,
+                          gpointer user_data)
 {
-  DEBUG("%s.%s(%s)", OFONO_IFACE_CALL_MANAGER, "PrivateChat",
-    self ? self->priv->object_path : "NULL");
-  g_return_val_if_fail(self != NULL, NULL);
-  g_return_val_if_fail(!MODEM_CALL(self)->priv->dispose_has_run, NULL);
-  return modem_request(MODEM_CALL(self),
-    _modem_call_service_proxy(self->priv->service),
-    "PrivateChat", reply_to_instance_request,
-    G_CALLBACK(callback), user_data,
-    DBUS_TYPE_G_OBJECT_PATH, self->priv->object_path,
-    G_TYPE_INVALID);
+  DEBUG ("%s.%s (%s)", OFONO_IFACE_CALL_MANAGER, "PrivateChat",
+      self ? self->priv->object_path : "NULL");
+  g_return_val_if_fail (self != NULL, NULL);
+  g_return_val_if_fail (!MODEM_CALL (self)->priv->dispose_has_run, NULL);
+  return modem_request (MODEM_CALL (self),
+      _modem_call_service_proxy (self->priv->service),
+      "PrivateChat", reply_to_instance_request,
+      G_CALLBACK (callback), user_data,
+      DBUS_TYPE_G_OBJECT_PATH, self->priv->object_path,
+      G_TYPE_INVALID);
 }
 
 ModemRequest *
-modem_call_request_hold(ModemCall *self,
-  int hold,
-  ModemCallReply callback,
-  gpointer user_data)
+modem_call_request_hold (ModemCall *self,
+                         int hold,
+                         ModemCallReply callback,
+                         gpointer user_data)
 {
   /* XXX: */
   (void)hold;
 
-  DEBUG("%s.%s", OFONO_IFACE_CALL_MANAGER, "SwapCalls");
-  g_return_val_if_fail(self != NULL, NULL);
-  g_return_val_if_fail(!MODEM_CALL(self)->priv->dispose_has_run, NULL);
-  return modem_request(MODEM_CALL(self),
-    _modem_call_service_proxy(self->priv->service),
-    "SwapCalls", reply_to_instance_request,
-    G_CALLBACK(callback), user_data,
-    G_TYPE_INVALID);
+  DEBUG ("%s.%s", OFONO_IFACE_CALL_MANAGER, "SwapCalls");
+  g_return_val_if_fail (self != NULL, NULL);
+  g_return_val_if_fail (!MODEM_CALL (self)->priv->dispose_has_run, NULL);
+  return modem_request (MODEM_CALL (self),
+      _modem_call_service_proxy (self->priv->service),
+      "SwapCalls", reply_to_instance_request,
+      G_CALLBACK (callback), user_data,
+      G_TYPE_INVALID);
 }
 
 static void
-reply_to_instance_request(DBusGProxy *proxy,
-  DBusGProxyCall *call,
-  void *_request)
+reply_to_instance_request (DBusGProxy *proxy,
+                           DBusGProxyCall *call,
+                           void *_request)
 {
-  DEBUG("enter");
+  DEBUG ("enter");
 
   ModemRequest *request = _request;
-  ModemCall *self = modem_request_object(request);
-  ModemCallReply *callback = modem_request_callback(request);
-  gpointer user_data = modem_request_user_data(request);
+  ModemCall *self = modem_request_object (request);
+  ModemCallReply *callback = modem_request_callback (request);
+  gpointer user_data = modem_request_user_data (request);
   GError *error = NULL;
 
-  if (dbus_g_proxy_end_call(proxy, call, &error, G_TYPE_INVALID)) {
-  }
+  if (dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID))
+    {
+    }
   else {
-    modem_error_fix(&error);
+    modem_error_fix (&error);
   }
-  if (callback) callback(self, request, error, user_data);
-  g_clear_error(&error);
+  if (callback) callback (self, request, error, user_data);
+  g_clear_error (&error);
 }
 
 gboolean
-modem_call_can_join(ModemCall const *self)
+modem_call_can_join (ModemCall const *self)
 {
-  if (!self || MODEM_IS_CALL_CONFERENCE(self))
+  if (!self || MODEM_IS_CALL_CONFERENCE (self))
     return FALSE;
 
   return (self->priv->state == MODEM_CALL_STATE_ACTIVE ||
-    self->priv->state == MODEM_CALL_STATE_HELD);
+      self->priv->state == MODEM_CALL_STATE_HELD);
 }
 
 ModemRequest *
-modem_call_send_dtmf(ModemCall *self, char const *dialstring,
-  ModemCallReply *callback,
-  gpointer user_data)
+modem_call_send_dtmf (ModemCall *self, char const *dialstring,
+                      ModemCallReply *callback,
+                      gpointer user_data)
 {
   int i;
   char modemstring[256];
   ModemCallPrivate *priv = self->priv;
 
-  g_return_val_if_fail(dialstring != NULL, NULL);
-  g_return_val_if_fail(!priv->dispose_has_run, NULL);
-  g_return_val_if_fail(priv->service != NULL, NULL);
-
-  for (i = 0; dialstring[i]; i++) {
-    if (i == 255)
-      return NULL; /* Too long */
-
-    switch (dialstring[i]) {
-      case '0':
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9':
-      case '#':
-      case '*':
-        modemstring[i] = dialstring[i];
-      break;
+  g_return_val_if_fail (dialstring != NULL, NULL);
+  g_return_val_if_fail (!priv->dispose_has_run, NULL);
+  g_return_val_if_fail (priv->service != NULL, NULL);
+
+  for (i = 0; dialstring[i]; i++)
+    {
+      if (i == 255)
+        return NULL; /* Too long */
+
+      switch (dialstring[i])
+        {
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+        case '#':
+        case '*':
+          modemstring[i] = dialstring[i];
+        break;
 
-      case 'p': case 'P': modemstring[i] = 'p'; break;
-      case 'w': case 'W': modemstring[i] = 'w'; break;
-      case 'a': case 'A': modemstring[i] = 'a'; break;
-      case 'b': case 'B': modemstring[i] = 'b'; break;
-      case 'c': case 'C': modemstring[i] = 'c'; break;
-      case 'd': case 'D': modemstring[i] = 'd'; break;
+        case 'p': case 'P': modemstring[i] = 'p'; break;
+        case 'w': case 'W': modemstring[i] = 'w'; break;
+        case 'a': case 'A': modemstring[i] = 'a'; break;
+        case 'b': case 'B': modemstring[i] = 'b'; break;
+        case 'c': case 'C': modemstring[i] = 'c'; break;
+        case 'd': case 'D': modemstring[i] = 'd'; break;
 
-      default:
-        return NULL;
+        default:
+          return NULL;
+        }
     }
-  }
 
   modemstring[i] = '\0';
 
-  return modem_request(self,
-    _modem_call_service_proxy(self->priv->service),
-    "SendTones", reply_to_instance_request,
-    G_CALLBACK(callback), user_data,
-    G_TYPE_STRING, modemstring,
-    G_TYPE_INVALID);
+  return modem_request (self,
+      _modem_call_service_proxy (self->priv->service),
+      "SendTones", reply_to_instance_request,
+      G_CALLBACK (callback), user_data,
+      G_TYPE_STRING, modemstring,
+      G_TYPE_INVALID);
 }
 
 /* XXX: Ofono at the moment supports only fixed-duration tones */
 ModemRequest *
-modem_call_start_dtmf(ModemCall *self, char const tone,
-  ModemCallReply *callback,
-  gpointer user_data)
+modem_call_start_dtmf (ModemCall *self, char const tone,
+                       ModemCallReply *callback,
+                       gpointer user_data)
 {
   char tones[2];
-  g_return_val_if_fail(self != NULL, NULL);
-  g_return_val_if_fail(!MODEM_CALL(self)->priv->dispose_has_run, NULL);
+  g_return_val_if_fail (self != NULL, NULL);
+  g_return_val_if_fail (!MODEM_CALL (self)->priv->dispose_has_run, NULL);
 
   tones[0] = tone, tones[1] = '\0';
 
-  return modem_request(MODEM_CALL(self),
-    _modem_call_service_proxy(self->priv->service),
-    "SendTones", reply_to_instance_request,
-    G_CALLBACK(callback), user_data,
-    G_TYPE_STRING, tones,
-    G_TYPE_INVALID);
+  return modem_request (MODEM_CALL (self),
+      _modem_call_service_proxy (self->priv->service),
+      "SendTones", reply_to_instance_request,
+      G_CALLBACK (callback), user_data,
+      G_TYPE_STRING, tones,
+      G_TYPE_INVALID);
 }
 
 ModemRequest *
-modem_call_stop_dtmf(ModemCall *self,
-  ModemCallReply *callback,
-  gpointer user_data)
+modem_call_stop_dtmf (ModemCall *self,
+                      ModemCallReply *callback,
+                      gpointer user_data)
 {
-  g_return_val_if_fail(self != NULL, NULL);
-  g_return_val_if_fail(!MODEM_CALL(self)->priv->dispose_has_run, NULL);
-
-  return modem_request(MODEM_CALL(self),
-    _modem_call_service_proxy(self->priv->service),
-    "StopTones", reply_to_stop_dtmf,
-    G_CALLBACK(callback), user_data,
-    G_TYPE_INVALID);
+  g_return_val_if_fail (self != NULL, NULL);
+  g_return_val_if_fail (!MODEM_CALL (self)->priv->dispose_has_run, NULL);
+
+  return modem_request (MODEM_CALL (self),
+      _modem_call_service_proxy (self->priv->service),
+      "StopTones", reply_to_stop_dtmf,
+      G_CALLBACK (callback), user_data,
+      G_TYPE_INVALID);
 }
 
 static void
-reply_to_stop_dtmf(DBusGProxy *proxy,
-  DBusGProxyCall *call,
-  void *_request)
+reply_to_stop_dtmf (DBusGProxy *proxy,
+                    DBusGProxyCall *call,
+                    void *_request)
 {
-  DEBUG("enter");
+  DEBUG ("enter");
 
   ModemRequest *request = _request;
-  ModemCall *self = modem_request_object(request);
-  ModemCallReply *callback = modem_request_callback(request);
-  gpointer user_data = modem_request_user_data(request);
+  ModemCall *self = modem_request_object (request);
+  ModemCallReply *callback = modem_request_callback (request);
+  gpointer user_data = modem_request_user_data (request);
   char *stopped;
   GError *error = NULL;
 
-  if (dbus_g_proxy_end_call(proxy, call, &error,
-      G_TYPE_STRING, &stopped,
-      G_TYPE_INVALID)) {
-    g_free(stopped);
-  }
+  if (dbus_g_proxy_end_call (proxy, call, &error,
+          G_TYPE_STRING, &stopped,
+          G_TYPE_INVALID))
+    {
+      g_free (stopped);
+    }
   else {
-    modem_error_fix(&error);
-    DEBUG("got " GERROR_MSG_FMT, GERROR_MSG_CODE(error));
+    modem_error_fix (&error);
+    DEBUG ("got " GERROR_MSG_FMT, GERROR_MSG_CODE (error));
   }
 
   if (callback)
-    callback(self, request, error, user_data);
-  g_clear_error(&error);
+    callback (self, request, error, user_data);
+  g_clear_error (&error);
 }
 
 /* ---------------------------------------------------------------------- */
@@ -1008,7 +1005,8 @@ reply_to_stop_dtmf(DBusGProxy *proxy,
  */
 
 /* Signals */
-enum {
+enum
+{
   SIGNAL_JOINED,
   SIGNAL_LEFT,
   N_CONFERENCE_SIGNALS
@@ -1016,7 +1014,7 @@ enum {
 
 static guint conference_signals[N_CONFERENCE_SIGNALS];
 
-G_DEFINE_TYPE(ModemCallConference, modem_call_conference, MODEM_TYPE_CALL);
+G_DEFINE_TYPE (ModemCallConference, modem_call_conference, MODEM_TYPE_CALL);
 
 struct _ModemCallConferencePrivate
 {
@@ -1025,46 +1023,46 @@ struct _ModemCallConferencePrivate
 };
 
 static void
-modem_call_conference_constructed(GObject *object)
+modem_call_conference_constructed (GObject *object)
 {
-  if (G_OBJECT_CLASS(modem_call_conference_parent_class)->constructed)
-    G_OBJECT_CLASS(modem_call_conference_parent_class)->constructed(object);
+  if (G_OBJECT_CLASS (modem_call_conference_parent_class)->constructed)
+    G_OBJECT_CLASS (modem_call_conference_parent_class)->constructed (object);
 }
 
 static void
-modem_call_conference_init(ModemCallConference *self)
+modem_call_conference_init (ModemCallConference *self)
 {
-  self->priv = G_TYPE_INSTANCE_GET_PRIVATE(
-    self, MODEM_TYPE_CALL_CONFERENCE, ModemCallConferencePrivate);
+  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (
+      self, MODEM_TYPE_CALL_CONFERENCE, ModemCallConferencePrivate);
 }
 
 static void
-modem_call_conference_dispose(GObject *object)
+modem_call_conference_dispose (GObject *object)
 {
-  ModemCallConference *self = MODEM_CALL_CONFERENCE(object);
+  ModemCallConference *self = MODEM_CALL_CONFERENCE (object);
   ModemCallConferencePrivate *priv = self->priv;
 
   if (priv->dispose_has_run)
     return;
   priv->dispose_has_run = TRUE;
 
-  if (G_OBJECT_CLASS(modem_call_conference_parent_class)->dispose)
-    G_OBJECT_CLASS(modem_call_conference_parent_class)->dispose(object);
+  if (G_OBJECT_CLASS (modem_call_conference_parent_class)->dispose)
+    G_OBJECT_CLASS (modem_call_conference_parent_class)->dispose (object);
 }
 
 static void
-modem_call_conference_finalize(GObject *object)
+modem_call_conference_finalize (GObject *object)
 {
-  if (G_OBJECT_CLASS(modem_call_conference_parent_class)->finalize)
-    G_OBJECT_CLASS(modem_call_conference_parent_class)->finalize(object);
+  if (G_OBJECT_CLASS (modem_call_conference_parent_class)->finalize)
+    G_OBJECT_CLASS (modem_call_conference_parent_class)->finalize (object);
 }
 
 static void
-modem_call_conference_class_init(ModemCallConferenceClass *klass)
+modem_call_conference_class_init (ModemCallConferenceClass *klass)
 {
-  GObjectClass *object_class = G_OBJECT_CLASS(klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-  g_type_class_add_private(klass, sizeof (ModemCallConferencePrivate));
+  g_type_class_add_private (klass, sizeof (ModemCallConferencePrivate));
 
   object_class->constructed = modem_call_conference_constructed;
   object_class->dispose = modem_call_conference_dispose;
@@ -1072,28 +1070,26 @@ modem_call_conference_class_init(ModemCallConferenceClass *klass)
 
   /* Properties */
   conference_signals[SIGNAL_JOINED] =
-    g_signal_new("joined",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      g_cclosure_marshal_VOID__OBJECT,
-      G_TYPE_NONE, 1,
-      MODEM_TYPE_CALL);
+    g_signal_new ("joined", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        g_cclosure_marshal_VOID__OBJECT,
+        G_TYPE_NONE, 1,
+        MODEM_TYPE_CALL);
 
   conference_signals[SIGNAL_LEFT] =
-    g_signal_new("left",
-      G_OBJECT_CLASS_TYPE (klass),
-      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
-      0,
-      NULL, NULL,
-      g_cclosure_marshal_VOID__OBJECT,
-      G_TYPE_NONE, 1,
-      MODEM_TYPE_CALL);
+    g_signal_new ("left", G_OBJECT_CLASS_TYPE (klass),
+        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+        0,
+        NULL, NULL,
+        g_cclosure_marshal_VOID__OBJECT,
+        G_TYPE_NONE, 1,
+        MODEM_TYPE_CALL);
 }
 
 GError *
-modem_call_new_error(guint causetype, guint cause, char const *prefixed)
+modem_call_new_error (guint causetype, guint cause, char const *prefixed)
 {
   GQuark domain;
   char const *msg;
@@ -1101,135 +1097,145 @@ modem_call_new_error(guint causetype, guint cause, char const *prefixed)
   char printed[64];
   int code = cause;
 
-  if (cause == 0) {
-    domain = MODEM_CALL_ERRORS;
-    code = MODEM_CALL_ERROR_NO_ERROR;
-    msg = "None";
-    error = "";
-  }
-  else if (causetype == MODEM_CALL_CAUSE_TYPE_NETWORK) {
-    domain = MODEM_CALL_NET_ERRORS;
-    code = cause;
+  if (cause == 0)
+    {
+      domain = MODEM_CALL_ERRORS;
+      code = MODEM_CALL_ERROR_NO_ERROR;
+      msg = "None";
+      error = "";
+    }
+  else if (causetype == MODEM_CALL_CAUSE_TYPE_NETWORK)
+    {
+      domain = MODEM_CALL_NET_ERRORS;
+      code = cause;
 
 #define _(x) MODEM_CALL_NET_ERROR_ ## x
-    switch (cause) {
-      case _(UNASSIGNED_NUMBER): msg = "Unassigned Number"; break;
-      case _(NO_ROUTE): msg = "No Route To Destination"; break;
-      case _(CH_UNACCEPTABLE): msg = "Channel Unacceptable"; break;
-      case _(OPER_BARRING): msg = "Operator Determined Barring"; break;
-      case _(NORMAL): msg = "Normal Call Clearing"; error = ""; break;
-      case _(USER_BUSY): msg = "User Busy"; error = ""; break;
-      case _(NO_USER_RESPONSE): msg = "No User Response"; break;
-      case _(ALERT_NO_ANSWER): msg = "Alert No Answer"; break;
-      case _(CALL_REJECTED): msg = "Call Rejected"; break;
-      case _(NUMBER_CHANGED): msg = "Number Changed"; break;
-      case _(NON_SELECT_CLEAR): msg = "Non-Selected Clearing"; break;
-      case _(DEST_OUT_OF_ORDER): msg = "Destination Out Of Order"; break;
-      case _(INVALID_NUMBER): msg = "Invalid Number"; break;
-      case _(FACILITY_REJECTED): msg = "Facility Rejected"; break;
-      case _(RESP_TO_STATUS): msg = "Response To Status"; error = ""; break;
-      case _(NORMAL_UNSPECIFIED): msg = "Unspecified Normal"; error = ""; break;
-      case _(NO_CHANNEL): msg = "No Channel Available"; break;
-      case _(NETW_OUT_OF_ORDER): msg = "Network Out Of Order"; break;
-      case _(TEMPORARY_FAILURE): msg = "Temporary Failure"; error =""; break;
-      case _(CONGESTION): msg = "Congestion"; break;
-      case _(ACCESS_INFO_DISC): msg = "Access Information Discarded"; break;
-      case _(CHANNEL_NA): msg = "Channel Not Available"; break;
-      case _(RESOURCES_NA): msg = "Resources Not Available"; break;
-      case _(QOS_NA): msg = "QoS Not Available"; break;
-      case _(FACILITY_UNSUBS): msg = "Requested Facility Not Subscribed"; break;
-      case _(COMING_BARRED_CUG): msg = "Incoming Calls Barred Within CUG"; break;
-      case _(BC_UNAUTHORIZED): msg = "Bearer Capability Unauthorized"; break;
-      case _(BC_NA): msg = "Bearer Capability Not Available"; break;
-      case _(SERVICE_NA): msg = "Service Not Available"; break;
-      case _(BEARER_NOT_IMPL): msg = "Bearer Not Implemented"; break;
-      case _(ACM_MAX): msg = "ACM Max"; break;
-      case _(FACILITY_NOT_IMPL): msg = "Facility Not Implemented"; break;
-      case _(ONLY_RDI_BC): msg = "Only Restricted DI Bearer Capability"; break;
-      case _(SERVICE_NOT_IMPL): msg = "Service Not Implemented"; break;
-      case _(INVALID_TI): msg = "Invalid Transaction Identifier"; break;
-      case _(NOT_IN_CUG): msg = "Not In CUG"; break;
-      case _(INCOMPATIBLE_DEST): msg = "Incompatible Destination"; break;
-      case _(INV_TRANS_NET_SEL): msg = "Invalid Transit Net Selected"; break;
-      case _(SEMANTICAL_ERR): msg = "Semantical"; break;
-      case _(INVALID_MANDATORY): msg = "Invalid Mandatory Information"; break;
-      case _(MSG_TYPE_INEXIST): msg = "Message Type Non-Existent"; break;
-      case _(MSG_TYPE_INCOMPAT): msg = "Message Type Incompatible"; break;
-      case _(IE_NON_EXISTENT): msg = "Information Element Non-Existent"; break;
-      case _(COND_IE_ERROR): msg = "Conditional Information Element"; break;
-      case _(MSG_INCOMPATIBLE): msg = "Incompatible Message"; break;
-      case _(TIMER_EXPIRY): msg = "Timer Expiry"; break;
-      case _(PROTOCOL_ERROR): msg = "Protocol"; break;
-      case _(INTERWORKING):
-        msg = "Error Cause Not Known Because of Interworking", error = "";
-        break;
-      default:
-        code = MODEM_CALL_NET_ERROR_GENERIC;
-        snprintf(printed, sizeof printed, "Error %u with type %u", cause, causetype);
-        msg = printed, error = "";
-    }
+      switch (cause)
+        {
+        case _(UNASSIGNED_NUMBER): msg = "Unassigned Number"; break;
+        case _(NO_ROUTE): msg = "No Route To Destination"; break;
+        case _(CH_UNACCEPTABLE): msg = "Channel Unacceptable"; break;
+        case _(OPER_BARRING): msg = "Operator Determined Barring"; break;
+        case _(NORMAL): msg = "Normal Call Clearing"; error = ""; break;
+        case _(USER_BUSY): msg = "User Busy"; error = ""; break;
+        case _(NO_USER_RESPONSE): msg = "No User Response"; break;
+        case _(ALERT_NO_ANSWER): msg = "Alert No Answer"; break;
+        case _(CALL_REJECTED): msg = "Call Rejected"; break;
+        case _(NUMBER_CHANGED): msg = "Number Changed"; break;
+        case _(NON_SELECT_CLEAR): msg = "Non-Selected Clearing"; break;
+        case _(DEST_OUT_OF_ORDER): msg = "Destination Out Of Order"; break;
+        case _(INVALID_NUMBER): msg = "Invalid Number"; break;
+        case _(FACILITY_REJECTED): msg = "Facility Rejected"; break;
+        case _(RESP_TO_STATUS): msg = "Response To Status"; error = ""; break;
+        case _(NORMAL_UNSPECIFIED): msg = "Unspecified Normal"; error = ""; break;
+        case _(NO_CHANNEL): msg = "No Channel Available"; break;
+        case _(NETW_OUT_OF_ORDER): msg = "Network Out Of Order"; break;
+        case _(TEMPORARY_FAILURE): msg = "Temporary Failure"; error =""; break;
+        case _(CONGESTION): msg = "Congestion"; break;
+        case _(ACCESS_INFO_DISC): msg = "Access Information Discarded"; break;
+        case _(CHANNEL_NA): msg = "Channel Not Available"; break;
+        case _(RESOURCES_NA): msg = "Resources Not Available"; break;
+        case _(QOS_NA): msg = "QoS Not Available"; break;
+        case _(FACILITY_UNSUBS): msg = "Requested Facility Not Subscribed"; break;
+        case _(COMING_BARRED_CUG): msg = "Incoming Calls Barred Within CUG"; break;
+        case _(BC_UNAUTHORIZED): msg = "Bearer Capability Unauthorized"; break;
+        case _(BC_NA): msg = "Bearer Capability Not Available"; break;
+        case _(SERVICE_NA): msg = "Service Not Available"; break;
+        case _(BEARER_NOT_IMPL): msg = "Bearer Not Implemented"; break;
+        case _(ACM_MAX): msg = "ACM Max"; break;
+        case _(FACILITY_NOT_IMPL): msg = "Facility Not Implemented"; break;
+        case _(ONLY_RDI_BC): msg = "Only Restricted DI Bearer Capability"; break;
+        case _(SERVICE_NOT_IMPL): msg = "Service Not Implemented"; break;
+        case _(INVALID_TI): msg = "Invalid Transaction Identifier"; break;
+        case _(NOT_IN_CUG): msg = "Not In CUG"; break;
+        case _(INCOMPATIBLE_DEST): msg = "Incompatible Destination"; break;
+        case _(INV_TRANS_NET_SEL): msg = "Invalid Transit Net Selected"; break;
+        case _(SEMANTICAL_ERR): msg = "Semantical"; break;
+        case _(INVALID_MANDATORY): msg = "Invalid Mandatory Information"; break;
+        case _(MSG_TYPE_INEXIST): msg = "Message Type Non-Existent"; break;
+        case _(MSG_TYPE_INCOMPAT): msg = "Message Type Incompatible"; break;
+        case _(IE_NON_EXISTENT): msg = "Information Element Non-Existent"; break;
+        case _(COND_IE_ERROR): msg = "Conditional Information Element"; break;
+        case _(MSG_INCOMPATIBLE): msg = "Incompatible Message"; break;
+        case _(TIMER_EXPIRY): msg = "Timer Expiry"; break;
+        case _(PROTOCOL_ERROR): msg = "Protocol"; break;
+        case _(INTERWORKING):
+          msg = "Error Cause Not Known Because of Interworking", error = "";
+          break;
+        default:
+          code = MODEM_CALL_NET_ERROR_GENERIC;
+          snprintf (printed, sizeof printed, "Error %u with type %u", cause, causetype);
+          msg = printed, error = "";
+        }
 #undef _
-  }
+    }
   else if (causetype == MODEM_CALL_CAUSE_TYPE_LOCAL ||
-    causetype == MODEM_CALL_CAUSE_TYPE_REMOTE) {
+      causetype == MODEM_CALL_CAUSE_TYPE_REMOTE)
+    {
 
-    domain = MODEM_CALL_ERRORS;
+      domain = MODEM_CALL_ERRORS;
 
 #define _(x) MODEM_CALL_ERROR_ ## x
-    switch (cause) {
-      case _(NO_CALL): msg = "No Call"; break;
-      case _(RELEASE_BY_USER): msg = "Release By User"; error = ""; break;
-      case _(BUSY_USER_REQUEST): msg = "Busy User Request"; break;
-      case _(ERROR_REQUEST): msg = "Request"; break;
-      case _(CALL_ACTIVE): msg = "Call Active"; break;
-      case _(NO_CALL_ACTIVE): msg = "No Call Active"; break;
-      case _(INVALID_CALL_MODE): msg = "Invalid Call Mode"; break;
-      case _(TOO_LONG_ADDRESS): msg = "Too Long Address"; break;
-      case _(INVALID_ADDRESS): msg = "Invalid Address"; break;
-      case _(EMERGENCY): msg = "Emergency"; break;
-      case _(NO_SERVICE): msg = "No Service"; break;
-      case _(NO_COVERAGE): msg = "No Coverage"; break;
-      case _(CODE_REQUIRED): msg = "Code Required"; break;
-      case _(NOT_ALLOWED): msg = "Not Allowed"; break;
-      case _(DTMF_ERROR): msg = "DTMF Error"; break;
-      case _(CHANNEL_LOSS): msg = "Channel Loss"; break;
-      case _(FDN_NOT_OK): msg = "FDN Not Ok"; break;
-      case _(BLACKLIST_BLOCKED): msg = "Blacklist Blocked"; break;
-      case _(BLACKLIST_DELAYED): msg = "Blacklist Delayed"; break;
-      case _(EMERGENCY_FAILURE): msg = "Emergency Failure"; break;
-      case _(NO_SIM): msg = "No SIM"; break;
-      case _(DTMF_SEND_ONGOING): msg = "DTMF Send Ongoing"; break;
-      case _(CS_INACTIVE): msg = "CS Inactive"; break;
-      case _(NOT_READY): msg = "Not Ready"; break;
-      case _(INCOMPATIBLE_DEST): msg = "Incompatible Dest"; break;
-      default:
-        code = MODEM_CALL_ERROR_GENERIC;
-        snprintf(printed, sizeof printed, "Error %u with type %u", cause, causetype);
-        msg = printed, error = "";
-    }
+      switch (cause)
+        {
+        case _(NO_CALL): msg = "No Call"; break;
+        case _(RELEASE_BY_USER): msg = "Release By User"; error = ""; break;
+        case _(BUSY_USER_REQUEST): msg = "Busy User Request"; break;
+        case _(ERROR_REQUEST): msg = "Request"; break;
+        case _(CALL_ACTIVE): msg = "Call Active"; break;
+        case _(NO_CALL_ACTIVE): msg = "No Call Active"; break;
+        case _(INVALID_CALL_MODE): msg = "Invalid Call Mode"; break;
+        case _(TOO_LONG_ADDRESS): msg = "Too Long Address"; break;
+        case _(INVALID_ADDRESS): msg = "Invalid Address"; break;
+        case _(EMERGENCY): msg = "Emergency"; break;
+        case _(NO_SERVICE): msg = "No Service"; break;
+        case _(NO_COVERAGE): msg = "No Coverage"; break;
+        case _(CODE_REQUIRED): msg = "Code Required"; break;
+        case _(NOT_ALLOWED): msg = "Not Allowed"; break;
+        case _(DTMF_ERROR): msg = "DTMF Error"; break;
+        case _(CHANNEL_LOSS): msg = "Channel Loss"; break;
+        case _(FDN_NOT_OK): msg = "FDN Not Ok"; break;
+        case _(BLACKLIST_BLOCKED): msg = "Blacklist Blocked"; break;
+        case _(BLACKLIST_DELAYED): msg = "Blacklist Delayed"; break;
+        case _(EMERGENCY_FAILURE): msg = "Emergency Failure"; break;
+        case _(NO_SIM): msg = "No SIM"; break;
+        case _(DTMF_SEND_ONGOING): msg = "DTMF Send Ongoing"; break;
+        case _(CS_INACTIVE): msg = "CS Inactive"; break;
+        case _(NOT_READY): msg = "Not Ready"; break;
+        case _(INCOMPATIBLE_DEST): msg = "Incompatible Dest"; break;
+        default:
+          code = MODEM_CALL_ERROR_GENERIC;
+          snprintf (printed, sizeof printed, "Error %u with type %u", cause, causetype);
+          msg = printed, error = "";
+        }
 #undef _
-  } else {
-    domain = MODEM_CALL_ERRORS;
-    code = MODEM_CALL_ERROR_GENERIC;
-    snprintf(printed, sizeof printed, "Error %u with type %u", cause, causetype);
-    msg = printed, error = "";
-  }
+    }
+  else
+    {
+      domain = MODEM_CALL_ERRORS;
+      code = MODEM_CALL_ERROR_GENERIC;
+      snprintf (printed, sizeof printed, "Error %u with type %u", cause, causetype);
+      msg = printed, error = "";
+    }
 
-  if (prefixed) {
-    return g_error_new(domain, code, "%s: %s%s", prefixed, msg, error);
-  }
-  else {
-    return g_error_new(domain, code, "%s%s", msg, error);
-  }
+  if (prefixed)
+    {
+      return g_error_new (domain, code, "%s: %s%s", prefixed, msg, error);
+    }
+  else
+    {
+      return g_error_new (domain, code, "%s%s", msg, error);
+    }
 }
 
 /* TODO: these need to be revised once Ofono provides sufficient information. */
 int
-modem_call_event_tone(guint state,
-  guint causetype,
-  guint cause)
+modem_call_event_tone (guint state,
+                       guint causetype,
+                       guint cause)
 {
-  switch (state) {
+  switch (state)
+    {
     case MODEM_CALL_STATE_DIALING:
     case MODEM_CALL_STATE_WAITING:
     case MODEM_CALL_STATE_INCOMING:
@@ -1240,77 +1246,81 @@ modem_call_event_tone(guint state,
       return TONES_EVENT_RINGING;
 
     case MODEM_CALL_STATE_DISCONNECTED:
-      if (causetype == MODEM_CALL_CAUSE_TYPE_NETWORK) {
-        /* 3GPP TS 22.001 F.4 */
-        switch (cause) {
-          case MODEM_CALL_NET_ERROR_NORMAL:
-          case MODEM_CALL_NET_ERROR_NORMAL_UNSPECIFIED:
-            return TONES_EVENT_DROPPED;
-
-          case MODEM_CALL_NET_ERROR_USER_BUSY:
-          case MODEM_CALL_NET_ERROR_CALL_REJECTED:
-            return TONES_EVENT_BUSY;
-
-          case MODEM_CALL_NET_ERROR_RESP_TO_STATUS:
-            return TONES_NONE;
-
-          case MODEM_CALL_NET_ERROR_NO_CHANNEL:
-          case MODEM_CALL_NET_ERROR_TEMPORARY_FAILURE:
-          case MODEM_CALL_NET_ERROR_CONGESTION:
-          case MODEM_CALL_NET_ERROR_CHANNEL_NA:
-          case MODEM_CALL_NET_ERROR_QOS_NA:
-          case MODEM_CALL_NET_ERROR_BC_NA:
-            return TONES_EVENT_CONGESTION;
-
-          default:
-            return TONES_EVENT_SPECIAL_INFORMATION;
-        }
-      }
-      else {
-        switch (cause) {
-          case MODEM_CALL_ERROR_RELEASE_BY_USER:
-            if (causetype == MODEM_CALL_CAUSE_TYPE_LOCAL)
-              return TONES_NONE;
-            else
+      if (causetype == MODEM_CALL_CAUSE_TYPE_NETWORK)
+        {
+          /* 3GPP TS 22.001 F.4 */
+          switch (cause)
+            {
+            case MODEM_CALL_NET_ERROR_NORMAL:
+            case MODEM_CALL_NET_ERROR_NORMAL_UNSPECIFIED:
               return TONES_EVENT_DROPPED;
 
-          case MODEM_CALL_ERROR_BLACKLIST_BLOCKED:
-          case MODEM_CALL_ERROR_BLACKLIST_DELAYED:
-            return TONES_EVENT_BUSY;
-
-          case MODEM_CALL_ERROR_CHANNEL_LOSS:
-          case MODEM_CALL_ERROR_NO_SERVICE:
-          case MODEM_CALL_ERROR_NO_COVERAGE:
-            return TONES_EVENT_CONGESTION;
+            case MODEM_CALL_NET_ERROR_USER_BUSY:
+            case MODEM_CALL_NET_ERROR_CALL_REJECTED:
+              return TONES_EVENT_BUSY;
 
-          case MODEM_CALL_ERROR_BUSY_USER_REQUEST:
-            if (causetype == MODEM_CALL_CAUSE_TYPE_LOCAL)
+            case MODEM_CALL_NET_ERROR_RESP_TO_STATUS:
               return TONES_NONE;
-            else
+
+            case MODEM_CALL_NET_ERROR_NO_CHANNEL:
+            case MODEM_CALL_NET_ERROR_TEMPORARY_FAILURE:
+            case MODEM_CALL_NET_ERROR_CONGESTION:
+            case MODEM_CALL_NET_ERROR_CHANNEL_NA:
+            case MODEM_CALL_NET_ERROR_QOS_NA:
+            case MODEM_CALL_NET_ERROR_BC_NA:
+              return TONES_EVENT_CONGESTION;
+
+            default:
               return TONES_EVENT_SPECIAL_INFORMATION;
-          default:
-            return TONES_EVENT_SPECIAL_INFORMATION;
+            }
+        }
+      else
+        {
+          switch (cause)
+            {
+            case MODEM_CALL_ERROR_RELEASE_BY_USER:
+              if (causetype == MODEM_CALL_CAUSE_TYPE_LOCAL)
+                return TONES_NONE;
+              else
+                return TONES_EVENT_DROPPED;
+
+            case MODEM_CALL_ERROR_BLACKLIST_BLOCKED:
+            case MODEM_CALL_ERROR_BLACKLIST_DELAYED:
+              return TONES_EVENT_BUSY;
+
+            case MODEM_CALL_ERROR_CHANNEL_LOSS:
+            case MODEM_CALL_ERROR_NO_SERVICE:
+            case MODEM_CALL_ERROR_NO_COVERAGE:
+              return TONES_EVENT_CONGESTION;
+
+            case MODEM_CALL_ERROR_BUSY_USER_REQUEST:
+              if (causetype == MODEM_CALL_CAUSE_TYPE_LOCAL)
+                return TONES_NONE;
+              else
+                return TONES_EVENT_SPECIAL_INFORMATION;
+            default:
+              return TONES_EVENT_SPECIAL_INFORMATION;
+            }
         }
-      }
       break;
-  }
+    }
 
   return TONES_NONE;
 }
 
 int
-modem_call_error_tone(GError *error)
+modem_call_error_tone (GError *error)
 {
   if (error == NULL)
     return TONES_NONE;
 
   if (error->domain == MODEM_CALL_NET_ERRORS)
-    return modem_call_event_tone(MODEM_CALL_STATE_DISCONNECTED,
-      MODEM_CALL_CAUSE_TYPE_NETWORK, error->code);
+    return modem_call_event_tone (MODEM_CALL_STATE_DISCONNECTED,
+        MODEM_CALL_CAUSE_TYPE_NETWORK, error->code);
 
   if (error->domain == MODEM_CALL_ERRORS)
-    return modem_call_event_tone(MODEM_CALL_STATE_DISCONNECTED,
-      MODEM_CALL_CAUSE_TYPE_REMOTE, error->code);
+    return modem_call_event_tone (MODEM_CALL_STATE_DISCONNECTED,
+        MODEM_CALL_CAUSE_TYPE_REMOTE, error->code);
 
   return TONES_EVENT_SPECIAL_INFORMATION;
 }
diff --git a/modem/call.h b/modem/call.h
index a631505..612c1e6 100644
--- a/modem/call.h
+++ b/modem/call.h
@@ -33,30 +33,36 @@ typedef struct _ModemCallService ModemCallService;
 typedef struct _ModemCallServiceClass ModemCallServiceClass;
 typedef struct _ModemCallServicePrivate ModemCallServicePrivate;
 
-struct _ModemCallServiceClass {
+struct _ModemCallServiceClass
+{
   GObjectClass parent_class;
 };
 
-struct _ModemCallService {
+struct _ModemCallService
+{
   GObject parent;
   ModemCallServicePrivate *priv;
 };
 
-GType modem_call_service_get_type(void);
+GType modem_call_service_get_type (void);
 
 /* TYPE MACROS */
-#define MODEM_TYPE_CALL_SERVICE                 \
-  (modem_call_service_get_type())
-#define MODEM_CALL_SERVICE(obj)                                         \
-  (G_TYPE_CHECK_INSTANCE_CAST((obj), MODEM_TYPE_CALL_SERVICE, ModemCallService))
-#define MODEM_CALL_SERVICE_CLASS(klass)                                 \
-  (G_TYPE_CHECK_CLASS_CAST((klass), MODEM_TYPE_CALL_SERVICE, ModemCallServiceClass))
-#define MODEM_IS_CALL_SERVICE(obj)                              \
-  (G_TYPE_CHECK_INSTANCE_TYPE((obj), MODEM_TYPE_CALL_SERVICE))
-#define MODEM_IS_CALL_SERVICE_CLASS(klass)                      \
-  (G_TYPE_CHECK_CLASS_TYPE((klass), MODEM_TYPE_CALL_SERVICE))
-#define MODEM_CALL_SERVICE_GET_CLASS(obj)                               \
-  (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEM_TYPE_CALL_SERVICE, ModemCallServiceClass))
+#define MODEM_TYPE_CALL_SERVICE \
+  (modem_call_service_get_type ())
+#define MODEM_CALL_SERVICE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+      MODEM_TYPE_CALL_SERVICE, ModemCallService))
+#define MODEM_CALL_SERVICE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), \
+      MODEM_TYPE_CALL_SERVICE, ModemCallServiceClass))
+#define MODEM_IS_CALL_SERVICE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
+      MODEM_TYPE_CALL_SERVICE))
+#define MODEM_IS_CALL_SERVICE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEM_TYPE_CALL_SERVICE))
+#define MODEM_CALL_SERVICE_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+      MODEM_TYPE_CALL_SERVICE, \ModemCallServiceClass))
 
 typedef struct _ModemCall ModemCall;
 typedef struct _ModemCallClass ModemCallClass;
@@ -75,58 +81,63 @@ struct _ModemCall {
   ModemCallPrivate *priv;
 };
 
-GType modem_call_get_type(void);
+GType modem_call_get_type (void);
 
 /* TYPE MACROS */
-#define MODEM_TYPE_CALL                         \
-  (modem_call_get_type())
-#define MODEM_CALL(obj)                                                 \
-  (G_TYPE_CHECK_INSTANCE_CAST((obj), MODEM_TYPE_CALL, ModemCall))
-#define MODEM_CALL_CLASS(klass)                                         \
-  (G_TYPE_CHECK_CLASS_CAST((klass), MODEM_TYPE_CALL, ModemCallClass))
-#define MODEM_IS_CALL(obj)                              \
-  (G_TYPE_CHECK_INSTANCE_TYPE((obj), MODEM_TYPE_CALL))
-#define MODEM_IS_CALL_CLASS(klass)                      \
-  (G_TYPE_CHECK_CLASS_TYPE((klass), MODEM_TYPE_CALL))
-#define MODEM_CALL_GET_CLASS(obj)                                       \
+#define MODEM_TYPE_CALL \
+  (modem_call_get_type ())
+#define MODEM_CALL(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEM_TYPE_CALL, ModemCall))
+#define MODEM_CALL_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), MODEM_TYPE_CALL, ModemCallClass))
+#define MODEM_IS_CALL(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEM_TYPE_CALL))
+#define MODEM_IS_CALL_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEM_TYPE_CALL))
+#define MODEM_CALL_GET_CLASS(obj) \
   (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEM_TYPE_CALL, ModemCallClass))
 
-
 typedef struct _ModemCallConference ModemCallConference;
 typedef struct _ModemCallConferenceClass ModemCallConferenceClass;
 typedef struct _ModemCallConferencePrivate ModemCallConferencePrivate;
 
-struct _ModemCallConferenceClass {
+struct _ModemCallConferenceClass
+{
   ModemCallClass parent_class;
 };
 
-struct _ModemCallConference {
+struct _ModemCallConference
+{
   ModemCall parent;
   ModemCallConferencePrivate *priv;
 };
 
-GType modem_call_conference_get_type(void);
+GType modem_call_conference_get_type (void);
 
 /* TYPE MACROS */
-#define MODEM_TYPE_CALL_CONFERENCE              \
-  (modem_call_conference_get_type())
-#define MODEM_CALL_CONFERENCE(obj)                                      \
-  (G_TYPE_CHECK_INSTANCE_CAST((obj), MODEM_TYPE_CALL_CONFERENCE, ModemCallConference))
-#define MODEM_CALL_CONFERENCE_CLASS(klass)                              \
-  (G_TYPE_CHECK_CLASS_CAST((klass), MODEM_TYPE_CALL_CONFERENCE, ModemCallConferenceClass))
-#define MODEM_IS_CALL_CONFERENCE(obj)                                   \
-  (G_TYPE_CHECK_INSTANCE_TYPE((obj), MODEM_TYPE_CALL_CONFERENCE))
-#define MODEM_IS_CALL_CONFERENCE_CLASS(klass)                           \
-  (G_TYPE_CHECK_CLASS_TYPE((klass), MODEM_TYPE_CALL_CONFERENCE))
-#define MODEM_CALL_CONFERENCE_GET_CLASS(obj)                            \
-  (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEM_TYPE_CALL_CONFERENCE, ModemCallConferenceClass))
+#define MODEM_TYPE_CALL_CONFERENCE \
+  (modem_call_conference_get_type ())
+#define MODEM_CALL_CONFERENCE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+      MODEM_TYPE_CALL_CONFERENCE, ModemCallConference))
+#define MODEM_CALL_CONFERENCE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), \
+      MODEM_TYPE_CALL_CONFERENCE, ModemCallConferenceClass))
+#define MODEM_IS_CALL_CONFERENCE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEM_TYPE_CALL_CONFERENCE))
+#define MODEM_IS_CALL_CONFERENCE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEM_TYPE_CALL_CONFERENCE))
+#define MODEM_CALL_CONFERENCE_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+      MODEM_TYPE_CALL_CONFERENCE, ModemCallConferenceClass))
 
 /**
  * Call properties
  */
 
 /** ModemCall state */
-enum _ModemCallState {
+enum _ModemCallState
+{
   MODEM_CALL_STATE_INVALID = 0,
   MODEM_CALL_STATE_DIALING,
   MODEM_CALL_STATE_ALERTING,
@@ -137,7 +148,8 @@ enum _ModemCallState {
   MODEM_CALL_STATE_DISCONNECTED
 };
 
-enum _ModemCallCauseType {
+enum _ModemCallCauseType
+{
   MODEM_CALL_CAUSE_TYPE_UNKNOWN,
   MODEM_CALL_CAUSE_TYPE_NETWORK,
   MODEM_CALL_CAUSE_TYPE_LOCAL,
@@ -145,122 +157,125 @@ enum _ModemCallCauseType {
 };
 
 /** Dial flags */
-enum _ModemClirOverride {
+enum _ModemClirOverride
+{
   MODEM_CLIR_OVERRIDE_DEFAULT = 0,
   MODEM_CLIR_OVERRIDE_ENABLED,
   MODEM_CLIR_OVERRIDE_DISABLED
 };
 
-enum {
+enum
+{
   MODEM_MAX_CALLS = 7
 };
 
-char const *modem_call_get_state_name(int state);
-GError *modem_call_new_error(guint causetype, guint cause, char const *prefixed);
+char const *modem_call_get_state_name (int state);
+GError *modem_call_new_error (guint causetype, guint cause,
+    char const *prefixed);
 
 /* Call service */
-gboolean modem_call_service_connect(ModemCallService *, char const *);
-void modem_call_service_disconnect(ModemCallService *);
-gboolean modem_call_service_is_connected(ModemCallService const *);
-gboolean modem_call_service_is_connecting(ModemCallService const *);
+gboolean modem_call_service_connect (ModemCallService *, char const *);
+void modem_call_service_disconnect (ModemCallService *);
+gboolean modem_call_service_is_connected (ModemCallService const *);
+gboolean modem_call_service_is_connecting (ModemCallService const *);
 
-void modem_call_service_resume(ModemCallService *);
+void modem_call_service_resume (ModemCallService *);
 
 /* Validate addresses */
-gboolean modem_call_is_valid_address(char const *address);
-gboolean modem_call_validate_address(char const *address, GError **error);
+gboolean modem_call_is_valid_address (char const *address);
+gboolean modem_call_validate_address (char const *address, GError **error);
 
-void modem_call_split_address(char const *address,
+void modem_call_split_address (char const *address,
   char **return_address,
   char **return_dialstring,
   ModemClirOverride *return_clir);
 
-int modem_call_event_tone(guint state, guint causetype, guint cause);
+int modem_call_event_tone (guint state, guint causetype, guint cause);
 
-int modem_call_error_tone(GError *);
+int modem_call_error_tone (GError *);
 
-char const * const *modem_call_get_emergency_numbers(ModemCallService *self);
-char const *modem_call_get_valid_emergency_urn(char const *urn);
-char const *modem_call_get_emergency_service(ModemCallService*, char const*);
+char const * const *modem_call_get_emergency_numbers (ModemCallService *self);
+char const *modem_call_get_valid_emergency_urn (char const *urn);
+char const *modem_call_get_emergency_service (ModemCallService*, char const*);
 
-typedef void ModemCallServiceReply(ModemCallService *,
+typedef void ModemCallServiceReply (ModemCallService *,
   ModemRequest *,
   GError *error,
   gpointer user_data);
 
-ModemCall *modem_call_service_get_call(ModemCallService *, char const *);
-ModemCall **modem_call_service_get_calls(ModemCallService *);
-ModemCallConference *modem_call_service_get_conference(ModemCallService *);
+ModemCall *modem_call_service_get_call (ModemCallService *, char const *);
+ModemCall **modem_call_service_get_calls (ModemCallService *);
+ModemCallConference *modem_call_service_get_conference (ModemCallService *);
 
-typedef void ModemCallRequestDialReply(ModemCallService *,
+typedef void ModemCallRequestDialReply (ModemCallService *,
   ModemRequest *,
   ModemCall *,
   GError *error,
   gpointer user_data);
 
-ModemRequest *modem_call_request_dial(ModemCallService *self,
+ModemRequest *modem_call_request_dial (ModemCallService *self,
   char const *destination,
   ModemClirOverride clir,
   ModemCallRequestDialReply *callback,
   gpointer user_data);
 
-ModemRequest *modem_call_request_conference(ModemCallService *,
+ModemRequest *modem_call_request_conference (ModemCallService *,
   ModemCallServiceReply *callback,
   gpointer user_data);
 
 /* ModemCall service */
-void modem_call_connect(ModemCall *);
-void modem_call_disconnect(ModemCall *);
+void modem_call_connect (ModemCall *);
+void modem_call_disconnect (ModemCall *);
 
-char const *modem_call_get_name(ModemCall const *);
-char const *modem_call_get_path(ModemCall const *);
-gboolean modem_call_has_path(ModemCall const *, char const *object_path);
+char const *modem_call_get_name (ModemCall const *);
+char const *modem_call_get_path (ModemCall const *);
+gboolean modem_call_has_path (ModemCall const *, char const *object_path);
 
-ModemCallState modem_call_get_state(ModemCall const *);
-ModemCallState modem_call_state_from_ofono_state(char const *state);
+ModemCallState modem_call_get_state (ModemCall const *);
+ModemCallState modem_call_state_from_ofono_state (char const *state);
 
-gboolean modem_call_try_set_handler(ModemCall *, gpointer);
-void modem_call_set_handler(ModemCall *, gpointer);
-gpointer modem_call_get_handler(ModemCall *);
+gboolean modem_call_try_set_handler (ModemCall *, gpointer);
+void modem_call_set_handler (ModemCall *, gpointer);
+gpointer modem_call_get_handler (ModemCall *);
 
-gboolean modem_call_is_member(ModemCall const *);
-gboolean modem_call_is_originating(ModemCall const *);
-gboolean modem_call_is_terminating(ModemCall const *);
+gboolean modem_call_is_member (ModemCall const *);
+gboolean modem_call_is_originating (ModemCall const *);
+gboolean modem_call_is_terminating (ModemCall const *);
 
-gboolean modem_call_is_active(ModemCall const *);
-gboolean modem_call_is_held(ModemCall const *);
+gboolean modem_call_is_active (ModemCall const *);
+gboolean modem_call_is_held (ModemCall const *);
 
-typedef void ModemCallReply(ModemCall *,
+typedef void ModemCallReply (ModemCall *,
   ModemRequest *,
   GError *,
   gpointer user_data);
 
-ModemRequest *modem_call_request_answer(ModemCall*,
+ModemRequest *modem_call_request_answer (ModemCall*,
   ModemCallReply *,
   gpointer user_data);
-ModemRequest *modem_call_request_release(ModemCall*,
+ModemRequest *modem_call_request_release (ModemCall*,
   ModemCallReply *,
   gpointer user_data);
 
-ModemRequest *modem_call_send_dtmf(ModemCall *self,
+ModemRequest *modem_call_send_dtmf (ModemCall *self,
   char const *dialstring,
   ModemCallReply *callback,
   gpointer user_data);
-ModemRequest *modem_call_start_dtmf(ModemCall *self,
+ModemRequest *modem_call_start_dtmf (ModemCall *self,
   char tone,
   ModemCallReply *callback,
   gpointer user_data);
-ModemRequest *modem_call_stop_dtmf(ModemCall *self,
+ModemRequest *modem_call_stop_dtmf (ModemCall *self,
   ModemCallReply *callback,
   gpointer user_data);
 
-gboolean modem_call_can_join(ModemCall const *);
+gboolean modem_call_can_join (ModemCall const *);
 
-ModemRequest *modem_call_request_hold(ModemCall *, int hold,
+ModemRequest *modem_call_request_hold (ModemCall *, int hold,
   ModemCallReply *,
   gpointer user_data);
 
-ModemRequest *modem_call_request_split(ModemCall *,
+ModemRequest *modem_call_request_split (ModemCall *,
   ModemCallReply *,
   gpointer user_data);