gboolean
cpufreq_selector_service_register (CPUFreqSelectorService *service,
				   GError                **error)
{
	DBusGConnection *connection;
	DBusGProxy      *bus_proxy;
	gboolean         res;
	guint            result;
	GError          *err = NULL;

	if (service->system_bus) {
		g_set_error (error,
			     CPUFREQ_SELECTOR_SERVICE_ERROR,
			     SERVICE_ERROR_ALREADY_REGISTERED,
			     "Service %s already registered", BUS_NAME);
		return FALSE;
	}

	connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &err);
	if (!connection) {
		g_set_error (error,
			     CPUFREQ_SELECTOR_SERVICE_ERROR,
			     SERVICE_ERROR_DBUS,
			     "Couldn't connect to system bus: %s",
			     err->message);
		g_error_free (err);

		return FALSE;
	}

	bus_proxy = dbus_g_proxy_new_for_name (connection,
					       DBUS_SERVICE_DBUS,
					       DBUS_PATH_DBUS,
					       DBUS_INTERFACE_DBUS);
	if (!bus_proxy) {
		g_set_error (error,
			     CPUFREQ_SELECTOR_SERVICE_ERROR,
			     SERVICE_ERROR_DBUS,
			     "Could not construct bus_proxy object");
		return FALSE;
	}

	res = dbus_g_proxy_call (bus_proxy,
				 "RequestName",
				 &err,
				 G_TYPE_STRING, BUS_NAME,
				 G_TYPE_UINT, DBUS_NAME_FLAG_DO_NOT_QUEUE,
				 G_TYPE_INVALID,
				 G_TYPE_UINT, &result,
				 G_TYPE_INVALID);
	g_object_unref (bus_proxy);
	
	if (!res) {
		if (err) {
			g_set_error (error,
				     CPUFREQ_SELECTOR_SERVICE_ERROR,
				     SERVICE_ERROR_DBUS,
				     "Failed to acquire %s: %s",
				     BUS_NAME, err->message);
			g_error_free (err);
		} else {
			g_set_error (error,
				     CPUFREQ_SELECTOR_SERVICE_ERROR,
				     SERVICE_ERROR_DBUS,
				     "Failed to acquire %s", BUS_NAME);
		}

		return FALSE;
	}

	if (result == DBUS_REQUEST_NAME_REPLY_EXISTS) {
		g_set_error (error,
			     CPUFREQ_SELECTOR_SERVICE_ERROR,
			     SERVICE_ERROR_ALREADY_REGISTERED,
			     "Service %s already registered", BUS_NAME);
		return FALSE;
	}

	service->authority = polkit_authority_get ();

	service->system_bus = connection;

	dbus_g_object_type_install_info (CPUFREQ_TYPE_SELECTOR_SERVICE,
					 &dbus_glib_cpufreq_selector_service_object_info);
	dbus_g_connection_register_g_object (connection,
					     "/org/gnome/cpufreq_selector/selector",
					     G_OBJECT (service));
	dbus_g_error_domain_register (CPUFREQ_SELECTOR_SERVICE_ERROR, NULL,
				      CPUFREQ_TYPE_SELECTOR_SERVICE_ERROR);

	reset_killtimer ();

	return TRUE;
}

static gboolean
gsm_consolekit_ensure_ck_connection (GsmConsolekit  *manager,
                                     GError        **error)
{
        GError  *connection_error;
        gboolean is_connected;

        connection_error = NULL;

        if (manager->priv->dbus_connection == NULL) {
                DBusConnection *connection;

                manager->priv->dbus_connection = dbus_g_bus_get (DBUS_BUS_SYSTEM,
                                                                 &connection_error);

                if (manager->priv->dbus_connection == NULL) {
                        g_propagate_error (error, connection_error);
                        is_connected = FALSE;
                        goto out;
                }

                connection = dbus_g_connection_get_connection (manager->priv->dbus_connection);
                dbus_connection_set_exit_on_disconnect (connection, FALSE);
                dbus_connection_add_filter (connection,
                                            gsm_consolekit_dbus_filter,
                                            manager, NULL);
        }

        if (manager->priv->bus_proxy == NULL) {
                manager->priv->bus_proxy =
                        dbus_g_proxy_new_for_name_owner (manager->priv->dbus_connection,
                                                         DBUS_SERVICE_DBUS,
                                                         DBUS_PATH_DBUS,
                                                         DBUS_INTERFACE_DBUS,
                                                         &connection_error);

                if (manager->priv->bus_proxy == NULL) {
                        g_propagate_error (error, connection_error);
                        is_connected = FALSE;
                        goto out;
                }

                dbus_g_proxy_add_signal (manager->priv->bus_proxy,
                                         "NameOwnerChanged",
                                         G_TYPE_STRING,
                                         G_TYPE_STRING,
                                         G_TYPE_STRING,
                                         G_TYPE_INVALID);

                dbus_g_proxy_connect_signal (manager->priv->bus_proxy,
                                             "NameOwnerChanged",
                                             G_CALLBACK (gsm_consolekit_on_name_owner_changed),
                                             manager, NULL);
        }

        if (manager->priv->ck_proxy == NULL) {
                manager->priv->ck_proxy =
                        dbus_g_proxy_new_for_name_owner (manager->priv->dbus_connection,
                                                         "org.freedesktop.ConsoleKit",
                                                         "/org/freedesktop/ConsoleKit/Manager",
                                                         "org.freedesktop.ConsoleKit.Manager",
                                                         &connection_error);

                if (manager->priv->ck_proxy == NULL) {
                        g_propagate_error (error, connection_error);
                        is_connected = FALSE;
                        goto out;
                }
        }

        is_connected = TRUE;

 out:
        if (manager->priv->is_connected != is_connected) {
                manager->priv->is_connected = is_connected;
                g_object_notify (G_OBJECT (manager), "is-connected");
        }

        if (!is_connected) {
                if (manager->priv->dbus_connection == NULL) {
                        if (manager->priv->bus_proxy != NULL) {
                                g_object_unref (manager->priv->bus_proxy);
                                manager->priv->bus_proxy = NULL;
                        }

                        if (manager->priv->ck_proxy != NULL) {
                                g_object_unref (manager->priv->ck_proxy);
                                manager->priv->ck_proxy = NULL;
                        }
                } else if (manager->priv->bus_proxy == NULL) {
                        if (manager->priv->ck_proxy != NULL) {
                                g_object_unref (manager->priv->ck_proxy);
                                manager->priv->ck_proxy = NULL;
                        }
                }
        }

        return is_connected;
}

int
main (int argc, char **argv)
{
  DBusGConnection *connection;
  GError *error;
  DBusGProxy *driver_proxy;
  guint32 request_name_ret;

  g_type_init ();
  dbus_g_thread_init ();

  dbus_g_error_domain_register (MY_OBJECT_ERROR,
				NULL,
				MY_TYPE_ERROR);

  g_printerr ("Launching test-service-glib\n");

  loop = g_main_loop_new (NULL, FALSE);

  {
    GLogLevelFlags fatal_mask;
    
    fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
    fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
    g_log_set_always_fatal (fatal_mask);
  }

  error = NULL;
  connection = dbus_g_bus_get (DBUS_BUS_STARTER,
                               &error);
  if (connection == NULL)
    {
      g_printerr ("Failed to open connection to bus: %s\n",
                  error->message);
      g_error_free (error);
      exit (1);
    }

  obj = g_object_new (MY_TYPE_OBJECT, NULL);
  obj2 = g_object_new (MY_TYPE_OBJECT, NULL);
  subobj = g_object_new (MY_TYPE_OBJECT_SUBCLASS, NULL);

  dbus_g_connection_register_g_object (connection,
                                       "/org/freedesktop/DBus/GLib/Tests/MyTestObject",
                                       obj);
  /* Register a second time; we want the object to also be reachable through this interface */
  dbus_g_connection_register_g_object (connection,
                                       "/org/freedesktop/DBus/GLib/Tests/Compat/MyTestObjectCompat",
                                       obj);
  dbus_g_connection_register_g_object (connection,
                                       "/org/freedesktop/DBus/GLib/Tests/MyTestObject2",
                                       obj2);

  dbus_g_connection_register_g_object (connection,
                                       "/org/freedesktop/DBus/GLib/Tests/MyTestObjectSubclass",
                                       subobj);

  driver_proxy = dbus_g_proxy_new_for_name (connection,
                                            DBUS_SERVICE_DBUS,
                                            DBUS_PATH_DBUS,
                                            DBUS_INTERFACE_DBUS);

  if (!org_freedesktop_DBus_request_name (driver_proxy,
					  TEST_SERVICE_NAME,
					  0, &request_name_ret, &error))
    {
      g_assert (error != NULL);
      g_printerr ("Failed to get name: %s\n",
		  error->message);
      g_clear_error (&error);
      exit (1);
    }

  if (!(request_name_ret == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER))
    {
      g_printerr ("Got result code %u from requesting name\n", request_name_ret);
      exit (1);
    }

  g_printerr ("GLib test service has name '%s'\n", TEST_SERVICE_NAME);
  g_printerr ("GLib test service entering main loop\n");

  g_main_loop_run (loop);
  
  g_printerr ("Successfully completed %s\n", argv[0]);
  
  return 0;
}

int
main (int    argc,
      char **argv)
{
  DBusGConnection *connection;
  DBusGProxy *proxy;
  GError *error = NULL;
  gchar *str;
  gboolean success;
  DBusGProxy *dp_proxy;

  g_type_init ();

  connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
  if (connection == NULL)
    {
      g_error ("Failed to make connection to session bus: %s", error->message);
      g_error_free (error);
      exit(1);
    }

  proxy = dbus_g_proxy_new_for_name (connection, TEST_NAMESPACE, TEST_OBJECT_PATH,
                                     "org.freedesktop.DBus.GLib.Test.Interfaces.Song");
  success = org_freedesktop_DBus_GLib_Test_Interfaces_Song_get_title (proxy, &str, &error);
  g_object_unref (proxy);

  if (!success)
    {
      g_print ("Error while calling Parent object method: %s\n", error->message);
      g_error_free (error);
      exit(1);
    }
  else
    {
      g_free (str);
      g_print ("Called Parent object method with success\n");
    }

  proxy = dbus_g_proxy_new_for_name (connection, TEST_NAMESPACE, TEST_OBJECT_PATH,
                                     "org.freedesktop.DBus.GLib.Test.Interfaces.Hello");
  g_assert (proxy != NULL);
  success = org_freedesktop_DBus_GLib_Test_Interfaces_Hello_say_hello (proxy, &str, &error);
  g_object_unref (proxy);

  if (!success)
    {
      g_print ("Error while calling Parent Interface object method: %s\n", error->message);
      g_error_free (error);
      exit(1);
    }
  else
    {
      g_free (str);
      g_print ("Called Parent Interface object method with success\n");
    }

  proxy = dbus_g_proxy_new_for_name (connection, TEST_NAMESPACE, TEST_OBJECT_PATH,
                                     "org.freedesktop.DBus.GLib.Test.Interfaces.Goodbye");
  success = org_freedesktop_DBus_GLib_Test_Interfaces_Goodbye_say_goodbye (proxy, &str, &error);
  g_object_unref (proxy);

  if (!success)
    {
      g_print ("Error while calling Object Interface object method: %s\n", error->message);
      g_error_free (error);
      exit(1);
    }
  else
    {
      g_free (str);
      g_print ("Called Object Interface object method with success\n");
    }

  /* Test interfaces with conflicting property names on the same GObject */
  dp_proxy = dbus_g_proxy_new_for_name (connection, TEST_NAMESPACE, TEST_DP_OBJECT_PATH,
                                        "org.freedesktop.DBus.Properties");

  /* test that setting the property and reading it back works */
  test_dp_property (dp_proxy, "A", TEST_DP_IFACE_A, 235235, FALSE);
  test_dp_property (dp_proxy, "B", TEST_DP_IFACE_B, 11981241, FALSE);

  /* Test that setting A does not change B */
  test_dp_property (dp_proxy, "B", TEST_DP_IFACE_B, 11981241, FALSE);
  test_dp_property (dp_proxy, "A", TEST_DP_IFACE_A, 235235, FALSE);
  test_dp_property (dp_proxy, "B", TEST_DP_IFACE_B, 11981241, TRUE);

  /* And test that setting B does not change A */
  test_dp_property (dp_proxy, "A", TEST_DP_IFACE_A, 235235, FALSE);
  test_dp_property (dp_proxy, "B", TEST_DP_IFACE_B, 11981241, FALSE);
  test_dp_property (dp_proxy, "A", TEST_DP_IFACE_A, 235235, TRUE);

  g_object_unref (dp_proxy);

  /* Ensure the properties are introspectable */
  dp_proxy = dbus_g_proxy_new_for_name (connection, TEST_NAMESPACE, TEST_DP_OBJECT_PATH,
                                        "org.freedesktop.DBus.Introspectable");

  g_print ("Testing duplicate property name introspection\n");
  if (!dbus_g_proxy_call (dp_proxy, "Introspect", &error,
                          G_TYPE_INVALID,
//.........这里部分代码省略.........

static void
on_sms_clicked (GtkWidget *button, MokoHistory *history)
{
  DBusGConnection *conn;
  DBusGProxy *proxy;
  GError *err = NULL;
  MokoHistoryPrivate *priv;
  GtkTreeSelection *selection;
  GtkTreeView *treeview;
  GtkTreeIter iter;
  GtkTreeModel *model;
  gchar *number;
  guint transaction;

  g_debug ("sms clicked");

  g_return_if_fail (MOKO_IS_HISTORY (history));
  priv = history->priv;

  treeview = GTK_TREE_VIEW (priv->treeview);
  selection = gtk_tree_view_get_selection (treeview);
  model = gtk_tree_view_get_model (treeview);

  if (!gtk_tree_selection_get_selected (selection, &model, &iter))
    return;

  gtk_tree_model_get (model, &iter, NUMBER_COLUMN, &number, -1);

  g_debug ("send SMS to number: %s", number);

  conn = dbus_g_bus_get (DBUS_BUS_SESSION, &err);
  if (conn == NULL)
  {
    g_warning ("Failed to make DBus connection: %s", err->message);
    g_error_free (err);
    return;
  }

  proxy = dbus_g_proxy_new_for_name (conn,
                                     SMS_NAMESPACE,
                                     SMS_OBJECT,
                                     SMS_NAMESPACE);
  if (proxy == NULL)
  {
    g_warning ("Unable to get openmoko-messages2 object");
    return;
  }

  err = NULL;
  dbus_g_proxy_call (proxy, "SendMessage", &err,
                     G_TYPE_STRING, NULL, G_TYPE_STRING, number,
                     G_TYPE_STRING, NULL,
                     G_TYPE_INVALID, G_TYPE_UINT, &transaction, G_TYPE_INVALID);

  if (err)
  {
    g_warning (err->message);
    g_error_free (err);
  } else {
    g_debug ( "sms: transaction %u started\n", transaction);
  }
}

int
main (int argc, char **argv)
{
	GOptionContext *context;
	gboolean ok;
	GError *error = NULL;
	DBusGConnection *bus;
	DBusGProxy *shell_proxy = NULL;
	DBusGProxy *player_proxy = NULL;
	gboolean is_playing;

#ifdef ENABLE_NLS
	/* initialize i18n */
	bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
	textdomain (GETTEXT_PACKAGE);
#endif
	/* setup */
	setlocale (LC_ALL, "");
	g_type_init ();
	g_set_prgname ("rhythmbox-client");

	/* parse arguments */
	context = g_option_context_new (NULL);
	g_option_context_add_main_entries (context, args, NULL);
	ok = g_option_context_parse (context, &argc, &argv, &error);
	if (annoy (&error))
		exit (1);

	rb_debug_init (debug);

	/* get dbus connection and proxy for rhythmbox shell */
	bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
	if (annoy (&error))
		exit (1);

	if (!create_rb_shell_proxies (bus, &shell_proxy, &player_proxy, &error)) {
		annoy (&error);
		exit (1);
	}
	g_clear_error (&error);

	/* 1. activate or quit */
	if (quit) {
		if (shell_proxy) {
			rb_debug ("quitting existing instance");
			dbus_g_proxy_call_no_reply (shell_proxy, "quit", G_TYPE_INVALID);
		} else {
			rb_debug ("no existing instance to quit");
		}

		exit (0);
	}
	if (shell_proxy == NULL) {
		DBusGProxy *bus_proxy;
		guint start_service_reply;

		if (no_start) {
			rb_debug ("no existing instance, and can't start one");
			exit (0);
		}

		rb_debug ("starting new instance");
		bus_proxy = dbus_g_proxy_new_for_name (bus,
						       "org.freedesktop.DBus",
						       "/org/freedesktop/DBus",
						       "org.freedesktop.DBus");

		if (!dbus_g_proxy_call (bus_proxy, "StartServiceByName", &error,
					G_TYPE_STRING, "org.gnome.Rhythmbox",
					G_TYPE_UINT, 0,
					G_TYPE_INVALID,
					G_TYPE_UINT, &start_service_reply,
					G_TYPE_INVALID)) {
			g_warning ("%s", error->message);
			exit (1);
		}

		/* hopefully we can get a proxy for the rb shell now.. */
		if (!create_rb_shell_proxies (bus, &shell_proxy, &player_proxy, &error)) {
			annoy (&error);
			exit (1);
		}
		g_clear_error (&error);
	}

	/* don't present if we're doing something else */
	if (next || previous ||
	    clear_queue ||
	    play_uri || other_stuff ||
	    play || pause || play_pause || stop ||
	    print_playing || print_playing_format || notify ||
	    (set_volume > -0.01) || volume_up || volume_down || print_volume || mute || unmute)
		no_present = TRUE;

	/* 2. present or hide */
	if (hide || !no_present) {
		DBusGProxy *properties_proxy;
		GValue value = {0,};

//.........这里部分代码省略.........

static HRESULT
get_connection_from_udev_or_odccm(SynceInfo *info, int *sockfd)
{
  GError *error = NULL;
  DBusGConnection *bus = NULL;
  DBusGProxy *dbus_proxy = NULL;
  DBusGProxy *dev_proxy = NULL;
  gboolean dccm_running = FALSE;
  gchar *unix_path = NULL;
  gint fd = -1;
  const gchar *service = NULL;
  const gchar *dev_iface = NULL;
  const gchar *dccm_name = NULL;
  HRESULT result = E_FAIL;

  /* Ensure that e.g. SYNCE_DCCM_ERROR is registered using g_dbus_error_register_error() */
  synce_glib_init();

#if ENABLE_ODCCM_SUPPORT
  const gchar *transport = synce_info_get_transport(info);
  if (strcmp(transport, "odccm") == 0) {
    service = ODCCM_SERVICE;
    dev_iface = ODCCM_DEV_IFACE;
    dccm_name = "odccm";
  } else 
#endif
  {
    service = DCCM_SERVICE;
    dev_iface = DCCM_DEV_IFACE;
    dccm_name = "dccm";
  }

#if !GLIB_CHECK_VERSION (2, 36, 0)
  g_type_init();
#endif

  bus = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
  if (bus == NULL)
  {
    synce_warning("%s: Failed to connect to system bus: %s", G_STRFUNC, error->message);
    goto ERROR;
  }

  dbus_proxy = dbus_g_proxy_new_for_name (bus,
                                          DBUS_SERVICE,
                                          DBUS_PATH,
                                          DBUS_IFACE);
  if (dbus_proxy == NULL) {
    synce_warning("%s: Failed to get dbus proxy object", G_STRFUNC);
    goto ERROR;
  }

  if (!(dbus_g_proxy_call(dbus_proxy, "NameHasOwner",
                          &error,
                          G_TYPE_STRING, service,
                          G_TYPE_INVALID,
                          G_TYPE_BOOLEAN, &dccm_running,
                          G_TYPE_INVALID))) {
    synce_warning("%s: Error checking owner of service %s: %s", G_STRFUNC, service, error->message);
    g_object_unref(dbus_proxy);
    goto ERROR;
  }

  g_object_unref(dbus_proxy);
  if (!dccm_running) {
    synce_info("%s is not running, ignoring", dccm_name);
    goto ERROR;
  }

  dev_proxy = dbus_g_proxy_new_for_name(bus, service,
                                        synce_info_get_object_path(info),
                                        dev_iface);
  if (dev_proxy == NULL) {
    synce_warning("%s: Failed to get proxy for device '%s'", G_STRFUNC, synce_info_get_object_path(info));
    goto ERROR;
  }

  if (!dbus_g_proxy_call(dev_proxy, "RequestConnection", &error,
                         G_TYPE_INVALID,
                         G_TYPE_STRING, &unix_path,
                         G_TYPE_INVALID))
  {
    synce_warning("%s: Failed to get a connection for %s: %s", G_STRFUNC, synce_info_get_name(info), error->message);

    /* INVALID_PASSWORD isn't perfect, but seems to be the best we have */
    if (dbus_g_error_has_name(error, "org.synce.dccm.Error.DeviceLocked"))
      result = HRESULT_FROM_WIN32(ERROR_INVALID_PASSWORD);

    g_object_unref(dev_proxy);
    goto ERROR;
  }

  g_object_unref(dev_proxy);

  fd = get_socket_from_dccm(unix_path);
  g_free(unix_path);

  if (fd < 0)
  {
    synce_warning("%s: Failed to get file-descriptor from %s for %s", G_STRFUNC, dccm_name, synce_info_get_name(info));
//.........这里部分代码省略.........

/**
 * gpm_session_init:
 * @session: This class instance
 **/
static void
gpm_session_init (GpmSession *session)
{
	DBusGConnection *connection;
	GError *error = NULL;

	session->priv = GPM_SESSION_GET_PRIVATE (session);
	session->priv->is_idle_old = FALSE;
	session->priv->is_idle_inhibited_old = FALSE;
	session->priv->is_suspend_inhibited_old = FALSE;
	session->priv->proxy_client_private = NULL;

	connection = dbus_g_bus_get (DBUS_BUS_SESSION, NULL);

	/* get org.mate.Session interface */
	session->priv->proxy = dbus_g_proxy_new_for_name_owner (connection, GPM_SESSION_MANAGER_SERVICE,
								GPM_SESSION_MANAGER_PATH,
								GPM_SESSION_MANAGER_INTERFACE, &error);
	if (session->priv->proxy == NULL) {
		egg_warning ("DBUS error: %s", error->message);
		g_error_free (error);
		return;
	}

	/* get org.mate.Session.Presence interface */
	session->priv->proxy_presence = dbus_g_proxy_new_for_name_owner (connection, GPM_SESSION_MANAGER_SERVICE,
									 GPM_SESSION_MANAGER_PRESENCE_PATH,
									 GPM_SESSION_MANAGER_PRESENCE_INTERFACE, &error);
	if (session->priv->proxy_presence == NULL) {
		egg_warning ("DBUS error: %s", error->message);
		g_error_free (error);
		return;
	}

	/* get properties interface */
	session->priv->proxy_prop = dbus_g_proxy_new_for_name_owner (connection, GPM_SESSION_MANAGER_SERVICE,
								     GPM_SESSION_MANAGER_PRESENCE_PATH,
								     GPM_DBUS_PROPERTIES_INTERFACE, &error);
	if (session->priv->proxy_prop == NULL) {
		egg_warning ("DBUS error: %s", error->message);
		g_error_free (error);
		return;
	}

	/* get StatusChanged */
	dbus_g_proxy_add_signal (session->priv->proxy_presence, "StatusChanged", G_TYPE_UINT, G_TYPE_INVALID);
	dbus_g_proxy_connect_signal (session->priv->proxy_presence, "StatusChanged", G_CALLBACK (gpm_session_presence_status_changed_cb), session, NULL);

	/* get InhibitorAdded */
	dbus_g_proxy_add_signal (session->priv->proxy, "InhibitorAdded", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
	dbus_g_proxy_connect_signal (session->priv->proxy, "InhibitorAdded", G_CALLBACK (gpm_session_inhibit_changed_cb), session, NULL);

	/* get InhibitorRemoved */
	dbus_g_proxy_add_signal (session->priv->proxy, "InhibitorRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
	dbus_g_proxy_connect_signal (session->priv->proxy, "InhibitorRemoved", G_CALLBACK (gpm_session_inhibit_changed_cb), session, NULL);

	/* coldplug */
	session->priv->is_idle_inhibited_old = gpm_session_is_idle_inhibited (session);
	session->priv->is_suspend_inhibited_old = gpm_session_is_suspend_inhibited (session);
	session->priv->is_idle_old = gpm_session_is_idle (session);
	egg_debug ("idle: %i, idle_inhibited: %i, suspend_inhibited: %i", session->priv->is_idle_old, session->priv->is_idle_inhibited_old, session->priv->is_suspend_inhibited_old);
}

static gboolean
nm_openssh_send_ip4_config (sshtun_handle_t handle)
{
	DBusGConnection *connection;
	GError *err = NULL;
	GHashTable *config;
	GValue *val;
	struct in_addr temp_addr;
	const char *tmp;

	connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &err);
	if (!connection)
		return FALSE;

	config = g_hash_table_new (g_str_hash, g_str_equal);

	/* Gateway */
	val = addr_to_gvalue (sshtun_get_param (handle, SSHTUN_PARAM_GW_ADDR));
	if (val)
		g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_GATEWAY, val);
	else {
		helper_failed (connection, "VPN Gateway");
		dbus_g_connection_unref (connection);
		return FALSE;
	}

	/* Tunnel device */
	val = str_to_gvalue (sshtun_get_param (handle, SSHTUN_PARAM_TUN_DEV),
						 FALSE);
	if (val)
		g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_TUNDEV, val);
	else {
		helper_failed (connection, "Tunnel Device");
		dbus_g_connection_unref (connection);
		return FALSE;
	}

	/* IP address */
	val = addr_to_gvalue (sshtun_get_param (handle, SSHTUN_PARAM_ADDR));
	if (val)
		g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_ADDRESS, val);
	else {
		helper_failed (connection, "IP4 Address");
		dbus_g_connection_unref (connection);
		return FALSE;
	}

	/* PTP address */
	val = addr_to_gvalue (sshtun_get_param (handle, SSHTUN_PARAM_PEER_ADDR));
	if (val)
		g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_PTP, val);

	/* Netmask */
	tmp = sshtun_get_param (handle, SSHTUN_PARAM_NETMASK);
	if (tmp && inet_pton (AF_INET, tmp, &temp_addr) > 0) {
		val = uint_to_gvalue (nm_utils_ip4_netmask_to_prefix (temp_addr.s_addr));
		g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_PREFIX, val);
	}

	/* MTU */
	tmp = sshtun_get_param (handle, SSHTUN_PARAM_MTU);
	if (tmp && strlen (tmp)) {
		long int mtu;

		errno = 0;
		mtu = strtol (tmp, NULL, 10);
		if (errno || mtu < 0 || mtu > 20000) {
			nm_warning ("Ignoring invalid tunnel MTU '%s'", tmp);
		} else {
			val = uint_to_gvalue ((guint32) mtu);
			g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_MTU, val);
		}
	}

	send_ip4_config (connection, config);
	dbus_g_connection_unref (connection);

	return TRUE;
}

NMCResultCode
do_add (NmCli *nmc, int argc, char **argv)
{
	DBusGConnection *bus;
	DBusGProxy *proxy;

	GError *err = NULL;
	
	int i;
	
	char *apn = NULL;
	char *pin = NULL;
	char *username = NULL;
	char *password = NULL;
	char *number = NULL; 
	char *ntype = NULL;
	char *auth = NULL;
	char *comp = NULL;
	char *aut = NULL;
	char *netid = NULL;
	char *enc = NULL;
	char *echofail = NULL;
	char *echoint = NULL;
	char *uuid = NULL;
	char *sbits = NULL;
	char *stbits = NULL;
	char *sparity = NULL;
	char *sbaud = NULL;
	
	if ((*argv == NULL) || strcmp(argv[0],"help") == 0 || strcmp(argv[0],"-help") == 0){
		usage_add();
	}
		
	else{
		if (!nmc_is_nm_running (nmc, &err)) {
			if (err) {
				g_string_printf (nmc->return_text, _("Error: Can't find out if NetworkManager is running: %s."), err->message);
				nmc->return_value = NMC_RESULT_ERROR_UNKNOWN;
				g_error_free (err);
				return nmc->return_value;
			} else {
				g_string_printf (nmc->return_text, _("Error: NetworkManager is not running."));
				nmc->return_value = NMC_RESULT_ERROR_NM_NOT_RUNNING;
				return nmc->return_value;
			}
		}

		if (matches(argv[0],"id") != 0){
			g_string_printf (nmc->return_text, _("Error: id has to be specified."));
			nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
			return nmc->return_value;
		}
		else if (matches(argv[0],"id") == 0){
			if(argc == 1){
				g_string_printf (nmc->return_text, _("Error: argument missing for parameter id."));	
				nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
				return nmc->return_value;
			}
			else if (argc % 2!=0){
				g_string_printf (nmc->return_text, _("Error: Some arguments are missing."));
				nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
				return nmc->return_value;
			}
		}
		
		
		for (i=0; i<argc; i=i+2){
			
			(matches(argv[i], "apn") == 0) ? apn = argv[i + 1] : NOT_SET;	
			(matches(argv[i], "pin") == 0) ? pin = argv[i + 1] : NOT_SET;
			(matches(argv[i], "username") == 0) ? username = argv[i + 1] : NOT_SET;
			(matches(argv[i], "password") == 0) ? password = argv[i + 1] : NOT_SET;
			(matches(argv[i], "ntype") == 0) ? ntype = argv[i + 1] : NOT_SET;
			(matches(argv[i], "number") == 0) ? number = argv[i + 1] : NOT_SET;
			(matches(argv[i], "auth") == 0) ? auth = argv[i + 1] : NOT_SET;
			(matches(argv[i], "comp") == 0) ? comp = argv[i + 1] : NOT_SET;
			(matches(argv[i], "auto") == 0) ? aut = argv[i + 1] : NOT_SET;
			(matches(argv[i], "netid") == 0) ? netid = argv[i + 1] : NOT_SET;
			(matches(argv[i], "enc") == 0) ? enc = argv[i + 1] : NOT_SET;
			(matches(argv[i], "echoint") == 0) ? echoint = argv[i + 1] : NOT_SET;
			(matches(argv[i], "echofail") == 0) ? echofail = argv[i + 1] : NOT_SET; 
			(matches(argv[i], "uuid") == 0) ? uuid = argv[i + 1] : NOT_SET;
			(matches(argv[i], "sbits") == 0) ? sbits = argv[i + 1] : NOT_SET;
			(matches(argv[i], "sparity") == 0) ? sparity = argv[i + 1] : NOT_SET;
			(matches(argv[i], "stbits") == 0) ? stbits = argv[i + 1] : NOT_SET;
			(matches(argv[i], "sbaud") == 0) ? sbaud = argv[i + 1] : NOT_SET;
			
		}
		
			
		g_type_init ();

		bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, NULL);

		proxy = dbus_g_proxy_new_for_name (bus,
					       NM_DBUS_SERVICE,
	                                       NM_DBUS_PATH_SETTINGS,
	                                       NM_DBUS_IFACE_SETTINGS);
	                                   

//.........这里部分代码省略.........

static gboolean
panel_power_manager_ensure_gpm_connection (PanelPowerManager  *manager,
					   GError            **error)
{
	GError   *connection_error;
	gboolean  is_connected;

	connection_error = NULL;
	if (manager->priv->dbus_connection == NULL) {
		manager->priv->dbus_connection = dbus_g_bus_get (DBUS_BUS_SESSION,
								 &connection_error);

		if (manager->priv->dbus_connection == NULL) {
			g_propagate_error (error, connection_error);
			is_connected = FALSE;
			goto out;
		}
	}

	if (manager->priv->bus_proxy == NULL) {
		manager->priv->bus_proxy =
			dbus_g_proxy_new_for_name_owner (manager->priv->dbus_connection,
							 DBUS_SERVICE_DBUS,
							 DBUS_PATH_DBUS,
							 DBUS_INTERFACE_DBUS,
							 &connection_error);

		if (manager->priv->bus_proxy == NULL) {
			g_propagate_error (error, connection_error);
			is_connected = FALSE;
			goto out;
		}

		dbus_g_proxy_add_signal (manager->priv->bus_proxy,
					 "NameOwnerChanged",
					 G_TYPE_STRING,
					 G_TYPE_STRING,
					 G_TYPE_STRING,
					 G_TYPE_INVALID);
		dbus_g_proxy_connect_signal (manager->priv->bus_proxy,
					     "NameOwnerChanged",
					     G_CALLBACK (panel_power_manager_on_name_owner_changed),
					     manager, NULL);
	}

	if (manager->priv->gpm_proxy == NULL) {
		manager->priv->gpm_proxy =
			dbus_g_proxy_new_for_name_owner (
					manager->priv->dbus_connection,
					"org.gnome.PowerManager",
					"/org/gnome/PowerManager",
					"org.gnome.PowerManager",
					&connection_error);

		if (manager->priv->gpm_proxy == NULL) {
			g_propagate_error (error, connection_error);
			is_connected = FALSE;
			goto out;
		}
	}
	is_connected = TRUE;

out:
	if (manager->priv->is_connected != is_connected) {
		manager->priv->is_connected = is_connected;
		g_object_notify (G_OBJECT (manager), "is-connected");
	}

	if (!is_connected) {
		if (manager->priv->dbus_connection == NULL) {
			if (manager->priv->bus_proxy != NULL) {
				g_object_unref (manager->priv->bus_proxy);
				manager->priv->bus_proxy = NULL;
			}

			if (manager->priv->gpm_proxy != NULL) {
				g_object_unref (manager->priv->gpm_proxy);
				manager->priv->gpm_proxy = NULL;
			}
		} else if (manager->priv->bus_proxy == NULL) {
			if (manager->priv->gpm_proxy != NULL) {
				g_object_unref (manager->priv->gpm_proxy);
				manager->priv->gpm_proxy = NULL;
			}
		}
	}

	return is_connected;
}

static void
mojito_client_view_constructed (GObject *object)
{
  MojitoClientViewPrivate *priv = GET_PRIVATE (object);
  GError *error = NULL;
  DBusConnection *conn;
  DBusError derror;

  priv->connection = dbus_g_bus_get (DBUS_BUS_STARTER, &error);

  if (!priv->connection)
  {
    g_critical (G_STRLOC ": Error getting DBUS connection: %s",
                error->message);
    g_clear_error (&error);
    return;
  }

  conn = dbus_g_connection_get_connection (priv->connection);
  dbus_error_init (&derror);
  if (!dbus_bus_start_service_by_name (conn,
                                       MOJITO_SERVICE_NAME,
                                       0, 
                                       NULL, 
                                       &derror))
  {
    g_critical (G_STRLOC ": Error starting mojito service: %s",
                derror.message);
    dbus_error_free (&derror);
    return;
  }

  priv->proxy = dbus_g_proxy_new_for_name_owner (priv->connection,
                                                 MOJITO_SERVICE_NAME,
                                                 priv->object_path,
                                                 MOJITO_SERVICE_VIEW_INTERFACE,
                                                 &error);

  if (!priv->proxy)
  {
    g_critical (G_STRLOC ": Error setting up proxy for remote object: %s",
                error->message);
    g_clear_error (&error);
    return;
  }

  dbus_g_proxy_add_signal (priv->proxy,
                           "ItemsAdded",
                           _mojito_items_get_container_type (),
                           NULL);
  dbus_g_proxy_connect_signal (priv->proxy,
                               "ItemsAdded",
                               (GCallback)_proxy_items_added_cb,
                               object,
                               NULL);

  dbus_g_proxy_add_signal (priv->proxy,
                           "ItemsChanged",
                           _mojito_items_get_container_type (),
                           NULL);
  dbus_g_proxy_connect_signal (priv->proxy,
                               "ItemsChanged",
                               (GCallback)_proxy_items_changed_cb,
                               object,
                               NULL);

  dbus_g_proxy_add_signal (priv->proxy,
                           "ItemsRemoved",
                           _mojito_items_removed_get_container_type (),
                           NULL);
  dbus_g_proxy_connect_signal (priv->proxy,
                               "ItemsRemoved",
                               (GCallback)_proxy_items_removed_cb,
                               object,
                               NULL);
}

int
main (int   argc,
      char**argv)
{
        DBusGConnection* bus;
        UbaCreator     * creator;
        GMainLoop      * loop;
        GError         * error = NULL;

        openlog (g_get_prgname (),
                 LOG_CONS, LOG_USER);

        g_log_set_default_handler (my_log_func,
                                   NULL);

        syslog (LOG_INFO, "started");

        g_type_init ();

        bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
        if (!bus) {
                g_warning ("Failed to connect to dbus session bus: %s",
                           error->message);
                g_clear_error (&error);

                closelog ();

                return 1;
        }

        switch (dbus_bus_request_name (dbus_g_connection_get_connection (bus),
                                       "eu.adeal.uba.demo",
                                       DBUS_NAME_FLAG_REPLACE_EXISTING,
                                       NULL))
        {
        case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
                /* happy */
                break;
        default:
                /* unhappy */
                break;
        }

        gtk_init (&argc, &argv);

        loop = g_main_loop_new (NULL, FALSE);

        creator = uba_creator_new ();
        uba_creator_set_main_loop (creator, loop);

        g_signal_connect (creator, "connect",
                          G_CALLBACK (connect_cb), NULL);

        syslog (LOG_INFO, "before registering: %d refs", G_OBJECT (creator)->ref_count);

        uba_creator_register (creator,
                              bus,
                              "/eu/adeal/uba/demo");

        syslog (LOG_INFO, "after registering:  %d refs", G_OBJECT (creator)->ref_count);

        g_main_loop_run (loop);
        g_main_loop_unref (loop);

        g_object_unref (creator);

        closelog ();

        return 0;
}

void
hexchat_remote (void)
/* TODO: dbus_g_connection_unref (connection) are commented because it makes
 * dbus to crash. Fixed in dbus >=0.70 ?!?
 * https://launchpad.net/distros/ubuntu/+source/dbus/+bug/54375
 */
{
	DBusGConnection *connection;
	DBusGProxy *dbus = NULL;
	DBusGProxy *remote_object = NULL;
	gboolean hexchat_running;
	GError *error = NULL;
	char *command = NULL;

	/* GnomeVFS >=2.15 uses D-Bus and threads, so threads should be
	 * initialised before opening for the first time a D-Bus connection */
	if (!g_thread_supported ()) {
		g_thread_init (NULL);
	}
	dbus_g_thread_init ();

	/* if there is nothing to do, return now. */
	if (!arg_existing || !(arg_url || arg_command)) {
		return;
	}

	arg_dont_autoconnect = TRUE;

	connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
	if (!connection) {
		write_error (_("Couldn't connect to session bus"), &error);
		return;
	}

	/* Checks if HexChat is already running */
	dbus = dbus_g_proxy_new_for_name (connection,
					  DBUS_SERVICE_DBUS,
					  DBUS_PATH_DBUS,
					  DBUS_INTERFACE_DBUS);
	if (!dbus_g_proxy_call (dbus, "NameHasOwner", &error,
				G_TYPE_STRING, DBUS_SERVICE,
				G_TYPE_INVALID,
				G_TYPE_BOOLEAN, &hexchat_running,
				G_TYPE_INVALID)) {
		write_error (_("Failed to complete NameHasOwner"), &error);
		hexchat_running = FALSE;
	}
	g_object_unref (dbus);

	if (!hexchat_running) {
		//dbus_g_connection_unref (connection);
		return;
	}

	remote_object = dbus_g_proxy_new_for_name (connection,
						   DBUS_SERVICE,
						   DBUS_REMOTE,
						   DBUS_REMOTE_INTERFACE);

	if (arg_url) {
		command = g_strdup_printf ("url %s", arg_url);
	} else if (arg_command) {
		command = g_strdup (arg_command);
	}

	if (command) {
		if (!dbus_g_proxy_call (remote_object, "Command",
					&error,
					G_TYPE_STRING, command,
					G_TYPE_INVALID,G_TYPE_INVALID)) {
			write_error (_("Failed to complete Command"), &error);
		}
		g_free (command);
	}

	exit (0);
}

static DBusGProxy *dbus_connect (MoonshotError **error)
{
    DBusConnection  *dbconnection;
    DBusError        dbus_error;
    DBusGConnection *connection;
    DBusGProxy      *g_proxy;
    GError          *g_error = NULL;
    dbus_bool_t      name_has_owner;

    g_return_val_if_fail (*error == NULL, NULL);

    dbus_error_init (&dbus_error);

    /* Check for moonshot server and start the service if possible. We use
     * libdbus here because dbus-glib doesn't handle autostarting the service.
     * If/when we move to GDBus this code can become a one-liner.
     */

    if (is_setid()) {
        *error = moonshot_error_new (MOONSHOT_ERROR_IPC_ERROR,
	                             "Cannot use IPC while setid");
        return NULL;
    }
#ifdef IPC_DBUS_GLIB
    if (getenv("DISPLAY")==NULL) {
        connection = dbus_launch_moonshot();
        if (connection == NULL) {
            *error = moonshot_error_new (MOONSHOT_ERROR_IPC_ERROR,
                                         "Headless dbus launch failed");
            return NULL;
        }
    } else
#endif
    {
        connection = dbus_g_bus_get (DBUS_BUS_SESSION, &g_error);

        if (g_error_matches(g_error, DBUS_GERROR, DBUS_GERROR_NOT_SUPPORTED)) {
            /*Generally this means autolaunch failed because probably DISPLAY is unset*/
            connection = dbus_launch_moonshot();
            if (connection != NULL) {
                g_error_free(g_error);
                g_error = NULL;
            }
        }
        if (g_error != NULL) {
            *error = moonshot_error_new (MOONSHOT_ERROR_IPC_ERROR,
                                         "DBus error: %s",
                                         g_error->message);
            g_error_free (g_error);
            return NULL;
        }
    }


    dbconnection = dbus_g_connection_get_connection(connection);
    name_has_owner  = dbus_bus_name_has_owner (dbconnection,
                                               MOONSHOT_DBUS_NAME,
                                               &dbus_error);

    if (dbus_error_is_set (&dbus_error)) {
        *error = moonshot_error_new (MOONSHOT_ERROR_IPC_ERROR,
                                     "DBus error: %s",
                                     dbus_error.message);
        dbus_error_free (&dbus_error);
        return NULL;
    }

    if (! name_has_owner) {
        dbus_bus_start_service_by_name (dbconnection,
                                        MOONSHOT_DBUS_NAME,
                                        0,
                                        NULL,
                                        &dbus_error);

        if (dbus_error_is_set (&dbus_error)) {
            if (strcmp (dbus_error.name + 27, "ServiceUnknown") == 0) {
                /* Missing .service file; the moonshot-ui install is broken */
                *error = moonshot_error_new (MOONSHOT_ERROR_UNABLE_TO_START_SERVICE,
                                             "The Moonshot service was not found. "
                                             "Please make sure