system/NetworkManager
system/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager synced 2024-10-06 16:21:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

2007-02-19 Tambet Ingo <tambet@ximian.com>

Browse source 
* src/vpn-manager/nm-vpn-manager.c: Handle the DBUS state changes itself.
	Handle device state changes and disconnect VPN if it's device deactivates.

	* src/nm-dbus-nm.c: 
	* src/nm-dbus-nm.h: 
	* src/nm-dbus-device.c: 
	* src/nm-dbus-device.c: 
	* src/nm-dbus-net.c: 
	* src/nm-dbus-net.h: Remove. All of it is implemented byt the new dbus API.

	* src/NetworkManagerMain.h: Get rid of all but 3 properties of NMData.

	* src/nm-device.c (nm_device_get_by_udi):
	(nm_device_get_by_iface): Remove. This doesn't belong here and is already
	implemented in the correct location (NMManager).
	Rip out all the test_device stuff.

	* src/NetworkManagerPolicy.c: Remove the leftover activation success and
	failure handlers, it's all done by NMDevice already.

	* src/NetworkManager.c: Move the signal handling here from nm-logging.c
	Remove the iochannel hack to route the unix signals to the main thread since
	we're not threaded anymore.

	* src/NetworkManagerAP.c: Implement HWAddress property.

	* src/NetworkManagerDbus.c: Remove the dbus signal sending code, it happens
	automatically with dbus-glib.

	* src/nm-netlink-monitor.c: 
	* src/nm-netlink-monitor.h:
		- Move it low in the class hierarchy, don't reference any NM types.
		- Remove private data from the header.
		- Use type safe checks in public API methods.
		- Make it a singleton so we don't have to pass the single reference around.



git-svn-id: http://svn-archive.gnome.org/svn/NetworkManager/trunk@2339 4912f4e0-d625-0410-9fb7-b9a5a253dbdc
This commit is contained in:
Tambet Ingo 2007-02-19 13:09:32 +00:00 committed by Tambet Ingo
parent dedaf4e9f7
commit 3dcd9d2d17
34 changed files with 541 additions and 3096 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
ChangeLog
View file

@ -1,3 +1,41 @@
2007-02-19 Tambet Ingo <tambet@ximian.com>
* src/vpn-manager/nm-vpn-manager.c: Handle the DBUS state changes itself.
Handle device state changes and disconnect VPN if it's device deactivates.
* src/nm-dbus-nm.c:
* src/nm-dbus-nm.h:
* src/nm-dbus-device.c:
* src/nm-dbus-device.c:
* src/nm-dbus-net.c:
* src/nm-dbus-net.h: Remove. All of it is implemented byt the new dbus API.
* src/NetworkManagerMain.h: Get rid of all but 3 properties of NMData.
* src/nm-device.c (nm_device_get_by_udi):
(nm_device_get_by_iface): Remove. This doesn't belong here and is already
implemented in the correct location (NMManager).
Rip out all the test_device stuff.
* src/NetworkManagerPolicy.c: Remove the leftover activation success and
failure handlers, it's all done by NMDevice already.
* src/NetworkManager.c: Move the signal handling here from nm-logging.c
Remove the iochannel hack to route the unix signals to the main thread since
we're not threaded anymore.
* src/NetworkManagerAP.c: Implement HWAddress property.
* src/NetworkManagerDbus.c: Remove the dbus signal sending code, it happens
automatically with dbus-glib.
* src/nm-netlink-monitor.c:
* src/nm-netlink-monitor.h:
- Move it low in the class hierarchy, don't reference any NM types.
- Remove private data from the header.
- Use type safe checks in public API methods.
- Make it a singleton so we don't have to pass the single reference around.
2007-02-16 Tambet Ingo <tambet@ximian.com>
* introspection/nm-ip4-config.xml: Implement.

3
introspection/nm-access-point.xml
View file

@ -2,12 +2,11 @@
<node name="/">
<interface name="org.freedesktop.NetworkManager.AccessPoint">
<property name="Address" type="s" access="read"/>
<property name="Capabilities" type="u" access="read"/>
<property name="Encrypted" type="b" access="read"/>
<property name="Essid" type="s" access="read"/>
<property name="Frequency" type="d" access="read"/>
<property name="HWAddress" type="s" access="read"/>
<property name="HwAddress" type="s" access="read"/>
<property name="Mode" type="i" access="read"/>
<property name="Rate" type="u" access="read"/>
<property name="Strength" type="i" access="read"/>

48
libnm-glib/libnm-glib-test.c
View file

@ -117,6 +117,28 @@ dump_ip4_config (NMIP4Config *cfg)
}
}
static void
dump_access_point (NMAccessPoint *ap)
{
char *str;
str = nm_access_point_get_essid (ap);
g_print ("\tEssid: %s\n", str);
g_free (str);
str = nm_access_point_get_hw_address (ap);
g_print ("\tMAC Address: %s\n", str);
g_free (str);
g_print ("\tCapabilities: %d\n", nm_access_point_get_capabilities (ap));
g_print ("\tEncrypted: %d\n", nm_access_point_is_encrypted (ap));
g_print ("\tFrequency: %f\n", nm_access_point_get_frequency (ap));
g_print ("\tMode: %d\n", nm_access_point_get_mode (ap));
g_print ("\tRate: %d\n", nm_access_point_get_rate (ap));
g_print ("\tStrength: %d\n", nm_access_point_get_strength (ap));
}
static void
dump_wireless (NMDevice80211Wireless *device)
{
@ -134,31 +156,7 @@ dump_wireless (NMDevice80211Wireless *device)
g_print ("Networks:\n");
networks = nm_device_802_11_wireless_get_networks (device);
for (iter = networks; iter; iter = iter->next) {
NMAccessPoint *ap = NM_ACCESS_POINT (iter->data);
str = nm_access_point_get_essid (ap);
g_print ("\tEssid: %s\n", str);
g_free (str);
/* This is not provided by NM yet */
#if 0
str = nm_access_point_get_address (ap);
g_print ("\tAddress: %s\n", str);
g_free (str);
str = nm_access_point_get_hw_address (ap);
g_print ("\tMAC Address: %s\n", str);
g_free (str);
#endif
g_print ("\tCapabilities: %d\n", nm_access_point_get_capabilities (ap));
g_print ("\tEncrypted: %d\n", nm_access_point_is_encrypted (ap));
g_print ("\tFrequency: %f\n", nm_access_point_get_frequency (ap));
g_print ("\tMode: %d\n", nm_access_point_get_mode (ap));
g_print ("\tRate: %d\n", nm_access_point_get_rate (ap));
g_print ("\tStrength: %d\n", nm_access_point_get_strength (ap));
dump_access_point (NM_ACCESS_POINT (iter->data));
g_print ("\n");
}

19
libnm-glib/nm-access-point.c
View file

@ -27,23 +27,6 @@ nm_access_point_new (DBusGConnection *connection, const char *path)
NULL);
}
char *
nm_access_point_get_address (NMAccessPoint *ap)
{
GValue value = {0,};
char *address = NULL;
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), NULL);
if (nm_dbus_get_property (DBUS_G_PROXY (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
"Address",
&value))
address = g_strdup (g_value_get_string (&value));
return address;
}
guint32
nm_access_point_get_capabilities (NMAccessPoint *ap)
{
@ -123,7 +106,7 @@ nm_access_point_get_hw_address (NMAccessPoint *ap)
if (nm_dbus_get_property (DBUS_G_PROXY (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
"HWAddress",
"HwAddress",
&value))
address = g_strdup (g_value_get_string (&value));

1
libnm-glib/nm-access-point.h
View file

@ -24,7 +24,6 @@ GType nm_access_point_get_type (void);
NMAccessPoint *nm_access_point_new (DBusGConnection *connection, const char *path);
char *nm_access_point_get_address (NMAccessPoint *ap);
guint32 nm_access_point_get_capabilities (NMAccessPoint *ap);
gboolean nm_access_point_is_encrypted (NMAccessPoint *ap);
char *nm_access_point_get_essid (NMAccessPoint *ap);

258
src/NetworkManager.c
View file

@ -52,7 +52,6 @@
#include "NetworkManagerAPList.h"
#include "NetworkManagerSystem.h"
#include "nm-named-manager.h"
#include "nm-vpn-act-request.h"
#include "nm-dbus-vpn.h"
#include "nm-dbus-nm.h"
#include "nm-dbus-manager.h"
@ -62,90 +61,54 @@
#include "nm-netlink-monitor.h"
#include "nm-logging.h"
#define NM_WIRELESS_LINK_STATE_POLL_INTERVAL (5 * 1000)
#define NM_DEFAULT_PID_FILE LOCALSTATEDIR"/run/NetworkManager.pid"
/*
* Globals
*/
static NMData *nm_data = NULL;
static NMManager *manager = NULL;
static GMainLoop *main_loop = NULL;
static NMData *nm_data = NULL;
static gboolean sigterm_pipe_handler (GIOChannel *src, GIOCondition condition, gpointer data);
static void nm_data_free (NMData *data);
/*
* nm_state_change_signal_broadcast
*
*/
static gboolean nm_state_change_signal_broadcast (gpointer user_data)
{
NMState state;
NMDBusManager *dbus_mgr;
DBusConnection *dbus_connection;
state = nm_manager_get_state (manager);
dbus_mgr = nm_dbus_manager_get ();
dbus_connection = nm_dbus_manager_get_dbus_connection (dbus_mgr);
if (dbus_connection)
nm_dbus_signal_state_change (dbus_connection, state);
g_object_unref (dbus_mgr);
return FALSE;
}
/*
* nm_schedule_state_change_signal_broadcast
*
*/
void nm_schedule_state_change_signal_broadcast (NMData *data)
{
g_idle_add_full (G_PRIORITY_HIGH,
nm_state_change_signal_broadcast,
NULL,
NULL);
}
static void
nm_error_monitoring_device_link_state (NmNetlinkMonitor *monitor,
GError *error,
NMData *data)
nm_error_monitoring_device_link_state (NMNetlinkMonitor *monitor,
GError *error,
gpointer user_data)
{
/* FIXME: Try to handle the error instead of just printing it. */
nm_warning ("error monitoring wired ethernet link state: %s\n",
error->message);
error->message);
}
static NmNetlinkMonitor *
nm_monitor_setup (NMData *data)
static gboolean
nm_monitor_setup (void)
{
GError *error = NULL;
NmNetlinkMonitor *monitor;
NMNetlinkMonitor *monitor;
monitor = nm_netlink_monitor_new (data);
monitor = nm_netlink_monitor_get ();
nm_netlink_monitor_open_connection (monitor, &error);
if (error != NULL)
{
nm_warning ("could not monitor wired ethernet devices: %s",
error->message);
error->message);
g_error_free (error);
g_object_unref (monitor);
return NULL;
return FALSE;
}
g_signal_connect (G_OBJECT (monitor), "error",
G_CALLBACK (nm_error_monitoring_device_link_state),
data);
NULL);
nm_netlink_monitor_attach (monitor, NULL);
/* Request initial status of cards */
nm_netlink_monitor_request_status (monitor, NULL);
return monitor;
return TRUE;
}
/*
@ -157,26 +120,9 @@ nm_monitor_setup (NMData *data)
static NMData *nm_data_new (void)
{
NMData * data;
guint id;
data = g_slice_new0 (NMData);
data->main_loop = g_main_loop_new (NULL, FALSE);
/* Allow clean shutdowns by having the thread which receives the signal
* notify the main thread to quit, rather than having the receiving
* thread try to quit the glib main loop.
*/
if (pipe (data->sigterm_pipe) < 0) {
nm_error ("Couldn't create pipe: %s", g_strerror (errno));
return NULL;
}
data->sigterm_iochannel = g_io_channel_unix_new (data->sigterm_pipe[0]);
id = g_io_add_watch (data->sigterm_iochannel,
G_IO_IN | G_IO_ERR,
sigterm_pipe_handler,
data);
/* Initialize the access point lists */
data->allowed_ap_list = nm_ap_list_new (NETWORK_TYPE_ALLOWED);
data->invalid_ap_list = nm_ap_list_new (NETWORK_TYPE_INVALID);
@ -187,15 +133,6 @@ static NMData *nm_data_new (void)
return NULL;
}
/* Create watch functions that monitor cards for link status. */
if (!(data->netlink_monitor = nm_monitor_setup (data)))
{
nm_data_free (data);
nm_warning ("could not create netlink monitor.");
return NULL;
}
data->wireless_enabled = TRUE;
return data;
}
@ -208,45 +145,16 @@ static NMData *nm_data_new (void)
*/
static void nm_data_free (NMData *data)
{
NMVPNActRequest *req;
g_return_if_fail (data != NULL);
/* Kill any active VPN connection */
if ((req = nm_vpn_manager_get_vpn_act_request (data->vpn_manager)))
nm_vpn_manager_deactivate_vpn_connection (data->vpn_manager, nm_vpn_act_request_get_parent_dev (req));
if (data->netlink_monitor) {
g_object_unref (G_OBJECT (data->netlink_monitor));
data->netlink_monitor = NULL;
}
nm_ap_list_unref (data->allowed_ap_list);
nm_ap_list_unref (data->invalid_ap_list);
nm_vpn_manager_dispose (data->vpn_manager);
g_object_unref (data->named_manager);
g_main_loop_unref (data->main_loop);
g_io_channel_unref(data->sigterm_iochannel);
g_slice_free (NMData, data);
}
int nm_get_sigterm_pipe (void)
{
return nm_data->sigterm_pipe[1];
}
static gboolean sigterm_pipe_handler (GIOChannel *src, GIOCondition condition, gpointer user_data)
{
NMData * data = user_data;
nm_info ("Caught terminiation signal");
g_main_loop_quit (data->main_loop);
return FALSE;
}
static void
nm_name_owner_changed_handler (NMDBusManager *mgr,
DBusConnection *connection,
@ -260,16 +168,93 @@ nm_name_owner_changed_handler (NMDBusManager *mgr,
gboolean new_owner_good = (new && (strlen (new) > 0));
if (strcmp (name, NMI_DBUS_SERVICE) == 0) {
if (!old_owner_good && new_owner_good) {
if (!old_owner_good && new_owner_good)
/* NMI appeared, update stuff */
nm_policy_schedule_allowed_ap_list_update (data);
nm_dbus_vpn_schedule_vpn_connections_update (data);
} else if (old_owner_good && !new_owner_good) {
/* nothing */
}
}
}
static void
nm_signal_handler (int signo)
{
static int in_fatal = 0;
/* avoid loops */
if (in_fatal > 0)
return;
++in_fatal;
switch (signo)
{
case SIGSEGV:
case SIGBUS:
case SIGILL:
case SIGABRT:
nm_warning ("Caught signal %d. Generating backtrace...", signo);
nm_logging_backtrace ();
exit (1);
break;
case SIGFPE:
case SIGPIPE:
/* let the fatal signals interrupt us */
--in_fatal;
nm_warning ("Caught signal %d, shutting down abnormally. Generating backtrace...", signo);
nm_logging_backtrace ();
g_main_loop_quit (main_loop);
break;
case SIGINT:
case SIGTERM:
/* let the fatal signals interrupt us */
--in_fatal;
nm_warning ("Caught signal %d, shutting down normally.", signo);
g_main_loop_quit (main_loop);
break;
case SIGHUP:
--in_fatal;
/* FIXME:
* Reread config stuff like system config files, VPN service files, etc
*/
break;
case SIGUSR1:
--in_fatal;
/* FIXME:
* Play with log levels or something
*/
break;
default:
signal (signo, nm_signal_handler);
break;
}
}
static void
setup_signals (void)
{
struct sigaction action;
sigset_t mask;
sigemptyset (&mask);
action.sa_handler = nm_signal_handler;
action.sa_mask = mask;
action.sa_flags = 0;
sigaction (SIGTERM, &action, NULL);
sigaction (SIGINT, &action, NULL);
sigaction (SIGILL, &action, NULL);
sigaction (SIGBUS, &action, NULL);
sigaction (SIGFPE, &action, NULL);
sigaction (SIGHUP, &action, NULL);
sigaction (SIGSEGV, &action, NULL);
sigaction (SIGABRT, &action, NULL);
sigaction (SIGUSR1, &action, NULL);
}
static void
write_pidfile (const char *pidfile)
{
@ -321,11 +306,11 @@ main (int argc, char *argv[])
char * user_pidfile = NULL;
NMPolicy *policy;
NMHalManager *hal_manager = NULL;
NMVPNManager *vpn_manager = NULL;
NMDBusManager * dbus_mgr;
DBusConnection *dbus_connection;
NMSupplicantManager * sup_mgr = NULL;
int exit_status = EXIT_FAILURE;
guint32 id;
GOptionEntry options[] = {
{"no-daemon", 0, 0, G_OPTION_ARG_NONE, &become_daemon, "Don't become a daemon", NULL},
@ -385,11 +370,14 @@ main (int argc, char *argv[])
if (!g_thread_supported ())
g_thread_init (NULL);
dbus_g_thread_init ();
setup_signals ();
nm_logging_setup (become_daemon);
nm_info ("starting...");
nm_system_init();
nm_system_init ();
main_loop = g_main_loop_new (NULL, FALSE);
/* Initialize our instance data */
nm_data = nm_data_new ();
@ -398,6 +386,10 @@ main (int argc, char *argv[])
goto pidfile;
}
/* Create watch functions that monitor cards for link status. */
if (!nm_monitor_setup ())
goto done;
/* Initialize our DBus service & connection */
dbus_mgr = nm_dbus_manager_get ();
dbus_connection = nm_dbus_manager_get_dbus_connection (dbus_mgr);
@ -408,14 +400,17 @@ main (int argc, char *argv[])
"was not loaded.");
goto done;
}
g_signal_connect (G_OBJECT (dbus_mgr), "name-owner-changed",
G_CALLBACK (nm_name_owner_changed_handler), nm_data);
id = nm_dbus_manager_register_signal_handler (dbus_mgr,
NMI_DBUS_INTERFACE,
NULL,
nm_dbus_nmi_signal_handler,
nm_data);
nm_data->nmi_sig_handler_id = id;
g_signal_connect (dbus_mgr,
"name-owner-changed",
G_CALLBACK (nm_name_owner_changed_handler),
nm_data);
nm_dbus_manager_register_signal_handler (dbus_mgr,
NMI_DBUS_INTERFACE,
NULL,
nm_dbus_nmi_signal_handler,
nm_data);
manager = nm_manager_new ();
policy = nm_policy_new (manager);
@ -427,8 +422,8 @@ main (int argc, char *argv[])
goto done;
}
nm_data->vpn_manager = nm_vpn_manager_new (manager, nm_data);
if (!nm_data->vpn_manager) {
vpn_manager = nm_vpn_manager_new (manager, nm_data);
if (!vpn_manager) {
nm_warning ("Failed to start the VPN manager.");
goto done;
}
@ -450,10 +445,8 @@ main (int argc, char *argv[])
goto done;
/* If NMI is running, grab allowed wireless network lists from it ASAP */
if (nm_dbus_manager_name_has_owner (dbus_mgr, NMI_DBUS_SERVICE)) {
if (nm_dbus_manager_name_has_owner (dbus_mgr, NMI_DBUS_SERVICE))
nm_policy_schedule_allowed_ap_list_update (nm_data);
nm_dbus_vpn_schedule_vpn_connections_update (nm_data);
}
/* We run dhclient when we need to, and we don't want any stray ones
* lying around upon launch.
@ -463,18 +456,15 @@ main (int argc, char *argv[])
/* Bring up the loopback interface. */
nm_system_enable_loopback ();
/* Get modems, ISDN, and so on's configuration from the system */
nm_data->dialup_list = nm_system_get_dialup_config ();
/* Run the main loop */
nm_schedule_state_change_signal_broadcast (nm_data);
exit_status = EXIT_SUCCESS;
g_main_loop_run (nm_data->main_loop);
g_main_loop_run (main_loop);
done:
nm_print_open_socks ();
nm_dbus_manager_remove_signal_handler (dbus_mgr, nm_data->nmi_sig_handler_id);
if (vpn_manager)
nm_vpn_manager_dispose (vpn_manager);
nm_hal_manager_destroy (hal_manager);
nm_policy_destroy (policy);

19
src/NetworkManagerAP.c
View file

@ -89,12 +89,11 @@ static guint signals[LAST_SIGNAL] = { 0 };
enum {
PROP_0,
PROP_ADDRESS,
PROP_CAPABILITIES,
PROP_ENCRYPTED,
PROP_ESSID,
PROP_FREQUENCY,
PROP_HWADDRESS,
PROP_HW_ADDRESS,
PROP_MODE,
PROP_RATE,
PROP_STRENGTH,
@ -179,6 +178,7 @@ get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
NMAccessPointPrivate *priv = NM_AP_GET_PRIVATE (object);
char hw_addr_buf[20];
switch (prop_id) {
case PROP_CAPABILITIES:
@ -193,6 +193,11 @@ get_property (GObject *object, guint prop_id,
case PROP_FREQUENCY:
g_value_set_double (value, priv->freq);
break;
case PROP_HW_ADDRESS:
memset (hw_addr_buf, 0, 20);
iw_ether_ntop (&priv->address, hw_addr_buf);
g_value_set_string (value, &hw_addr_buf[0]);
break;
case PROP_MODE:
g_value_set_int (value, priv->mode);
break;
@ -222,8 +227,6 @@ nm_ap_class_init (NMAccessPointClass *ap_class)
/* properties */
/* FIXME: address */
g_object_class_install_property
(object_class, PROP_CAPABILITIES,
g_param_spec_uint (NM_AP_CAPABILITIES,
@ -256,7 +259,13 @@ nm_ap_class_init (NMAccessPointClass *ap_class)
0.0, 10000.0, 0.0, /* FIXME */
G_PARAM_READWRITE));
/* FIXME: HWAddress */
g_object_class_install_property
(object_class, PROP_HW_ADDRESS,
g_param_spec_string (NM_AP_HW_ADDRESS,
"MAC Address",
"Hardware MAC address",
NULL,
G_PARAM_READABLE));
g_object_class_install_property
(object_class, PROP_MODE,

3
src/NetworkManagerAP.h
View file

@ -36,12 +36,11 @@
#define NM_IS_AP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), NM_TYPE_AP))
#define NM_AP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NM_TYPE_AP, NMAccessPointClass))
#define NM_AP_ADDRESS "address"
#define NM_AP_CAPABILITIES "capabilities"
#define NM_AP_ENCRYPTED "encrypted"
#define NM_AP_ESSID "essid"
#define NM_AP_FREQUENCY "frequency"
#define NM_AP_HWADDRESS "hwaddress"
#define NM_AP_HW_ADDRESS "hw-address"
#define NM_AP_MODE "mode"
#define NM_AP_RATE "rate"
#define NM_AP_STRENGTH "strength"

280
src/NetworkManagerDbus.c
View file

@ -39,7 +39,6 @@
#include "nm-dbus-nm.h"
#include "nm-dbus-device.h"
#include "nm-dbus-net.h"
#include "nm-dbus-vpn.h"
#include "nm-dbus-nmi.h"
#include "nm-utils.h"
#include "nm-dhcp-manager.h"
@ -184,272 +183,6 @@ NMDevice *nm_dbus_get_device_from_escaped_object_path (NMData *data, const char
/* Handler code */
/*-------------------------------------------------------------*/
typedef struct NMStatusChangeData
{
NMData * data;
NMDevice * dev;
NMAccessPoint * ap;
DeviceStatus status;
} NMStatusChangeData;
typedef struct
{
DeviceStatus status;
const char * signal;
} DeviceStatusSignals;
static DeviceStatusSignals dev_status_signals[] =
{
{ DEVICE_NO_LONGER_ACTIVE, "DeviceNoLongerActive" },
{ DEVICE_NOW_ACTIVE, "DeviceNowActive" },
{ DEVICE_ACTIVATING, "DeviceActivating" },
{ DEVICE_ACTIVATION_FAILED, "DeviceActivationFailed" },
{ DEVICE_ADDED, "DeviceAdded" },
{ DEVICE_REMOVED, "DeviceRemoved" },
{ DEVICE_CARRIER_ON, "DeviceCarrierOn" },
{ DEVICE_CARRIER_OFF, "DeviceCarrierOff" },
{ DEVICE_STATUS_INVALID, NULL }
};
/*
* nm_dbus_signal_device_status_change
*
* Notifies the bus that a particular device has had a status change
*
*/
static gboolean
nm_dbus_signal_device_status_change (gpointer user_data)
{
NMStatusChangeData *cb_data = (NMStatusChangeData *)user_data;
DBusMessage * message;
char * dev_path = NULL;
const char * sig = NULL;
int i = 0;
NMDBusManager * dbus_mgr = NULL;
DBusConnection *dbus_connection;
g_return_val_if_fail (cb_data->data, FALSE);
g_return_val_if_fail (cb_data->dev, FALSE);
dbus_mgr = nm_dbus_manager_get ();
dbus_connection = nm_dbus_manager_get_dbus_connection (dbus_mgr);
if (!dbus_connection) {
nm_warning ("could not get the dbus connection.");
goto out;
}
while ((dev_status_signals[i].status != DEVICE_STATUS_INVALID) && (dev_status_signals[i].status != cb_data->status))
i++;
if (!(sig = dev_status_signals[i].signal))
goto out;
if (!(dev_path = nm_dbus_get_object_path_for_device (cb_data->dev)))
goto out;
message = dbus_message_new_signal (NM_DBUS_PATH, NM_DBUS_INTERFACE, sig);
if (!message) {
nm_warning ("nm_dbus_signal_device_status_change(): Not enough memory for new dbus message!");
goto out;
}
/* If the device was wireless, attach the name of the wireless network that failed to activate */
if (cb_data->ap) {
const char *essid = nm_ap_get_essid (cb_data->ap);
if (essid)
dbus_message_append_args (message, DBUS_TYPE_OBJECT_PATH, &dev_path, DBUS_TYPE_STRING, &essid, DBUS_TYPE_INVALID);
g_object_unref (cb_data->ap);
} else {
dbus_message_append_args (message, DBUS_TYPE_OBJECT_PATH, &dev_path, DBUS_TYPE_INVALID);
}
dbus_connection_send (dbus_connection, message, NULL);
dbus_message_unref (message);
g_object_unref (G_OBJECT (cb_data->dev));
g_slice_free (NMStatusChangeData, cb_data);
out:
g_object_unref (dbus_mgr);
g_free (dev_path);
return FALSE;
}
void nm_dbus_schedule_device_status_change_signal (NMData *data, NMDevice *dev, NMAccessPoint *ap, DeviceStatus status)
{
NMStatusChangeData * cb_data = NULL;
GSource * source;
guint id;
g_return_if_fail (data != NULL);
g_return_if_fail (dev != NULL);
cb_data = g_slice_new0 (NMStatusChangeData);
g_object_ref (G_OBJECT (dev));
cb_data->data = data;
cb_data->dev = dev;
if (ap)
cb_data->ap = g_object_ref (ap);
cb_data->status = status;
id = g_idle_add (nm_dbus_signal_device_status_change, cb_data);
source = g_main_context_find_source_by_id (NULL, id);
if (source) {
g_source_set_priority (source, G_PRIORITY_HIGH_IDLE);
}
}
/*
* nm_dbus_signal_state_change
*
* Signal a change in state
*
*/
void nm_dbus_signal_state_change (DBusConnection *connection, NMState state)
{
DBusMessage * message;
g_return_if_fail (connection != NULL);
if (!(message = dbus_message_new_signal (NM_DBUS_PATH, NM_DBUS_INTERFACE, NM_DBUS_SIGNAL_STATE_CHANGE)))
{
nm_warning ("nm_dbus_signal_state_change(): Not enough memory for new dbus message!");
return;
}
dbus_message_append_args (message, DBUS_TYPE_UINT32, &state, DBUS_TYPE_INVALID);
if (!dbus_connection_send (connection, message, NULL))
nm_warning ("nm_dbus_signal_state_change(): Could not raise the signal!");
dbus_message_unref (message);
}
/*
* nm_dbus_signal_wireless_network_change
*
* Notifies the bus that a new wireless network has come into range
*
*/
void
nm_dbus_signal_wireless_network_change (NMDevice80211Wireless *dev,
NMAccessPoint *ap,
NMNetworkStatus status,
gint strength)
{
NMDBusManager * dbus_mgr = NULL;
DBusConnection *dbus_connection;
DBusMessage * message;
char * dev_path = NULL;
char * net_path = NULL;
const char * sig = NULL;
g_return_if_fail (dev != NULL);
g_return_if_fail (ap != NULL);
dbus_mgr = nm_dbus_manager_get ();
dbus_connection = nm_dbus_manager_get_dbus_connection (dbus_mgr);
if (!dbus_connection) {
nm_warning ("could not get the dbus connection.");
goto out;
}
if (!(dev_path = nm_dbus_get_object_path_for_device (NM_DEVICE (dev))))
goto out;
if (!(net_path = nm_dbus_get_object_path_for_network (NM_DEVICE (dev), ap)))
goto out;
switch (status) {
case NETWORK_STATUS_DISAPPEARED:
sig = "WirelessNetworkDisappeared";
break;
case NETWORK_STATUS_APPEARED:
sig = "WirelessNetworkAppeared";
break;
case NETWORK_STATUS_STRENGTH_CHANGED:
sig = "WirelessNetworkStrengthChanged";
break;
default:
break;
}
if (!sig) {
nm_warning ("tried to broadcast unknown signal.");
goto out;
}
message = dbus_message_new_signal (NM_DBUS_PATH, NM_DBUS_INTERFACE, sig);
if (!message) {
nm_warning ("could not allocate the dbus message.");
goto out;
}
dbus_message_append_args (message,
DBUS_TYPE_OBJECT_PATH, &dev_path,
DBUS_TYPE_OBJECT_PATH, &net_path,
DBUS_TYPE_INVALID);
if (status == NETWORK_STATUS_STRENGTH_CHANGED) {
dbus_message_append_args (message,
DBUS_TYPE_INT32, &strength,
DBUS_TYPE_INVALID);
}
dbus_connection_send (dbus_connection, message, NULL);
dbus_message_unref (message);
out:
g_free (net_path);
g_free (dev_path);
g_object_unref (dbus_mgr);
}
void
nm_dbus_signal_device_strength_change (NMDevice80211Wireless *dev,
gint strength)
{
NMDBusManager * dbus_mgr = NULL;
DBusConnection *dbus_connection;
DBusMessage * message;
char * dev_path = NULL;
g_return_if_fail (dev != NULL);
dbus_mgr = nm_dbus_manager_get ();
dbus_connection = nm_dbus_manager_get_dbus_connection (dbus_mgr);
if (!dbus_connection) {
nm_warning ("could not get the dbus connection.");
goto out;
}
if (!(dev_path = nm_dbus_get_object_path_for_device (NM_DEVICE (dev))))
goto out;
message = dbus_message_new_signal (NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"DeviceStrengthChanged");
if (!message) {
nm_warning ("could not allocate the dbus message.");
goto out;
}
dbus_message_append_args (message,
DBUS_TYPE_OBJECT_PATH, &dev_path,
DBUS_TYPE_INT32, &strength,
DBUS_TYPE_INVALID);
dbus_connection_send (dbus_connection, message, NULL);
dbus_message_unref (message);
out:
g_free (dev_path);
g_object_unref (dbus_mgr);
}
gboolean
nm_dbus_nmi_signal_handler (DBusConnection *connection,
DBusMessage *message,
@ -481,19 +214,6 @@ nm_dbus_nmi_signal_handler (DBusConnection *connection,
nm_dbus_update_one_allowed_network (network, data);
handled = TRUE;
}
} else if (dbus_message_is_signal (message, NMI_DBUS_INTERFACE, "VPNConnectionUpdate")) {
char *name = NULL;
if (dbus_message_get_args (message,
NULL,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID)) {
nm_debug ("NetworkManagerInfo triggered update of VPN connection "
" '%s'",
name);
nm_dbus_vpn_update_one_vpn_connection (connection, name, data);
handled = TRUE;
}
} else if (dbus_message_is_signal (message, NMI_DBUS_INTERFACE, "UserInterfaceActivated")) {
nm_device_802_11_wireless_set_scan_interval (data,
NULL,

23
src/NetworkManagerDbus.h
View file

@ -32,21 +32,6 @@
#include "NetworkManagerAPList.h"
typedef enum
{
DEVICE_STATUS_INVALID,
DEVICE_NOW_ACTIVE,
DEVICE_NO_LONGER_ACTIVE,
DEVICE_ACTIVATING,
DEVICE_ACTIVATION_FAILED,
DEVICE_ACTIVATION_CANCELED,
DEVICE_ADDED,
DEVICE_REMOVED,
DEVICE_CARRIER_ON,
DEVICE_CARRIER_OFF
} DeviceStatus;
static inline gboolean message_is_error (DBusMessage *msg)
{
g_return_val_if_fail (msg != NULL, FALSE);
@ -56,14 +41,6 @@ static inline gboolean message_is_error (DBusMessage *msg)
char * nm_dbus_get_object_path_for_device (NMDevice *dev);
char * nm_dbus_get_object_path_for_network (NMDevice *dev, NMAccessPoint *ap);
void nm_dbus_schedule_device_status_change_signal (NMData *data, NMDevice *dev, NMAccessPoint *ap, DeviceStatus status);
void nm_dbus_signal_state_change (DBusConnection *connection, NMState state);
void nm_dbus_signal_wireless_network_change (NMDevice80211Wireless *dev, NMAccessPoint *ap, NMNetworkStatus status, gint strength);
void nm_dbus_signal_device_strength_change (NMDevice80211Wireless *dev, gint strength);
NMDevice * nm_dbus_get_device_from_escaped_object_path (NMData *data, const char *path);
DBusMessage * nm_dbus_create_error_message (DBusMessage *message, const char *exception_namespace, const char *exception, const char *format, ...);

28
src/NetworkManagerMain.h
View file

@ -25,12 +25,8 @@
#include <glib.h>
#include <glib/gthread.h>
#include <dbus/dbus.h>
#include "NetworkManager.h"
#include "NetworkManagerAP.h"
#include "nm-netlink-monitor.h"
#include "NetworkManagerAPList.h"
#include "nm-named-manager.h"
#include "nm-device.h"
#include "NetworkManagerDbusUtils.h"
typedef struct NMActRequest NMActRequest;
@ -39,34 +35,12 @@ typedef struct NMVPNManager NMVPNManager;
typedef struct NMData
{
GIOChannel * sigterm_iochannel;
int sigterm_pipe[2];
NmNetlinkMonitor * netlink_monitor;
NMNamedManager * named_manager;
NMVPNManager * vpn_manager;
guint32 nmi_sig_handler_id;
GMainLoop * main_loop;
guint dev_change_check_idle_id;
GSList * dev_list;
gboolean wireless_enabled;
gboolean modem_active;
gboolean asleep;
GSList * dialup_list;
struct NMAccessPointList *allowed_ap_list;
struct NMAccessPointList *invalid_ap_list;
} NMData;
void nm_schedule_state_change_signal_broadcast (NMData *data);
int nm_get_sigterm_pipe (void);
#endif

119
src/NetworkManagerPolicy.c
View file

@ -58,125 +58,6 @@ static void schedule_change_check (NMPolicy *policy);
static NMPolicy *global_policy;
/*
* nm_policy_activation_finish
*
* Finishes up activation by sending out dbus signals, which has to happen
* on the main thread.
*
*/
static gboolean nm_policy_activation_finish (gpointer user_data)
{
NMActRequest * req = (NMActRequest *) user_data;
NMDevice * dev = NULL;
NMData * data = NULL;
NMAccessPoint * ap = NULL;
g_return_val_if_fail (req != NULL, FALSE);
data = nm_act_request_get_data (req);
g_assert (data);
dev = nm_act_request_get_dev (req);
g_assert (dev);
if (NM_IS_DEVICE_802_11_WIRELESS (dev))
ap = nm_act_request_get_ap (req);
nm_dbus_schedule_device_status_change_signal (data, dev, ap, DEVICE_NOW_ACTIVE);
nm_schedule_state_change_signal_broadcast (data);
return FALSE;
}
/*
* nm_policy_schedule_activation_finish
*
*/
void nm_policy_schedule_activation_finish (NMActRequest *req)
{
GSource * source;
NMDevice * dev;
guint id;
g_return_if_fail (req != NULL);
dev = nm_act_request_get_dev (req);
g_assert (dev);
nm_act_request_set_stage (req, NM_ACT_STAGE_ACTIVATED);
id = g_idle_add (nm_policy_activation_finish, req);
source = g_main_context_find_source_by_id (NULL, id);
if (source) {
g_source_set_priority (source, G_PRIORITY_HIGH_IDLE);
}
nm_info ("Activation (%s) Finish handler scheduled.",
nm_device_get_iface (dev));
}
/*
* nm_policy_activation_failed
*
* Clean up a failed activation.
*
*/
static gboolean nm_policy_activation_failed (gpointer user_data)
{
NMActRequest * req = (NMActRequest *) user_data;
NMDevice * dev = NULL;
NMData * data = NULL;
NMAccessPoint * ap = NULL;
g_return_val_if_fail (req != NULL, FALSE);
data = nm_act_request_get_data (req);
g_assert (data);
dev = nm_act_request_get_dev (req);
g_assert (dev);
if (NM_IS_DEVICE_802_11_WIRELESS (dev))
ap = nm_act_request_get_ap (req);
nm_dbus_schedule_device_status_change_signal (data, dev, ap, DEVICE_ACTIVATION_FAILED);
nm_device_interface_deactivate (NM_DEVICE_INTERFACE (dev));
nm_schedule_state_change_signal_broadcast (data);
schedule_change_check ((gpointer) global_policy);
return FALSE;
}
/*
* nm_policy_schedule_activation_failed
*
*/
void nm_policy_schedule_activation_failed (NMActRequest *req)
{
GSource * source;
NMDevice * dev;
guint id;
g_return_if_fail (req != NULL);
dev = nm_act_request_get_dev (req);
g_assert (dev);
nm_act_request_set_stage (req, NM_ACT_STAGE_FAILED);
id = g_idle_add (nm_policy_activation_failed, req);
source = g_main_context_find_source_by_id (NULL, id);
if (source) {
g_source_set_priority (source, G_PRIORITY_HIGH_IDLE);
}
nm_info ("Activation (%s) failure scheduled...", nm_device_get_iface (dev));
}
/*
* nm_policy_auto_get_best_device
*

3
src/NetworkManagerPolicy.h
View file

@ -37,7 +37,4 @@ void nm_policy_destroy (NMPolicy *policy);
void nm_policy_schedule_allowed_ap_list_update (NMData *app_data);
void nm_policy_schedule_device_ap_lists_update_from_allowed (NMData *app_data);
void nm_policy_schedule_activation_finish (NMActRequest *req);
void nm_policy_schedule_activation_failed (NMActRequest *req);
#endif /* NETWORK_MANAGER_POLICY_H */

12
src/backends/NetworkManagerFrugalware.c
View file

@ -62,10 +62,6 @@ void nm_system_device_flush_routes (NMDevice *dev)
{
g_return_if_fail (dev != NULL);
/* Not really applicable for test devices */
if (nm_device_is_test_device (dev))
return;
nm_system_device_flush_routes_with_iface (nm_device_get_iface (dev));
}
@ -98,10 +94,6 @@ void nm_system_device_flush_addresses (NMDevice *dev)
{
g_return_if_fail (dev != NULL);
/* Not really applicable for test devices */
if (nm_device_is_test_device (dev))
return;
nm_system_device_flush_addresses_with_iface (nm_device_get_iface (dev));
}
@ -275,10 +267,6 @@ void nm_system_device_add_default_route_via_device (NMDevice *dev)
{
g_return_if_fail (dev != NULL);
/* Not really applicable for test devices */
if (nm_device_is_test_device (dev))
return;
nm_system_device_add_default_route_via_device_with_iface (nm_device_get_iface (dev));
}

12
src/backends/NetworkManagerGeneric.c
View file

@ -59,10 +59,6 @@ void nm_generic_device_add_default_route_via_device (NMDevice *dev)
{
g_return_if_fail (dev != NULL);
/* Not really applicable for test devices */
if (nm_device_is_test_device (dev))
return;
nm_system_device_add_default_route_via_device_with_iface (nm_device_get_iface (dev));
}
@ -114,10 +110,6 @@ void nm_generic_device_flush_routes (NMDevice *dev)
{
g_return_if_fail (dev != NULL);
/* Not really applicable for test devices */
if (nm_device_is_test_device (dev))
return;
nm_system_device_flush_routes_with_iface (nm_device_get_iface (dev));
}
@ -149,10 +141,6 @@ void nm_generic_device_flush_addresses (NMDevice *dev)
{
g_return_if_fail (dev != NULL);
/* Not really applicable for test devices */
if (nm_device_is_test_device (dev))
return;
nm_system_device_flush_addresses_with_iface (nm_device_get_iface (dev));
}

724
src/nm-dbus-device.c
View file

@ -1,724 +0,0 @@
/* NetworkManager -- Network link manager
*
* Dan Williams <dcbw@redhat.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* (C) Copyright 2005 Red Hat, Inc.
*/
#include <glib.h>
#include <dbus/dbus.h>
#include <dbus/dbus-glib-lowlevel.h>
#include <dbus/dbus-glib.h>
#include <stdarg.h>
#include <syslog.h>
#include <netinet/ether.h>
#include "nm-utils.h"
#include "nm-device.h"
#include "NetworkManagerDbus.h"
#include "NetworkManagerDbusUtils.h"
#include "NetworkManagerPolicy.h"
#include "NetworkManagerUtils.h"
#include "nm-dbus-device.h"
#include "nm-device-802-3-ethernet.h"
#include "nm-device-802-11-wireless.h"
#include "nm-device-private.h"
#include "nm-dbus-net.h"
static DBusMessage *
new_invalid_device_type_error (DBusMessage *replyto)
{
return nm_dbus_create_error_message (replyto,
NM_DBUS_INTERFACE,
"InvalidDeviceType",
"Invalid device type for this"
"request.");
}
static DBusMessage *
nm_dbus_device_get_name (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData *data = (NMDbusCBData *) user_data;
DBusMessage *reply = NULL;
const char *iface;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->dev != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
iface = nm_device_get_iface (data->dev);
dbus_message_append_args (reply, DBUS_TYPE_STRING, &iface, DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *
nm_dbus_device_get_type (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData *data = (NMDbusCBData *) user_data;
DBusMessage *reply = NULL;
dbus_int32_t type;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->dev != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
type = nm_device_get_device_type (data->dev);
dbus_message_append_args (reply, DBUS_TYPE_INT32, &type, DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *
nm_dbus_device_get_hal_udi (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData *data = (NMDbusCBData *) user_data;
DBusMessage *reply = NULL;
const char *udi;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->dev != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
udi = nm_device_get_udi (data->dev);
dbus_message_append_args (reply, DBUS_TYPE_STRING, &udi, DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *
nm_dbus_device_get_ip4_address (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData *data = (NMDbusCBData *) user_data;
DBusMessage *reply = NULL;
dbus_uint32_t address;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->dev != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
address = nm_device_get_ip4_address (data->dev);
dbus_message_append_args (reply, DBUS_TYPE_UINT32, &address, DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *
nm_dbus_device_get_hw_address (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData *data = (NMDbusCBData *) user_data;
DBusMessage *reply = NULL;
struct ether_addr addr;
char char_addr[20];
char * ptr = &char_addr[0];
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->dev != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
memset (&addr, 0, sizeof (struct ether_addr));
if (NM_IS_DEVICE_802_3_ETHERNET (data->dev)) {
nm_device_802_3_ethernet_get_address (NM_DEVICE_802_3_ETHERNET (data->dev), &addr);
} else if (NM_IS_DEVICE_802_11_WIRELESS (data->dev)) {
nm_device_802_11_wireless_get_address (NM_DEVICE_802_11_WIRELESS (data->dev), &addr);
}
memset (char_addr, 0, 20);
iw_ether_ntop (&addr, char_addr);
dbus_message_append_args (reply, DBUS_TYPE_STRING, &ptr, DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *
nm_dbus_device_get_mode (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData *data = (NMDbusCBData *) user_data;
DBusMessage *reply = NULL;
dbus_int32_t mode;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->dev != NULL, NULL);
if (!NM_IS_DEVICE_802_11_WIRELESS (data->dev)) {
reply = new_invalid_device_type_error (message);
goto out;
}
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
goto out;
}
mode = (dbus_int32_t) nm_device_802_11_wireless_get_mode (NM_DEVICE_802_11_WIRELESS (data->dev));
dbus_message_append_args (reply, DBUS_TYPE_INT32, &mode, DBUS_TYPE_INVALID);
out:
return reply;
}
static DBusMessage *
nm_dbus_device_get_link_active (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData *data = (NMDbusCBData *) user_data;
DBusMessage *reply = NULL;
dbus_bool_t is_active;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->dev != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
is_active = nm_device_has_active_link (data->dev);
dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &is_active, DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *
nm_dbus_device_get_active_network (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData *data = (NMDbusCBData *) user_data;
DBusMessage *reply = NULL;
NMDevice * dev;
gboolean success = FALSE;
NMActRequest * req;
NMAccessPoint * ap;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->dev != NULL, NULL);
/* Only wireless devices have an active network */
dev = data->dev;
if (!NM_IS_DEVICE_802_11_WIRELESS (dev))
{
reply = new_invalid_device_type_error (message);
goto out;
}
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
goto out;
}
req = nm_device_get_act_request (dev);
if (req && (ap = nm_act_request_get_ap (req))) {
NMAccessPoint *tmp_ap;
char * object_path = NULL;
tmp_ap = nm_device_802_11_wireless_ap_list_get_ap_by_essid (NM_DEVICE_802_11_WIRELESS (dev), nm_ap_get_essid (ap));
if (tmp_ap && (object_path = nm_dbus_get_object_path_for_network (dev, tmp_ap))) {
dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID);
g_free (object_path);
success = TRUE;
}
}
if (!success) {
dbus_message_unref (reply);
reply = nm_dbus_create_error_message (message,
NM_DBUS_INTERFACE,
"NoActiveNetwork",
"The device is not associated "
" with any networks at this time.");
}
out:
return reply;
}
static DBusMessage *
nm_dbus_device_get_networks (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData *data = (NMDbusCBData *) user_data;
DBusMessage * reply = NULL;
NMDevice * dev;
DBusMessageIter iter;
DBusMessageIter iter_array;
NMAccessPoint * ap = NULL;
gboolean success = FALSE;
NMAccessPointList * ap_list;
NMAPListIter * list_iter;
char * escaped_object_path;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->dev != NULL, NULL);
if (!NM_IS_DEVICE_802_11_WIRELESS (data->dev)) {
reply = new_invalid_device_type_error (message);
goto out;
}
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
goto out;
}
dbus_message_iter_init_append (reply, &iter);
dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter_array);
dev = data->dev;
if ((ap_list = nm_device_802_11_wireless_ap_list_get (NM_DEVICE_802_11_WIRELESS (dev)))) {
if ((list_iter = nm_ap_list_iter_new (ap_list))) {
while ((ap = nm_ap_list_iter_next (list_iter))) {
if (nm_ap_get_essid (ap)) {
escaped_object_path = nm_dbus_get_object_path_for_network (dev, ap);
dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_OBJECT_PATH, &escaped_object_path);
g_free (escaped_object_path);
success = TRUE;
}
}
nm_ap_list_iter_free (list_iter);
}
}
dbus_message_iter_close_container (&iter, &iter_array);
if (!success) {
dbus_message_unref (reply);
reply = nm_dbus_create_error_message (message, NM_DBUS_INTERFACE, "NoNetworks",
"The device cannot see any wireless networks.");
}
out:
return reply;
}
static DBusMessage *
nm_dbus_device_get_capabilities (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData *data = (NMDbusCBData *) user_data;
DBusMessage *reply = NULL;
dbus_uint32_t capabilities;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->dev != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
capabilities = nm_device_get_capabilities (data->dev);
dbus_message_append_args (reply, DBUS_TYPE_UINT32, &capabilities, DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *
nm_dbus_device_get_driver (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData *data = (NMDbusCBData *) user_data;
DBusMessage *reply = NULL;
const char * driver;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->dev != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
driver = nm_device_get_driver (data->dev);
if (!driver)
driver = "";
dbus_message_append_args (reply, DBUS_TYPE_STRING, &driver, DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *
nm_dbus_device_set_link_active (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData *data = (NMDbusCBData *) user_data;
DBusMessage *reply = NULL;
gboolean have_link;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->dev != NULL, NULL);
g_return_val_if_fail (data->data != NULL, NULL);
/* Can only set link status for test devices */
if (!nm_device_is_test_device (data->dev))
{
reply = nm_dbus_create_error_message (message,
NM_DBUS_INTERFACE,
"NotTestDevice",
"Only test devices can have their"
" link status set manually.");
goto out;
}
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
goto out;
}
if (!dbus_message_get_args (message, NULL,
DBUS_TYPE_BOOLEAN, &have_link,
DBUS_TYPE_INVALID)) {
reply = nm_dbus_new_invalid_args_error (message, NM_DBUS_INTERFACE);
goto out;
}
nm_device_set_active_link (data->dev, have_link);
out:
return reply;
}
static DBusMessage *
nm_dbus_device_get_properties (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData * data = (NMDbusCBData *) user_data;
DBusMessage * reply = NULL;
NMDevice * dev;
char * op;
const char * iface;
dbus_uint32_t type;
const char * udi;
gchar * ip4_address;
gchar * broadcast;
gchar * subnetmask;
gchar * route;
gchar * primary_dns;
gchar * secondary_dns;
struct ether_addr hw_addr;
char hw_addr_buf[20];
char * hw_addr_buf_ptr = &hw_addr_buf[0];
dbus_int32_t mode = -1;
dbus_int32_t strength = -1;
dbus_int32_t speed = 0;
char * active_network_path = NULL;
dbus_bool_t link_active;
dbus_uint32_t capabilities;
dbus_uint32_t type_capabilities;
char ** networks = NULL;
int num_networks = 0;
dbus_bool_t active;
NMActStage act_stage;
NMIP4Config * ip4config;
guint32 broadcast_addr = 0;
guint32 subnetmask_addr = 0;
guint32 route_addr = 0;
guint32 primary_dns_addr = 0;
guint32 secondary_dns_addr = 0;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->dev != NULL, NULL);
g_return_val_if_fail (data->data != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
goto out;
}
dev = data->dev;
op = nm_dbus_get_object_path_for_device (dev);
iface = nm_device_get_iface (dev);
type = nm_device_get_device_type (dev);
udi = nm_device_get_udi (dev);
link_active = (dbus_bool_t) nm_device_has_active_link (dev);
capabilities = (dbus_uint32_t) nm_device_get_capabilities (dev);
type_capabilities = (dbus_uint32_t) nm_device_get_type_capabilities (dev);
active = nm_device_get_act_request (dev) ? TRUE : FALSE;
act_stage = active ? nm_act_request_get_stage (nm_device_get_act_request (dev)) : NM_ACT_STAGE_UNKNOWN;
memset (hw_addr_buf, 0, 20);
if (NM_IS_DEVICE_802_3_ETHERNET (dev))
nm_device_802_3_ethernet_get_address (NM_DEVICE_802_3_ETHERNET (dev), &hw_addr);
else if (NM_IS_DEVICE_802_11_WIRELESS (dev))
nm_device_802_11_wireless_get_address (NM_DEVICE_802_11_WIRELESS (dev), &hw_addr);
iw_ether_ntop (&hw_addr, hw_addr_buf);
ip4config = nm_device_get_ip4_config (dev);
if (ip4config) {
guint32 nr_nameservers;
broadcast_addr = nm_ip4_config_get_broadcast (ip4config);
subnetmask_addr = nm_ip4_config_get_netmask (ip4config);
route_addr = nm_ip4_config_get_gateway (ip4config);
nr_nameservers = nm_ip4_config_get_num_nameservers (ip4config);
if (nr_nameservers > 1)
secondary_dns_addr = nm_ip4_config_get_nameserver (ip4config, 1);
if (nr_nameservers > 0)
primary_dns_addr = nm_ip4_config_get_nameserver (ip4config, 0);
}
ip4_address = nm_utils_inet_ip4_address_as_string (nm_device_get_ip4_address (dev));
broadcast = nm_utils_inet_ip4_address_as_string (broadcast_addr);
subnetmask = nm_utils_inet_ip4_address_as_string (subnetmask_addr);
route = nm_utils_inet_ip4_address_as_string (route_addr);
primary_dns = nm_utils_inet_ip4_address_as_string (primary_dns_addr);
secondary_dns = nm_utils_inet_ip4_address_as_string (secondary_dns_addr);
if (NM_IS_DEVICE_802_11_WIRELESS (dev)) {
NMDevice80211Wireless * wdev = NM_DEVICE_802_11_WIRELESS (dev);
NMActRequest * req = nm_device_get_act_request (dev);
NMAccessPoint * ap;
NMAccessPointList * ap_list;
NMAPListIter * iter;
strength = nm_device_802_11_wireless_get_signal_strength (wdev);
mode = nm_device_802_11_wireless_get_mode (wdev);
speed = nm_device_802_11_wireless_get_bitrate (wdev);
if (req && (ap = nm_act_request_get_ap (req))) {
NMAccessPoint *tmp_ap;
if ((tmp_ap = nm_device_802_11_wireless_ap_list_get_ap_by_essid (wdev, nm_ap_get_essid (ap))))
active_network_path = nm_dbus_get_object_path_for_network (dev, tmp_ap);
}
ap_list = nm_device_802_11_wireless_ap_list_get (wdev);
if (ap_list && (num_networks = nm_ap_list_size (ap_list))) {
if ((iter = nm_ap_list_iter_new (ap_list))) {
int i = 0;
networks = g_malloc0 (sizeof (char *) * (num_networks + 1));
while ((ap = nm_ap_list_iter_next (iter))) {
char *ap_op = nm_dbus_get_object_path_for_network (dev, ap);
if (ap_op)
networks[i++] = ap_op;
}
num_networks = i; /* # actually added to array, since we can have NULL essid access points */
nm_ap_list_iter_free (iter);
}
}
} else {
speed = nm_device_802_3_ethernet_get_speed (NM_DEVICE_802_3_ETHERNET (dev));
}
if (!active_network_path)
active_network_path = g_strdup ("");
dbus_message_append_args (reply,
DBUS_TYPE_OBJECT_PATH, &op,
DBUS_TYPE_STRING, &iface,
DBUS_TYPE_UINT32, &type,
DBUS_TYPE_STRING, &udi,
DBUS_TYPE_BOOLEAN,&active,
DBUS_TYPE_UINT32, &act_stage,
DBUS_TYPE_STRING, &ip4_address,
DBUS_TYPE_STRING, &subnetmask,
DBUS_TYPE_STRING, &broadcast,
DBUS_TYPE_STRING, &hw_addr_buf_ptr,
DBUS_TYPE_STRING, &route,
DBUS_TYPE_STRING, &primary_dns,
DBUS_TYPE_STRING, &secondary_dns,
DBUS_TYPE_INT32, &mode,
DBUS_TYPE_INT32, &strength,
DBUS_TYPE_BOOLEAN,&link_active,
DBUS_TYPE_INT32, &speed,
DBUS_TYPE_UINT32, &capabilities,
DBUS_TYPE_UINT32, &type_capabilities,
DBUS_TYPE_STRING, &active_network_path,
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &networks, num_networks,
DBUS_TYPE_INVALID);
g_free (op);
g_free (active_network_path);
g_strfreev (networks);
g_free (route);
g_free (ip4_address);
g_free (broadcast);
g_free (subnetmask);
out:
return reply;
}
/*
* nm_dbus_devices_message_handler
*
* Dispatch messages against individual network devices
*
*/
static DBusHandlerResult
nm_dbus_device_message_handler (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
NMData * data = (NMData *)user_data;
gboolean handled = FALSE;
const char * path;
DBusMessage * reply = NULL;
NMDevice * dev;
char * object_path;
char * escaped_object_path;
NMDbusCBData * cb_data;
g_return_val_if_fail (connection != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
g_return_val_if_fail (message != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
g_return_val_if_fail (data != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
path = dbus_message_get_path (message);
if (!(dev = nm_dbus_get_device_from_escaped_object_path (data, path))) {
reply = nm_dbus_create_error_message (message,
NM_DBUS_INTERFACE,
"DeviceNotFound",
"The requested device does not "
" exist.");
goto out;
}
/* Test whether or not the _networks_ of a device were queried instead of the device itself */
object_path = g_strdup_printf ("%s/%s/Networks/",
NM_DBUS_PATH_DEVICE,
nm_device_get_iface (dev));
escaped_object_path = nm_dbus_escape_object_path (object_path);
g_free (object_path);
cb_data = g_slice_new0 (NMDbusCBData);
cb_data->data = data;
cb_data->dev = dev;
if (strncmp (path, escaped_object_path, strlen (escaped_object_path)) == 0) {
handled = nm_dbus_net_methods_dispatch (data->net_methods,
connection,
message,
cb_data,
&reply);
} else {
handled = nm_dbus_method_list_dispatch (data->device_methods,
connection,
message,
cb_data,
&reply);
}
g_object_unref (G_OBJECT (cb_data->dev));
g_slice_free (NMDbusCBData, cb_data);
g_free (escaped_object_path);
out:
if (reply)
{
dbus_connection_send (connection, reply, NULL);
dbus_message_unref (reply);
handled = TRUE;
}
return (handled ? DBUS_HANDLER_RESULT_HANDLED : DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
}
/*
* nm_dbus_device_methods_setup
*
* Register handlers for dbus methods on the org.freedesktop.NetworkManager.Devices object.
*
*/
NMDbusMethodList *nm_dbus_device_methods_setup (NMData *data)
{
NMDbusMethodList * list;
g_return_val_if_fail (data != NULL, NULL);
list = nm_dbus_method_list_new (NM_DBUS_PATH_DEVICE, TRUE, data, NULL);
nm_dbus_method_list_set_custom_handler_func (list, nm_dbus_device_message_handler);
nm_dbus_method_list_add_method (list, "getProperties", nm_dbus_device_get_properties);
nm_dbus_method_list_add_method (list, "getName", nm_dbus_device_get_name);
nm_dbus_method_list_add_method (list, "getType", nm_dbus_device_get_type);
nm_dbus_method_list_add_method (list, "getHalUdi", nm_dbus_device_get_hal_udi);
nm_dbus_method_list_add_method (list, "getIP4Address", nm_dbus_device_get_ip4_address);
nm_dbus_method_list_add_method (list, "getHWAddress", nm_dbus_device_get_hw_address);
nm_dbus_method_list_add_method (list, "getMode", nm_dbus_device_get_mode);
nm_dbus_method_list_add_method (list, "getActiveNetwork", nm_dbus_device_get_active_network);
nm_dbus_method_list_add_method (list, "getNetworks", nm_dbus_device_get_networks);
nm_dbus_method_list_add_method (list, "getLinkActive", nm_dbus_device_get_link_active);
nm_dbus_method_list_add_method (list, "setLinkActive", nm_dbus_device_set_link_active);
nm_dbus_method_list_add_method (list, "getCapabilities", nm_dbus_device_get_capabilities);
nm_dbus_method_list_add_method (list, "getDriver", nm_dbus_device_get_driver);
return (list);
}

29
src/nm-dbus-device.h
View file

@ -1,29 +0,0 @@
/* NetworkManager -- Network link manager
*
* Dan Williams <dcbw@redhat.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* (C) Copyright 2005 Red Hat, Inc.
*/
#ifndef NM_DBUS_DEVICE_H
#define NM_DBUS_DEVICE_H
NMDbusMethodList *nm_dbus_device_methods_setup (NMData *data);
#endif

403
src/nm-dbus-net.c
View file

@ -1,403 +0,0 @@
/* NetworkManager -- Network link manager
*
* Dan Williams <dcbw@redhat.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* (C) Copyright 2005 Red Hat, Inc.
*/
#include "nm-device.h"
#include "nm-device-802-11-wireless.h"
#include "NetworkManagerDbus.h"
#include "NetworkManagerAP.h"
#include "NetworkManagerAPList.h"
#include "NetworkManagerUtils.h"
#include "nm-dbus-net.h"
#include "nm-utils.h"
#include "nm-device-private.h"
/*
* nm_dbus_get_ap_from_object_path
*
* Returns the network (ap) associated with a dbus object path
*
*/
static NMAccessPoint *
nm_dbus_get_ap_from_object_path (const char *path,
NMDevice *dev)
{
NMAccessPoint * ap = NULL;
NMAccessPointList * ap_list;
NMAPListIter * iter;
char compare_path[100];
char * escaped_compare_path;
g_return_val_if_fail (path != NULL, NULL);
g_return_val_if_fail (dev != NULL, NULL);
ap_list = nm_device_802_11_wireless_ap_list_get (NM_DEVICE_802_11_WIRELESS (dev));
if (!ap_list)
return NULL;
if (!(iter = nm_ap_list_iter_new (ap_list)))
return NULL;
while ((ap = nm_ap_list_iter_next (iter))) {
int len;
snprintf (compare_path, 100, "%s/%s/Networks/%s", NM_DBUS_PATH_DEVICE,
nm_device_get_iface (dev), nm_ap_get_essid (ap));
escaped_compare_path = nm_dbus_escape_object_path (compare_path);
len = strlen(escaped_compare_path);
if (strncmp (path, escaped_compare_path, len) == 0) {
/* Differentiate between 'foo' and 'foo-a' */
if (path[len] == '\0' || path[len] == '/') {
g_free (escaped_compare_path);
break;
}
}
g_free (escaped_compare_path);
}
nm_ap_list_iter_free (iter);
return ap;
}
static DBusMessage *
nm_dbus_net_get_name (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData * data = (NMDbusCBData *) user_data;
DBusMessage *reply = NULL;
const char *essid;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->ap != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
essid = nm_ap_get_essid (data->ap);
dbus_message_append_args (reply, DBUS_TYPE_STRING, &essid, DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *
nm_dbus_net_get_address (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData * data = (NMDbusCBData *) user_data;
DBusMessage * reply = NULL;
char buf[20];
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->ap != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
memset (&buf[0], 0, 20);
iw_ether_ntop((const struct ether_addr *) (nm_ap_get_address (data->ap)), &buf[0]);
dbus_message_append_args (reply, DBUS_TYPE_STRING, &buf, DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *
nm_dbus_net_get_strength (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData * data = (NMDbusCBData *) user_data;
DBusMessage * reply = NULL;
NMAccessPoint * tmp_ap = NULL;
NMAccessPointList * ap_list;
NMAPListIter * iter;
int best_strength;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->ap != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
/* We iterate over the device list and return the best strength for all
* APs with the given ESSID.
*/
best_strength = nm_ap_get_strength (data->ap);
if (!(ap_list = nm_device_802_11_wireless_ap_list_get (NM_DEVICE_802_11_WIRELESS (data->dev))))
goto append;
if (!(iter = nm_ap_list_iter_new (ap_list)))
goto append;
/* Find best strength # among all APs that share this essid */
while ((tmp_ap = nm_ap_list_iter_next (iter))) {
if (nm_null_safe_strcmp (nm_ap_get_essid (data->ap), nm_ap_get_essid (tmp_ap)) == 0)
if (nm_ap_get_strength (tmp_ap) > best_strength)
best_strength = nm_ap_get_strength (tmp_ap);
}
nm_ap_list_iter_free (iter);
append:
dbus_message_append_args (reply, DBUS_TYPE_INT32, &best_strength, DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *
nm_dbus_net_get_frequency (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData * data = (NMDbusCBData *) user_data;
DBusMessage * reply = NULL;
double freq;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->ap != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
freq = nm_ap_get_freq (data->ap);
dbus_message_append_args (reply, DBUS_TYPE_DOUBLE, &freq, DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *
nm_dbus_net_get_rate (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData * data = (NMDbusCBData *) user_data;
DBusMessage * reply = NULL;
dbus_int32_t rate;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->ap != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
rate = nm_ap_get_rate (data->ap);
dbus_message_append_args (reply, DBUS_TYPE_INT32, &rate, DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *
nm_dbus_net_get_encrypted (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData * data = (NMDbusCBData *) user_data;
DBusMessage * reply = NULL;
dbus_bool_t is_encrypted;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->ap != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
is_encrypted = nm_ap_get_encrypted (data->ap);
dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &is_encrypted, DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *
nm_dbus_net_get_mode (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData * data = (NMDbusCBData *) user_data;
DBusMessage * reply = NULL;
dbus_int32_t mode;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->ap != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
mode = (dbus_int32_t) nm_ap_get_mode (data->ap);
dbus_message_append_args (reply, DBUS_TYPE_INT32, &mode, DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *
nm_dbus_net_get_properties (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMDbusCBData * data = (NMDbusCBData *) user_data;
DBusMessage * reply = NULL;
char * op;
const char * essid;
char hw_addr_buf[20];
char * hw_addr_buf_ptr = &hw_addr_buf[0];
dbus_int32_t strength;
double freq;
dbus_int32_t rate;
dbus_int32_t mode;
dbus_int32_t capabilities;
dbus_bool_t broadcast;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->ap != NULL, NULL);
g_return_val_if_fail (data->dev != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
op = nm_dbus_get_object_path_for_network (data->dev, data->ap);
essid = nm_ap_get_essid (data->ap);
strength = nm_ap_get_strength (data->ap);
freq = nm_ap_get_freq (data->ap);
rate = nm_ap_get_rate (data->ap);
mode = (dbus_int32_t) nm_ap_get_mode (data->ap);
capabilities = (dbus_int32_t) nm_ap_get_capabilities (data->ap);
broadcast = (dbus_bool_t) nm_ap_get_broadcast (data->ap);
memset (&hw_addr_buf[0], 0, 20);
if (nm_ap_get_address (data->ap))
iw_ether_ntop((const struct ether_addr *) (nm_ap_get_address (data->ap)), &hw_addr_buf[0]);
dbus_message_append_args (reply,
DBUS_TYPE_OBJECT_PATH, &op,
DBUS_TYPE_STRING, &essid,
DBUS_TYPE_STRING, &hw_addr_buf_ptr,
DBUS_TYPE_INT32, &strength,
DBUS_TYPE_DOUBLE, &freq,
DBUS_TYPE_INT32, &rate,
DBUS_TYPE_INT32, &mode,
DBUS_TYPE_INT32, &capabilities,
DBUS_TYPE_BOOLEAN, &broadcast,
DBUS_TYPE_INVALID);
g_free (op);
return reply;
}
gboolean
nm_dbus_net_methods_dispatch (NMDbusMethodList *list,
DBusConnection *connection,
DBusMessage *message,
gpointer user_data,
DBusMessage **reply)
{
NMDbusCBData * cb_data = (NMDbusCBData *) user_data;
const char * path;
NMAccessPoint * ap;
gboolean handled = FALSE;
g_return_val_if_fail (list != NULL, FALSE);
g_return_val_if_fail (connection != NULL, FALSE);
g_return_val_if_fail (message != NULL, FALSE);
g_return_val_if_fail (cb_data != NULL, FALSE);
g_return_val_if_fail (cb_data->dev != NULL, FALSE);
/* Figure out which network the request is for */
path = dbus_message_get_path (message);
if ((ap = nm_dbus_get_ap_from_object_path (path, cb_data->dev))) {
cb_data->ap = ap;
handled = nm_dbus_method_list_dispatch (list,
connection,
message,
cb_data,
reply);
} else {
*reply = nm_dbus_create_error_message (message,
NM_DBUS_INTERFACE,
"NetworkNotFound",
"The requested network does not "
"exist for this device.");
handled = TRUE;
}
return handled;
}
/*
* nm_dbus_net_methods_setup
*
* Register handlers for dbus methods on the
* org.freedesktop.NetworkManager.Devices.<dev>.Networks object.
*
*/
NMDbusMethodList *nm_dbus_net_methods_setup (NMData *data)
{
NMDbusMethodList * list;
g_return_val_if_fail (data != NULL, NULL);
list = nm_dbus_method_list_new ("", FALSE, data, NULL);
nm_dbus_method_list_add_method (list, "getProperties", nm_dbus_net_get_properties);
nm_dbus_method_list_add_method (list, "getName", nm_dbus_net_get_name);
nm_dbus_method_list_add_method (list, "getAddress", nm_dbus_net_get_address);
nm_dbus_method_list_add_method (list, "getStrength", nm_dbus_net_get_strength);
nm_dbus_method_list_add_method (list, "getFrequency", nm_dbus_net_get_frequency);
nm_dbus_method_list_add_method (list, "getRate", nm_dbus_net_get_rate);
nm_dbus_method_list_add_method (list, "getEncrypted", nm_dbus_net_get_encrypted);
nm_dbus_method_list_add_method (list, "getMode", nm_dbus_net_get_mode);
return (list);
}

37
src/nm-dbus-net.h
View file

@ -1,37 +0,0 @@
/* NetworkManager -- Network link manager
*
* Dan Williams <dcbw@redhat.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* (C) Copyright 2005 Red Hat, Inc.
*/
#ifndef NM_DBUS_NET_H
#define NM_DBUS_NET_H
#include "NetworkManagerDbusUtils.h"
#include "NetworkManagerMain.h"
NMDbusMethodList *nm_dbus_net_methods_setup (NMData *data);
gboolean nm_dbus_net_methods_dispatch (NMDbusMethodList *list,
DBusConnection *connection,
DBusMessage *message,
gpointer uesr_data,
DBusMessage **reply);
#endif

721
src/nm-dbus-nm.c
View file

@ -1,721 +0,0 @@
/* NetworkManager -- Network link manager
*
* Dan Williams <dcbw@redhat.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* (C) Copyright 2005 Red Hat, Inc.
*/
#include <glib.h>
#include <dbus/dbus.h>
#include <dbus/dbus-glib-lowlevel.h>
#include <dbus/dbus-glib.h>
#include <stdarg.h>
#include "nm-dbus-nm.h"
#include "nm-utils.h"
#include "NetworkManagerDbus.h"
#include "NetworkManagerDbusUtils.h"
#include "NetworkManagerUtils.h"
#include "NetworkManagerPolicy.h"
#include "NetworkManagerDialup.h"
#include "NetworkManagerSystem.h"
#include "NetworkManager.h"
#include "nm-ap-security.h"
#include "nm-device-interface.h"
#include "nm-device-802-3-ethernet.h"
#include "nm-device-802-11-wireless.h"
/*
* nm_dbus_nm_get_devices
*
* Returns a string array of object paths corresponding to the
* devices in the device list.
*
*/
static DBusMessage *
nm_dbus_nm_get_devices (DBusConnection *connection,
DBusMessage *message,
void * user_data)
{
NMData * data = (NMData *) user_data;
DBusMessage * reply = NULL;
DBusMessageIter iter;
DBusMessageIter iter_array;
GSList * elt;
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
/* Check for no devices */
if (!data->dev_list) {
return nm_dbus_create_error_message (message,
NM_DBUS_INTERFACE,
"NoDevices",
"There are no available network devices.");
}
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
dbus_message_iter_init_append (reply, &iter);
dbus_message_iter_open_container (&iter,
DBUS_TYPE_ARRAY,
DBUS_TYPE_OBJECT_PATH_AS_STRING,
&iter_array);
for (elt = data->dev_list; elt; elt = g_slist_next (elt)) {
NMDevice * dev = NM_DEVICE (elt->data);
char * op = nm_dbus_get_object_path_for_device (dev);
dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_OBJECT_PATH, &op);
g_free (op);
}
dbus_message_iter_close_container (&iter, &iter_array);
return reply;
}
static DBusMessage *
nm_dbus_nm_get_dialup (DBusConnection *connection,
DBusMessage *message,
void * user_data)
{
NMData * data = (NMData *) user_data;
DBusMessage * reply = NULL;
DBusMessageIter iter;
DBusMessageIter iter_array;
GSList * elt;
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
/* Check for no dialup devices */
if (!data->dialup_list) {
return nm_dbus_create_error_message (message,
NM_DBUS_INTERFACE,
"NoDialup",
"There are no available dialup devices.");
}
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
dbus_message_iter_init_append (reply, &iter);
dbus_message_iter_open_container (&iter,
DBUS_TYPE_ARRAY,
DBUS_TYPE_STRING_AS_STRING,
&iter_array);
for (elt = data->dialup_list; elt; elt = g_slist_next (elt)) {
NMDialUpConfig *config = (NMDialUpConfig *) elt->data;
dbus_message_iter_append_basic (&iter_array,
DBUS_TYPE_STRING, &config->name);
}
dbus_message_iter_close_container (&iter, &iter_array);
return reply;
}
static DBusMessage *
nm_dbus_nm_activate_dialup (DBusConnection *connection,
DBusMessage *message,
void * user_data)
{
NMData *data = (NMData *) user_data;
DBusMessage *reply = NULL;
const char *dialup;
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &dialup, DBUS_TYPE_INVALID))
{
reply = nm_dbus_new_invalid_args_error (message, NM_DBUS_INTERFACE);
goto out;
}
if (!nm_system_activate_dialup (data->dialup_list, dialup)) {
reply = nm_dbus_create_error_message (message,
NM_DBUS_INTERFACE,
"ActivationFailed",
"Failed to activate the dialup "
"device.");
} else {
data->modem_active = TRUE;
}
out:
return reply;
}
static DBusMessage *
nm_dbus_nm_deactivate_dialup (DBusConnection *connection,
DBusMessage *message,
void * user_data)
{
NMData *data = (NMData *) user_data;
DBusMessage *reply = NULL;
const char *dialup;
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
return NULL;
}
if (!dbus_message_get_args (message,
NULL,
DBUS_TYPE_STRING, &dialup,
DBUS_TYPE_INVALID)) {
reply = nm_dbus_new_invalid_args_error (message, NM_DBUS_INTERFACE);
goto out;
}
if (!nm_system_deactivate_dialup (data->dialup_list, dialup)) {
reply = nm_dbus_create_error_message (message,
NM_DBUS_INTERFACE,
"DeactivationFailed",
"Failed to deactivate the dialup "
" device.");
} else {
data->modem_active = FALSE;
}
out:
return reply;
}
/*
* nm_dbus_nm_set_active_device
*
* Notify the state modification handler that we want to lock to a specific
* device.
*
*/
static DBusMessage *
nm_dbus_nm_set_active_device (DBusConnection *connection,
DBusMessage *message,
void * user_data)
{
NMData * data = (NMData *) user_data;
NMDevice * dev = NULL;
DBusMessage * reply = NULL;
char * dev_path;
NMAccessPoint * ap = NULL;
DBusMessageIter iter;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
dbus_message_iter_init (message, &iter);
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_OBJECT_PATH) {
nm_warning ("%s:%d (%s): Invalid arguments (first arg type was not OBJECT_PATH).",
__FILE__, __LINE__, __func__);
goto out;
}
dbus_message_iter_get_basic (&iter, &dev_path);
dev = nm_dbus_get_device_from_escaped_object_path (data, dev_path);
/* Ensure the device exists in our list and is supported */
if (!dev || !(nm_device_get_capabilities (dev) & NM_DEVICE_CAP_NM_SUPPORTED)) {
reply = nm_dbus_create_error_message (message,
NM_DBUS_INTERFACE,
"DeviceNotFound",
"The requested network device "
"does not exist.");
nm_warning ("%s:%d (%s): Invalid device (device not found).", __FILE__,
__LINE__, __func__);
goto out;
}
nm_device_interface_deactivate (NM_DEVICE_INTERFACE (dev));
nm_schedule_state_change_signal_broadcast (data);
if (NM_IS_DEVICE_802_11_WIRELESS (dev)) {
NMAPSecurity * security = NULL;
char * essid = NULL;
gboolean fallback = FALSE;
if ( !dbus_message_iter_next (&iter)
|| (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING)) {
nm_warning ("%s:%d (%s): Invalid argument type (essid).", __FILE__,
__LINE__, __func__);
goto out;
}
/* grab ssid and ensure validity */
dbus_message_iter_get_basic (&iter, &essid);
if (!essid || (strlen (essid) <= 0)) {
nm_warning ("%s:%d (%s): Invalid argument (essid).",
__FILE__, __LINE__, __func__);
goto out;
}
if ( !dbus_message_iter_next (&iter)
|| (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_BOOLEAN)) {
nm_warning ("Invalid argument type (fallback");
goto out;
}
/* grab the fallback bit */
dbus_message_iter_get_basic (&iter, &fallback);
/* If there's security information, we use that. If not, we
* make some up from the scan list.
*/
if (dbus_message_iter_next (&iter)) {
if (!(security = nm_ap_security_new_deserialize (&iter))) {
/* There was security info, but it was invalid */
reply = nm_dbus_new_invalid_args_error (message, NM_DBUS_INTERFACE);
nm_warning ("%s:%d (%s): Invalid argument (wireless security "
"info).", __FILE__, __LINE__, __func__);
goto out;
}
}
/* Set up the wireless-specific activation request properties */
ap = nm_device_802_11_wireless_get_activation_ap (NM_DEVICE_802_11_WIRELESS (dev), essid, security);
nm_ap_set_fallback (ap, fallback);
if (security)
g_object_unref (G_OBJECT (security));
nm_info ("User Switch: %s / %s", dev_path, essid);
nm_device_802_11_wireless_activate (NM_DEVICE_802_11_WIRELESS (dev), ap, TRUE);
} else if (NM_IS_DEVICE_802_3_ETHERNET (dev)) {
nm_info ("User Switch: %s", dev_path);
nm_device_802_3_ethernet_activate (NM_DEVICE_802_3_ETHERNET (dev), TRUE);
} else {
nm_warning ("Unhandled device activation");
}
/* empty success message */
reply = dbus_message_new_method_return (message);
if (!reply)
nm_warning ("Could not allocate dbus message.");
out:
if (dev)
g_object_unref (G_OBJECT (dev));
if (!reply)
reply = nm_dbus_new_invalid_args_error (message, NM_DBUS_INTERFACE);
return reply;
}
/*
* nm_dbus_nm_create_wireless_network
*
* Create a new wireless network and
*
*/
static DBusMessage *
nm_dbus_nm_create_wireless_network (DBusConnection *connection,
DBusMessage *message,
void * user_data)
{
NMData * data = (NMData *) user_data;
NMDevice * dev = NULL;
DBusMessage * reply = NULL;
char * dev_path = NULL;
NMAccessPoint * new_ap = NULL;
NMAPSecurity * security = NULL;
char * essid = NULL;
DBusMessageIter iter;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
dbus_message_iter_init (message, &iter);
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_OBJECT_PATH) {
reply = nm_dbus_new_invalid_args_error (message, NM_DBUS_INTERFACE);
goto out;
}
dbus_message_iter_get_basic (&iter, &dev_path);
dev = nm_dbus_get_device_from_escaped_object_path (data, dev_path);
/* Ensure the device exists in our list and is supported */
if (!dev || !(nm_device_get_capabilities (dev) & NM_DEVICE_CAP_NM_SUPPORTED)) {
reply = nm_dbus_create_error_message (message,
NM_DBUS_INTERFACE,
"DeviceNotFound",
"The requested network device "
"does not exist.");
goto out;
}
if ( !NM_IS_DEVICE_802_11_WIRELESS (dev)
|| !dbus_message_iter_next (&iter)
|| (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING)) {
reply = nm_dbus_new_invalid_args_error (message, NM_DBUS_INTERFACE);
goto out;
}
/* grab ssid and ensure validity */
dbus_message_iter_get_basic (&iter, &essid);
if (!essid || (strlen (essid) <= 0) || !dbus_message_iter_next (&iter)) {
reply = nm_dbus_new_invalid_args_error (message, NM_DBUS_INTERFACE);
goto out;
}
if (!(security = nm_ap_security_new_deserialize (&iter))) {
reply = nm_dbus_new_invalid_args_error (message, NM_DBUS_INTERFACE);
goto out;
}
nm_info ("Creating network '%s' on device '%s'.", essid, dev_path);
new_ap = nm_ap_new ();
nm_ap_set_essid (new_ap, essid);
nm_ap_set_mode (new_ap, IW_MODE_ADHOC);
nm_ap_set_security (new_ap, security);
g_object_unref (G_OBJECT (security));
nm_ap_set_user_created (new_ap, TRUE);
nm_device_802_11_wireless_activate (NM_DEVICE_802_11_WIRELESS (dev), new_ap, TRUE);
out:
if (dev)
g_object_unref (G_OBJECT (dev));
return reply;
}
#if 0
static DBusMessage *
nm_dbus_nm_create_test_device (DBusConnection *connection,
DBusMessage *message,
void * user_data)
{
NMData * data = (NMData *) user_data;
NMDeviceType type;
DBusMessage *reply = NULL;
static int test_dev_num = 0;
NMDevice * dev;
char * iface;
char * udi;
char * dev_path;
char * escaped_dev_path;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
if (!dbus_message_get_args (message,
NULL,
DBUS_TYPE_INT32, &type,
DBUS_TYPE_INVALID)) {
reply = nm_dbus_new_invalid_args_error (message, NM_DBUS_INTERFACE);
goto out;
}
if ( (type != DEVICE_TYPE_802_3_ETHERNET)
&& (type == DEVICE_TYPE_802_11_WIRELESS)) {
reply = nm_dbus_new_invalid_args_error (message, NM_DBUS_INTERFACE);
goto out;
}
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
goto out;
}
iface = g_strdup_printf ("test%d", test_dev_num);
udi = g_strdup_printf ("/test-devices/%s", iface);
dev = nm_create_device_and_add_to_list (data, udi, iface, TRUE, type);
g_free (iface);
g_free (udi);
test_dev_num++;
dev_path = g_strdup_printf ("%s/%s", NM_DBUS_PATH_DEVICES, nm_device_get_iface (dev));
escaped_dev_path = nm_dbus_escape_object_path (dev_path);
g_free (dev_path);
dbus_message_append_args (reply, DBUS_TYPE_STRING, &escaped_dev_path, DBUS_TYPE_INVALID);
g_free (escaped_dev_path);
out:
return reply;
}
static DBusMessage *
nm_dbus_nm_remove_test_device (DBusConnection *connection,
DBusMessage *message,
void * user_data)
{
NMData * data = (NMData *) user_data;
DBusMessage *reply = NULL;
char * dev_path;
NMDevice * dev = NULL;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
if (!dbus_message_get_args (message,
NULL,
DBUS_TYPE_STRING, &dev_path,
DBUS_TYPE_INVALID)) {
reply = nm_dbus_new_invalid_args_error (message, NM_DBUS_INTERFACE);
goto out;
}
if (!(dev = nm_dbus_get_device_from_escaped_object_path (data, dev_path))) {
reply = nm_dbus_new_invalid_args_error (message, NM_DBUS_INTERFACE);
goto out;
}
if (!nm_device_is_test_device (dev)) {
reply = nm_dbus_create_error_message (message,
NM_DBUS_INTERFACE,
"NotTestDevice",
"Only test devices can be removed"
" via the DBus interface.");
goto out;
}
nm_remove_device (data, dev);
out:
if (dev)
g_object_unref (G_OBJECT (dev));
return reply;
}
#endif
static DBusMessage *
nm_dbus_nm_set_wireless_enabled (DBusConnection *connection,
DBusMessage *message,
void * user_data)
{
NMData * data = (NMData *) user_data;
gboolean enabled = FALSE;
DBusMessage * reply = NULL;
GSList * elt;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
if (!dbus_message_get_args (message,
NULL,
DBUS_TYPE_BOOLEAN, &enabled,
DBUS_TYPE_INVALID)) {
reply = nm_dbus_new_invalid_args_error (message, NM_DBUS_INTERFACE);
goto out;
}
data->wireless_enabled = enabled;
if (!enabled) {
/* Down all wireless devices */
for (elt = data->dev_list; elt; elt = g_slist_next (elt)) {
NMDevice * dev = NM_DEVICE (elt->data);
if (NM_IS_DEVICE_802_11_WIRELESS (dev)) {
nm_device_interface_deactivate (NM_DEVICE_INTERFACE (dev));
nm_device_bring_down (dev);
}
}
}
out:
return reply;
}
static DBusMessage *
nm_dbus_nm_get_wireless_enabled (DBusConnection *connection,
DBusMessage *message,
void * user_data)
{
NMData * data = (NMData *) user_data;
DBusMessage *reply = NULL;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
if ((reply = dbus_message_new_method_return (message))) {
dbus_message_append_args (reply,
DBUS_TYPE_BOOLEAN, &data->wireless_enabled,
DBUS_TYPE_INVALID);
}
return reply;
}
static DBusMessage *
nm_dbus_nm_sleep (DBusConnection *connection,
DBusMessage *message,
void * user_data)
{
NMData * data = (NMData *) user_data;
GSList * elt;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
if (data->asleep)
return NULL;
nm_info ("Going to sleep.");
data->asleep = TRUE;
/* Not using nm_schedule_state_change_signal_broadcast() here
* because we want the signal to go out ASAP.
*/
nm_dbus_signal_state_change (connection, NM_STATE_ASLEEP);
/* Just deactivate and down all devices from the device list,
* we'll remove them in 'wake' for speed's sake.
*/
for (elt = data->dev_list; elt; elt = g_slist_next (elt)) {
NMDevice *dev = NM_DEVICE (elt->data);
nm_device_set_removed (dev, TRUE);
nm_device_interface_deactivate (NM_DEVICE_INTERFACE (dev));
nm_system_device_set_up_down (dev, FALSE);
}
nm_system_deactivate_all_dialup (data->dialup_list);
data->modem_active = FALSE;
return NULL;
}
static DBusMessage *
nm_dbus_nm_wake (DBusConnection *connection,
DBusMessage *message,
void * user_data)
{
NMData * data = (NMData *) user_data;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
if (!data->asleep)
return NULL;
nm_info ("Waking up from sleep.");
data->asleep = FALSE;
/* Remove all devices from the device list */
/* FIXME: Well, not really. This whole file will be gone soon. */
#if 0
while (g_slist_length (data->dev_list))
nm_remove_device (data, NM_DEVICE (data->dev_list->data));
g_slist_free (data->dev_list);
data->dev_list = NULL;
nm_add_initial_devices (data);
#endif
nm_schedule_state_change_signal_broadcast (data);
return NULL;
}
static DBusMessage *
nm_dbus_nm_get_state (DBusConnection *connection,
DBusMessage *message,
void * user_data)
{
NMData * data = (NMData *) user_data;
DBusMessage * reply = NULL;
NMState state;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (message != NULL, NULL);
g_return_val_if_fail (data != NULL, NULL);
if (!(reply = dbus_message_new_method_return (message))) {
nm_warning ("Not enough memory to create dbus message.");
goto out;
}
/* FIXME: This function is deprecated and doesn't work anymore */
state = NM_STATE_UNKNOWN;
dbus_message_append_args (reply, DBUS_TYPE_UINT32, &state, DBUS_TYPE_INVALID);
out:
return reply;
}
/*
* nm_dbus_nm_methods_setup
*
* Register handlers for dbus methods on the org.freedesktop.NetworkManager object.
*
*/
NMDbusMethodList *nm_dbus_nm_methods_setup (NMData *data)
{
NMDbusMethodList * list;
g_return_val_if_fail (data != NULL, NULL);
list = nm_dbus_method_list_new (NM_DBUS_PATH, FALSE, data, NULL);
nm_dbus_method_list_add_method (list, "getDevices", nm_dbus_nm_get_devices);
nm_dbus_method_list_add_method (list, "getDialup", nm_dbus_nm_get_dialup);
nm_dbus_method_list_add_method (list, "activateDialup", nm_dbus_nm_activate_dialup);
nm_dbus_method_list_add_method (list, "deactivateDialup", nm_dbus_nm_deactivate_dialup);
nm_dbus_method_list_add_method (list, "setActiveDevice", nm_dbus_nm_set_active_device);
nm_dbus_method_list_add_method (list, "createWirelessNetwork", nm_dbus_nm_create_wireless_network);
nm_dbus_method_list_add_method (list, "setWirelessEnabled", nm_dbus_nm_set_wireless_enabled);
nm_dbus_method_list_add_method (list, "getWirelessEnabled", nm_dbus_nm_get_wireless_enabled);
nm_dbus_method_list_add_method (list, "sleep", nm_dbus_nm_sleep);
nm_dbus_method_list_add_method (list, "wake", nm_dbus_nm_wake);
nm_dbus_method_list_add_method (list, "state", nm_dbus_nm_get_state);
#if 0
nm_dbus_method_list_add_method (list, "createTestDevice", nm_dbus_nm_create_test_device);
nm_dbus_method_list_add_method (list, "removeTestDevice", nm_dbus_nm_remove_test_device);
#endif
return list;
}

31
src/nm-dbus-nm.h
View file

@ -1,31 +0,0 @@
/* NetworkManager -- Network link manager
*
* Dan Williams <dcbw@redhat.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* (C) Copyright 2005 Red Hat, Inc.
*/
#ifndef NM_DBUS_NM_H
#define NM_DBUS_NM_H
#include "NetworkManagerMain.h"
#include "NetworkManagerDbusUtils.h"
NMDbusMethodList *nm_dbus_nm_methods_setup (NMData *data);
#endif

29
src/nm-device-802-11-wireless.c
View file

@ -276,6 +276,8 @@ nm_device_802_11_wireless_update_signal_strength (NMDevice80211Wireless *self)
NMSock * sk;
iwrange range;
iwstats stats;
NMActRequest *req;
NMAccessPoint *ap = NULL;
int percent = -1;
g_return_if_fail (self != NULL);
@ -287,7 +289,12 @@ nm_device_802_11_wireless_update_signal_strength (NMDevice80211Wireless *self)
/* If we aren't the active device, we don't really have a signal strength
* that would mean anything.
*/
if (!nm_device_get_act_request (NM_DEVICE (self))) {
req = nm_device_get_act_request (NM_DEVICE (self));
if (req)
ap = nm_act_request_get_ap (req);
if (!ap) {
self->priv->strength = -1;
return;
}
@ -320,7 +327,7 @@ nm_device_802_11_wireless_update_signal_strength (NMDevice80211Wireless *self)
self->priv->invalid_strength_counter = 0;
if (percent != self->priv->strength)
nm_dbus_signal_device_strength_change (self, percent);
nm_ap_set_strength (ap, (gint8) percent);
self->priv->strength = percent;
}
@ -1896,9 +1903,8 @@ request_wireless_scan (gpointer user_data)
/* Reschedule ourselves if all wireless is disabled, we're asleep,
* or we are currently activating.
*/
if ( (app_data->wireless_enabled == FALSE)
|| (app_data->asleep == TRUE)
|| (nm_device_is_activating (NM_DEVICE (self)) == TRUE))
/* FIXME: Make sure we're allowed to scan: is networking enabled? is wireless enabled? */
if (nm_device_is_activating (NM_DEVICE (self)))
{
nm_device_802_11_wireless_set_scan_interval (app_data, self, NM_WIRELESS_SCAN_INTERVAL_INIT);
schedule_scan (self);
@ -2187,8 +2193,6 @@ merge_scanned_ap (NMDevice80211Wireless *dev,
/* Did the AP's name change? */
if (!devlist_essid || !merge_essid || nm_null_safe_strcmp (devlist_essid, merge_essid)) {
network_removed (dev, list_ap);
nm_dbus_signal_wireless_network_change (dev, list_ap,
NETWORK_STATUS_DISAPPEARED, -1);
new = TRUE;
}
@ -2250,11 +2254,6 @@ merge_scanned_ap (NMDevice80211Wireless *dev,
list_ap = merge_ap;
new = TRUE;
}
if (list_ap && new) {
nm_dbus_signal_wireless_network_change (dev, list_ap,
NETWORK_STATUS_APPEARED, -1);
}
}
static void
@ -2308,7 +2307,6 @@ cull_scan_list (NMDevice80211Wireless * self)
if (!(outdated_ap = (NMAccessPoint *)(elt->data)))
continue;
network_removed (self, outdated_ap);
nm_dbus_signal_wireless_network_change (self, outdated_ap, NETWORK_STATUS_DISAPPEARED, -1);
nm_ap_list_remove_ap (nm_device_802_11_wireless_ap_list_get (self), outdated_ap);
}
g_slist_free (outdated_list);
@ -2465,7 +2463,6 @@ link_timeout_cb (gpointer user_data)
if (nm_device_is_activating (dev)) {
cleanup_association_attempt (self, TRUE);
nm_device_state_changed (dev, NM_DEVICE_STATE_FAILED);
nm_policy_schedule_activation_failed (req);
}
return FALSE;
}
@ -2729,9 +2726,7 @@ supplicant_mgr_state_cb_handler (gpointer user_data)
nm_device_set_active_link (NM_DEVICE (self), FALSE);
if (nm_device_is_activating (dev)) {
NMActRequest * req = nm_device_get_act_request (dev);
nm_device_state_changed (dev, NM_DEVICE_STATE_FAILED);
nm_policy_schedule_activation_failed (req);
}
}
} else if (new_state == NM_SUPPLICANT_MANAGER_STATE_IDLE) {
@ -2789,7 +2784,6 @@ supplicant_iface_connection_error_cb_handler (gpointer user_data)
cleanup_association_attempt (self, TRUE);
nm_device_state_changed (NM_DEVICE (self), NM_DEVICE_STATE_FAILED);
nm_policy_schedule_activation_failed (req);
out:
g_free (cb_data->name);
@ -2874,7 +2868,6 @@ supplicant_connection_timeout_cb (gpointer user_data)
nm_device_get_iface (dev));
nm_device_state_changed (dev, NM_DEVICE_STATE_FAILED);
nm_policy_schedule_activation_failed (nm_device_get_act_request (dev));
}
}

68
src/nm-device-802-3-ethernet.c
View file

@ -35,6 +35,7 @@
#include "NetworkManagerUtils.h"
#include "NetworkManagerPolicy.h"
#include "nm-supplicant-manager.h"
#include "nm-netlink-monitor.h"
#include "nm-utils.h"
#include "kernel-types.h"
@ -73,12 +74,12 @@ enum {
static gboolean supports_mii_carrier_detect (NMDevice8023Ethernet *dev);
static gboolean supports_ethtool_carrier_detect (NMDevice8023Ethernet *dev);
static void nm_device_802_3_ethernet_link_activated (NmNetlinkMonitor *monitor,
GObject *obj,
NMDevice8023Ethernet *self);
static void nm_device_802_3_ethernet_link_deactivated (NmNetlinkMonitor *monitor,
GObject *obj,
NMDevice8023Ethernet *self);
static void nm_device_802_3_ethernet_link_activated (NMNetlinkMonitor *monitor,
const char *iface,
gpointer user_data);
static void nm_device_802_3_ethernet_link_deactivated (NMNetlinkMonitor *monitor,
const char *iface,
gpointer user_data);
static void supplicant_iface_state_cb (NMSupplicantInterface * iface,
guint32 new_state,
@ -103,19 +104,18 @@ real_init (NMDevice *dev)
{
NMDevice8023Ethernet * self = NM_DEVICE_802_3_ETHERNET (dev);
NMData * app_data;
NmNetlinkMonitor * monitor;
NMNetlinkMonitor * monitor;
NMSupplicantManager * sup_mgr;
app_data = nm_device_get_app_data (NM_DEVICE (self));
monitor = app_data->netlink_monitor;
monitor = nm_netlink_monitor_get ();
self->priv->link_connected_id =
g_signal_connect (G_OBJECT (monitor), "interface-connected",
G_CALLBACK (nm_device_802_3_ethernet_link_activated), self);
self->priv->link_connected_id = g_signal_connect (monitor, "interface-connected",
G_CALLBACK (nm_device_802_3_ethernet_link_activated), self);
self->priv->link_disconnected_id =
g_signal_connect (G_OBJECT (monitor), "interface-disconnected",
G_CALLBACK (nm_device_802_3_ethernet_link_deactivated), self);
self->priv->link_disconnected_id = g_signal_connect (monitor, "interface-disconnected",
G_CALLBACK (nm_device_802_3_ethernet_link_deactivated), self);
g_object_unref (monitor);
sup_mgr = nm_supplicant_manager_get ();
self->priv->sup_iface = nm_supplicant_manager_get_iface (sup_mgr,
@ -134,32 +134,28 @@ real_init (NMDevice *dev)
}
static void
nm_device_802_3_ethernet_link_activated (NmNetlinkMonitor *monitor,
GObject *obj,
NMDevice8023Ethernet *self)
nm_device_802_3_ethernet_link_activated (NMNetlinkMonitor *monitor,
const char *iface,
gpointer user_data)
{
NMDevice * dev = NM_DEVICE (self);
NMDevice *dev = NM_DEVICE (user_data);
/* Make sure signal is for us */
if (dev != NM_DEVICE (obj))
return;
nm_device_set_active_link (dev, TRUE);
if (!strcmp (nm_device_get_iface (dev), iface))
nm_device_set_active_link (dev, TRUE);
}
static void
nm_device_802_3_ethernet_link_deactivated (NmNetlinkMonitor *monitor,
GObject *obj,
NMDevice8023Ethernet *self)
nm_device_802_3_ethernet_link_deactivated (NMNetlinkMonitor *monitor,
const char *iface,
gpointer user_data)
{
NMDevice * dev = NM_DEVICE (self);
NMDevice *dev = NM_DEVICE (user_data);
/* Make sure signal is for us */
if (dev != NM_DEVICE (obj))
return;
nm_device_set_active_link (dev, FALSE);
if (!strcmp (nm_device_get_iface (dev), iface))
nm_device_set_active_link (dev, FALSE);
}
static gboolean
@ -365,8 +361,8 @@ static void
nm_device_802_3_ethernet_dispose (GObject *object)
{
NMDevice8023Ethernet * self = NM_DEVICE_802_3_ETHERNET (object);
NMData * data = nm_device_get_app_data (NM_DEVICE (self));
NMSupplicantManager * sup_mgr;
NMNetlinkMonitor *monitor;
if (self->priv->dispose_has_run)
/* If dispose did already run, return. */
@ -386,10 +382,12 @@ nm_device_802_3_ethernet_dispose (GObject *object)
self->priv->sup_iface = NULL;
g_object_unref (sup_mgr);
g_signal_handler_disconnect (G_OBJECT (data->netlink_monitor),
self->priv->link_connected_id);
g_signal_handler_disconnect (G_OBJECT (data->netlink_monitor),
self->priv->link_disconnected_id);
monitor = nm_netlink_monitor_get ();
g_signal_handler_disconnect (monitor,
self->priv->link_connected_id);
g_signal_handler_disconnect (monitor,
self->priv->link_disconnected_id);
g_object_unref (monitor);
if (self->priv->link_source_id) {
g_source_remove (self->priv->link_source_id);

2
src/nm-device-802-3-ethernet.h
View file

@ -42,7 +42,7 @@ typedef struct _NMDevice8023Ethernet NMDevice8023Ethernet;
typedef struct _NMDevice8023EthernetClass NMDevice8023EthernetClass;
typedef struct _NMDevice8023EthernetPrivate NMDevice8023EthernetPrivate;
#define NM_DEVICE_802_3_ETHERNET_HW_ADDRESS "hw_address"
#define NM_DEVICE_802_3_ETHERNET_HW_ADDRESS "hw-address"
#define NM_DEVICE_802_3_ETHERNET_SPEED "speed"
struct _NMDevice8023Ethernet

94
src/nm-device.c
View file

@ -34,7 +34,6 @@
#include "NetworkManagerPolicy.h"
#include "NetworkManagerUtils.h"
#include "NetworkManagerSystem.h"
#include "nm-vpn-manager.h"
#include "nm-dhcp-manager.h"
#include "nm-dbus-manager.h"
#include "nm-dbus-nmi.h"
@ -212,61 +211,6 @@ nm_device_stop (NMDevice *self)
}
/*
* nm_get_device_by_udi
*
* Search through the device list for a device with a given UDI.
*
*/
NMDevice *
nm_get_device_by_udi (NMData *data,
const char *udi)
{
GSList *elt;
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (udi != NULL, NULL);
for (elt = data->dev_list; elt; elt = g_slist_next (elt))
{
NMDevice *dev = NULL;
if ((dev = NM_DEVICE (elt->data)))
{
if (nm_null_safe_strcmp (nm_device_get_udi (dev), udi) == 0)
return dev;
}
}
return NULL;
}
/*
* nm_get_device_by_iface
*
* Search through the device list for a device with a given iface.
*
*/
NMDevice *
nm_get_device_by_iface (NMData *data,
const char *iface)
{
GSList *elt;
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (iface != NULL, NULL);
for (elt = data->dev_list; elt; elt = g_slist_next (elt)) {
NMDevice *dev = NM_DEVICE (elt->data);
g_assert (dev);
if (nm_null_safe_strcmp (nm_device_get_iface (dev), iface) == 0)
return dev;
}
return NULL;
}
/*
* Get/set functions for UDI
*/
@ -324,20 +268,6 @@ nm_device_set_device_type (NMDevice *dev, NMDeviceType type)
}
static gboolean
real_is_test_device (NMDevice *dev)
{
return FALSE;
}
gboolean
nm_device_is_test_device (NMDevice *self)
{
g_return_val_if_fail (self != NULL, FALSE);
return NM_DEVICE_GET_CLASS (self)->is_test_device (self);
}
/*
* Accessor for capabilities
*/
@ -474,9 +404,6 @@ nm_device_activate (NMDevice *device,
nm_act_request_set_stage (req, NM_ACT_STAGE_DEVICE_PREPARE);
nm_device_activate_schedule_stage1_device_prepare (req);
nm_schedule_state_change_signal_broadcast (data);
nm_dbus_schedule_device_status_change_signal (data, device, NULL, DEVICE_ACTIVATING);
}
@ -516,7 +443,6 @@ nm_device_activate_stage1_device_prepare (gpointer user_data)
goto out;
} else if (ret == NM_ACT_STAGE_RETURN_FAILURE) {
nm_device_state_changed (self, NM_DEVICE_STATE_FAILED);
nm_policy_schedule_activation_failed (req);
goto out;
}
g_assert (ret == NM_ACT_STAGE_RETURN_SUCCESS);
@ -610,7 +536,6 @@ nm_device_activate_stage2_device_config (gpointer user_data)
else if (ret == NM_ACT_STAGE_RETURN_FAILURE)
{
nm_device_state_changed (self, NM_DEVICE_STATE_FAILED);
nm_policy_schedule_activation_failed (req);
goto out;
}
g_assert (ret == NM_ACT_STAGE_RETURN_SUCCESS);
@ -727,7 +652,6 @@ nm_device_activate_stage3_ip_config_start (gpointer user_data)
else if (ret == NM_ACT_STAGE_RETURN_FAILURE)
{
nm_device_state_changed (self, NM_DEVICE_STATE_FAILED);
nm_policy_schedule_activation_failed (req);
goto out;
}
g_assert (ret == NM_ACT_STAGE_RETURN_SUCCESS);
@ -873,7 +797,6 @@ nm_device_activate_stage4_ip_config_get (gpointer user_data)
else if (!ip4_config || (ret == NM_ACT_STAGE_RETURN_FAILURE))
{
nm_device_state_changed (self, NM_DEVICE_STATE_FAILED);
nm_policy_schedule_activation_failed (req);
goto out;
}
g_assert (ret == NM_ACT_STAGE_RETURN_SUCCESS);
@ -967,7 +890,6 @@ nm_device_activate_stage4_ip_config_timeout (gpointer user_data)
goto out;
} else if (!ip4_config || (ret == NM_ACT_STAGE_RETURN_FAILURE)) {
nm_device_state_changed (self, NM_DEVICE_STATE_FAILED);
nm_policy_schedule_activation_failed (req);
goto out;
}
g_assert (ret == NM_ACT_STAGE_RETURN_SUCCESS);
@ -1055,10 +977,8 @@ nm_device_activate_stage5_ip_config_commit (gpointer user_data)
NM_DEVICE_GET_CLASS (self)->update_link (self);
nm_device_state_changed (self, NM_DEVICE_STATE_ACTIVATED);
nm_policy_schedule_activation_finish (req);
} else {
nm_device_state_changed (self, NM_DEVICE_STATE_FAILED);
nm_policy_schedule_activation_failed (req);
}
nm_info ("Activation (%s) Stage 5 of 5 (IP Configure Commit) complete.",
@ -1139,7 +1059,6 @@ nm_device_activation_cancel (NMDevice *self)
nm_act_request_unref (self->priv->act_request);
self->priv->act_request = NULL;
nm_schedule_state_change_signal_broadcast (self->priv->app_data);
nm_info ("Activation (%s): cancelled.", nm_device_get_iface (self));
}
@ -1155,20 +1074,13 @@ nm_device_activation_cancel (NMDevice *self)
gboolean
nm_device_deactivate_quickly (NMDevice *self)
{
NMData * app_data;
NMActRequest * act_request;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (self->priv->app_data != NULL, FALSE);
nm_system_shutdown_nis ();
app_data = self->priv->app_data;
nm_vpn_manager_deactivate_vpn_connection (app_data->vpn_manager, self);
if (nm_device_get_state (self) == NM_DEVICE_STATE_ACTIVATED)
nm_dbus_schedule_device_status_change_signal (app_data, self, NULL, DEVICE_NO_LONGER_ACTIVE);
else if (nm_device_is_activating (self))
if (nm_device_is_activating (self))
nm_device_activation_cancel (self);
/* Tear down an existing activation request, which may not have happened
@ -1229,7 +1141,6 @@ nm_device_deactivate (NMDeviceInterface *device)
NM_DEVICE_GET_CLASS (self)->deactivate (self);
nm_device_state_changed (self, NM_DEVICE_STATE_DISCONNECTED);
nm_schedule_state_change_signal_broadcast (self->priv->app_data);
}
@ -1343,7 +1254,7 @@ dhcp_state_changed (NMDHCPManager *dhcp_manager,
case DHCDBD_FAIL: /* all attempts to contact server timed out, sleeping */
case DHCDBD_ABEND: /* dhclient exited abnormally */
case DHCDBD_END: /* dhclient exited normally */
nm_policy_schedule_activation_failed (req);
nm_device_state_changed (device, NM_DEVICE_STATE_FAILED);
break;
default:
break;
@ -1730,7 +1641,6 @@ nm_device_class_init (NMDeviceClass *klass)
object_class->get_property = get_property;
object_class->constructor = constructor;
klass->is_test_device = real_is_test_device;
klass->activation_cancel_handler = real_activation_cancel_handler;
klass->get_type_capabilities = real_get_type_capabilities;
klass->get_generic_capabilities = real_get_generic_capabilities;

9
src/nm-device.h
View file

@ -78,8 +78,6 @@ struct _NMDeviceClass
{
GObjectClass parent;
gboolean (* is_test_device) (NMDevice *self);
const char * (* has_active_link) (NMDevice *self);
void (* set_active_link) (NMDevice *self, gboolean active);
void (* update_link) (NMDevice *self);
@ -157,13 +155,6 @@ void * nm_device_get_system_config_data (NMDevice *dev);
struct NMActRequest * nm_device_get_act_request (NMDevice *dev);
/* Utility routines */
NMDevice * nm_get_device_by_udi (struct NMData *data,
const char *udi);
NMDevice * nm_get_device_by_iface (struct NMData *data,
const char *iface);
gboolean nm_device_is_test_device (NMDevice *dev);
void nm_device_activate_schedule_stage1_device_prepare (struct NMActRequest *req);
void nm_device_activate_schedule_stage2_device_config (struct NMActRequest *req);

87
src/nm-logging.c
View file

@ -23,7 +23,6 @@
#include <execinfo.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <sys/wait.h>
@ -87,7 +86,7 @@ crashlogger_get_backtrace (void)
}
static void
void
nm_logging_backtrace (void)
{
struct stat s;
@ -145,88 +144,6 @@ nm_log_handler (const gchar * log_domain,
}
static void
nm_signal_handler (int signo)
{
static int in_fatal = 0;
int ignore;
/* avoid loops */
if (in_fatal > 0)
return;
++in_fatal;
switch (signo)
{
case SIGSEGV:
case SIGBUS:
case SIGILL:
case SIGABRT:
nm_warning ("Caught signal %d. Generating backtrace...", signo);
nm_logging_backtrace ();
exit (1);
break;
case SIGFPE:
case SIGPIPE:
/* let the fatal signals interrupt us */
--in_fatal;
nm_warning ("Caught signal %d, shutting down abnormally. Generating backtrace...", signo);
nm_logging_backtrace ();
ignore = write (nm_get_sigterm_pipe (), "X", 1);
break;
case SIGINT:
case SIGTERM:
/* let the fatal signals interrupt us */
--in_fatal;
nm_warning ("Caught signal %d, shutting down normally.", signo);
ignore = write (nm_get_sigterm_pipe (), "X", 1);
break;
case SIGHUP:
--in_fatal;
/* FIXME:
* Reread config stuff like system config files, VPN service files, etc
*/
break;
case SIGUSR1:
--in_fatal;
/* FIXME:
* Play with log levels or something
*/
break;
default:
signal (signo, nm_signal_handler);
break;
}
}
static void
setup_signals (void)
{
struct sigaction action;
sigset_t mask;
sigemptyset (&mask);
action.sa_handler = nm_signal_handler;
action.sa_mask = mask;
action.sa_flags = 0;
sigaction (SIGTERM, &action, NULL);
sigaction (SIGINT, &action, NULL);
sigaction (SIGILL, &action, NULL);
sigaction (SIGBUS, &action, NULL);
sigaction (SIGFPE, &action, NULL);
sigaction (SIGHUP, &action, NULL);
sigaction (SIGSEGV, &action, NULL);
sigaction (SIGABRT, &action, NULL);
sigaction (SIGUSR1, &action, NULL);
}
void
nm_logging_setup (gboolean become_daemon)
{
@ -239,8 +156,6 @@ nm_logging_setup (gboolean become_daemon)
G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION,
nm_log_handler,
NULL);
setup_signals ();
}
void

10
src/nm-logging.h
View file

@ -24,10 +24,8 @@
#include <glib.h>
void
nm_logging_setup (gboolean become_daemon);
void nm_logging_setup (gboolean become_daemon);
void nm_logging_backtrace (void);
void nm_logging_shutdown (void);
void
nm_logging_shutdown (void);
#endif
#endif /* NM_LOGGING_H */

2
src/nm-marshal.list
View file

@ -1,5 +1,5 @@
VOID:OBJECT
VOID:OBJECT,POINTER,INT
VOID:STRING,POINTER,INT
VOID:POINTER
VOID:POINTER,STRING,STRING,STRING
VOID:UINT,UINT

293
src/nm-netlink-monitor.c
View file

@ -55,113 +55,113 @@
#define NM_NETLINK_MONITOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
NM_TYPE_NETLINK_MONITOR, \
NmNetlinkMonitorPrivate))
NMNetlinkMonitorPrivate))
struct NMData;
struct _NmNetlinkMonitorPrivate
{
typedef struct {
GMainContext * context;
GIOChannel * io_channel;
GSource * event_source;
struct NMData *app_data;
};
static void nm_netlink_monitor_finalize (GObject *object);
static void nm_netlink_monitor_class_install_signals (NmNetlinkMonitorClass *service_class);
} NMNetlinkMonitorPrivate;
static gboolean
nm_netlink_monitor_event_handler (GIOChannel *channel,
GIOCondition io_condition,
NmNetlinkMonitor *monitor);
NMNetlinkMonitor *monitor);
static gboolean
nm_netlink_monitor_error_handler (GIOChannel *channel,
GIOCondition io_condition,
NmNetlinkMonitor *monitor);
NMNetlinkMonitor *monitor);
static gboolean
nm_netlink_monitor_disconnect_handler (GIOChannel *channel,
GIOCondition io_condition,
NmNetlinkMonitor *monitor);
NMNetlinkMonitor *monitor);
enum
{
INTERFACE_CONNECTED = 0,
INTERFACE_DISCONNECTED,
WIRELESS_EVENT,
ERROR,
NUMBER_OF_SIGNALS
LAST_SIGNAL
};
static guint nm_netlink_monitor_signals[NUMBER_OF_SIGNALS];
static guint signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE (NmNetlinkMonitor, nm_netlink_monitor, G_TYPE_OBJECT);
G_DEFINE_TYPE (NMNetlinkMonitor, nm_netlink_monitor, G_TYPE_OBJECT);
static void
nm_netlink_monitor_class_init (NmNetlinkMonitorClass *monitor_class)
nm_netlink_monitor_init (NMNetlinkMonitor *monitor)
{
GObjectClass *gobject_class;
}
gobject_class = G_OBJECT_CLASS (monitor_class);
static void
finalize (GObject *object)
{
NMNetlinkMonitorPrivate *priv = NM_NETLINK_MONITOR_GET_PRIVATE (object);
gobject_class->finalize = nm_netlink_monitor_finalize;
if (priv->io_channel)
nm_netlink_monitor_close_connection (NM_NETLINK_MONITOR (object));
nm_netlink_monitor_class_install_signals (monitor_class);
g_type_class_add_private (monitor_class, sizeof (NmNetlinkMonitorPrivate));
G_OBJECT_CLASS (nm_netlink_monitor_parent_class)->finalize (object);
}
static void
nm_netlink_monitor_class_install_signals (NmNetlinkMonitorClass *monitor_class)
nm_netlink_monitor_class_init (NMNetlinkMonitorClass *monitor_class)
{
GObjectClass *object_class;
GObjectClass *object_class = G_OBJECT_CLASS (monitor_class);
object_class = G_OBJECT_CLASS (monitor_class);
g_type_class_add_private (monitor_class, sizeof (NMNetlinkMonitorPrivate));
nm_netlink_monitor_signals[INTERFACE_CONNECTED] =
g_signal_new ("interface-connected",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (NmNetlinkMonitorClass, interface_connected),
NULL, NULL, nm_marshal_VOID__OBJECT,
G_TYPE_NONE, 1, G_TYPE_OBJECT);
monitor_class->interface_connected = NULL;
/* Virtual methods */
object_class->finalize = finalize;
nm_netlink_monitor_signals[INTERFACE_DISCONNECTED] =
g_signal_new ("interface-disconnected",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (NmNetlinkMonitorClass, interface_disconnected),
NULL, NULL, nm_marshal_VOID__OBJECT,
G_TYPE_NONE, 1, G_TYPE_OBJECT);
monitor_class->interface_disconnected = NULL;
/* Signals */
signals[INTERFACE_CONNECTED] =
g_signal_new ("interface-connected",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (NMNetlinkMonitorClass, interface_connected),
NULL, NULL, g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING);
nm_netlink_monitor_signals[WIRELESS_EVENT] =
g_signal_new ("wireless-event",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (NmNetlinkMonitorClass, wireless_event),
NULL, NULL, nm_marshal_VOID__OBJECT_POINTER_INT,
G_TYPE_NONE, 3, G_TYPE_OBJECT, G_TYPE_POINTER, G_TYPE_INT);
monitor_class->wireless_event = NULL;
signals[INTERFACE_DISCONNECTED] =
g_signal_new ("interface-disconnected",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (NMNetlinkMonitorClass, interface_disconnected),
NULL, NULL, g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING);
nm_netlink_monitor_signals[ERROR] =
g_signal_new ("error",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (NmNetlinkMonitorClass, error),
NULL, NULL, nm_marshal_VOID__POINTER,
G_TYPE_NONE, 1, G_TYPE_POINTER);
monitor_class->error = NULL;
signals[WIRELESS_EVENT] =
g_signal_new ("wireless-event",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (NMNetlinkMonitorClass, wireless_event),
NULL, NULL, nm_marshal_VOID__STRING_POINTER_INT,
G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_INT);
signals[ERROR] =
g_signal_new ("error",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (NMNetlinkMonitorClass, error),
NULL, NULL, nm_marshal_VOID__POINTER,
G_TYPE_NONE, 1, G_TYPE_POINTER);
}
gboolean
nm_netlink_monitor_open_connection (NmNetlinkMonitor *monitor,
GError **error)
nm_netlink_monitor_open_connection (NMNetlinkMonitor *monitor,
GError **error)
{
NMNetlinkMonitorPrivate *priv;
struct sockaddr_nl monitor_address = { .nl_family = 0 };
int fd, saved_errno;
GError *channel_error;
GIOFlags channel_flags;
g_return_val_if_fail (monitor->priv->io_channel == NULL, FALSE);
g_return_val_if_fail (NM_IS_NETLINK_MONITOR (monitor), FALSE);
priv = NM_NETLINK_MONITOR_GET_PRIVATE (monitor);
g_return_val_if_fail (priv->io_channel == NULL, FALSE);
fd = socket (PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
@ -195,10 +195,10 @@ nm_netlink_monitor_open_connection (NmNetlinkMonitor *monitor,
return FALSE;
}
monitor->priv->io_channel = g_io_channel_unix_new (fd);
priv->io_channel = g_io_channel_unix_new (fd);
channel_error = NULL;
g_io_channel_set_encoding (monitor->priv->io_channel,
g_io_channel_set_encoding (priv->io_channel,
NULL /* encoding */,
&channel_error);
@ -207,12 +207,12 @@ nm_netlink_monitor_open_connection (NmNetlinkMonitor *monitor,
*/
g_assert (channel_error == NULL);
g_io_channel_set_close_on_unref (monitor->priv->io_channel,
g_io_channel_set_close_on_unref (priv->io_channel,
TRUE);
channel_flags = g_io_channel_get_flags (monitor->priv->io_channel);
channel_flags = g_io_channel_get_flags (priv->io_channel);
channel_error = NULL;
g_io_channel_set_flags (monitor->priv->io_channel,
g_io_channel_set_flags (priv->io_channel,
channel_flags | G_IO_FLAG_NONBLOCK,
&channel_error);
@ -226,43 +226,23 @@ nm_netlink_monitor_open_connection (NmNetlinkMonitor *monitor,
}
void
nm_netlink_monitor_close_connection (NmNetlinkMonitor *monitor)
nm_netlink_monitor_close_connection (NMNetlinkMonitor *monitor)
{
g_return_if_fail (monitor->priv->io_channel != NULL);
NMNetlinkMonitorPrivate *priv;
if (monitor->priv->event_source != NULL)
g_return_if_fail (NM_IS_NETLINK_MONITOR (monitor));
priv = NM_NETLINK_MONITOR_GET_PRIVATE (monitor);
g_return_if_fail (priv->io_channel != NULL);
if (priv->event_source != NULL)
nm_netlink_monitor_detach (monitor);
g_io_channel_shutdown (monitor->priv->io_channel,
g_io_channel_shutdown (priv->io_channel,
TRUE /* flush pending data */,
NULL);
g_io_channel_unref (monitor->priv->io_channel);
monitor->priv->io_channel = NULL;
}
static void
nm_netlink_monitor_init (NmNetlinkMonitor *monitor)
{
monitor->priv = NM_NETLINK_MONITOR_GET_PRIVATE (monitor);
monitor->priv->context = NULL;
monitor->priv->io_channel = NULL;
monitor->priv->event_source = NULL;
}
static void
nm_netlink_monitor_finalize (GObject *object)
{
NmNetlinkMonitor *monitor;
GObjectClass *gobject_class;
monitor = NM_NETLINK_MONITOR (object);
gobject_class = G_OBJECT_CLASS (nm_netlink_monitor_parent_class);
if (monitor->priv->io_channel != NULL)
nm_netlink_monitor_close_connection (monitor);
gobject_class->finalize (object);
g_io_channel_unref (priv->io_channel);
priv->io_channel = NULL;
}
GQuark
@ -276,41 +256,42 @@ nm_netlink_monitor_error_quark (void)
return error_quark;
}
NmNetlinkMonitor *
nm_netlink_monitor_new (struct NMData *data)
NMNetlinkMonitor *
nm_netlink_monitor_get (void)
{
NmNetlinkMonitor *instance;
static NMNetlinkMonitor *singleton = NULL;
g_return_val_if_fail (data != NULL, NULL);
if (!singleton)
singleton = NM_NETLINK_MONITOR (g_object_new (NM_TYPE_NETLINK_MONITOR, NULL));
else
g_object_ref (singleton);
instance = NM_NETLINK_MONITOR (g_object_new (NM_TYPE_NETLINK_MONITOR,
NULL, NULL));
instance->priv->app_data = data;
return instance;
return singleton;
}
static void
nm_netlink_monitor_clear_event_source (NmNetlinkMonitor *monitor)
nm_netlink_monitor_clear_event_source (NMNetlinkMonitor *monitor)
{
monitor->priv->event_source = NULL;
NM_NETLINK_MONITOR_GET_PRIVATE (monitor)->event_source = NULL;
}
void
nm_netlink_monitor_attach (NmNetlinkMonitor *monitor,
nm_netlink_monitor_attach (NMNetlinkMonitor *monitor,
GMainContext *context)
{
NMNetlinkMonitorPrivate *priv;
GSource *event_source;
g_return_if_fail (NM_IS_NETLINK_MONITOR (monitor));
g_return_if_fail (monitor->priv->context == NULL);
priv = NM_NETLINK_MONITOR_GET_PRIVATE (monitor);
g_return_if_fail (priv->context == NULL);
if (context == NULL)
context = g_main_context_default ();
monitor->priv->context = g_main_context_ref (context);
priv->context = g_main_context_ref (context);
event_source = g_io_create_watch (monitor->priv->io_channel,
event_source = g_io_create_watch (priv->io_channel,
NM_NETLINK_MONITOR_EVENT_CONDITIONS |
NM_NETLINK_MONITOR_ERROR_CONDITIONS |
NM_NETLINK_MONITOR_DISCONNECT_CONDITIONS);
@ -320,33 +301,37 @@ nm_netlink_monitor_attach (NmNetlinkMonitor *monitor,
(GDestroyNotify)
nm_netlink_monitor_clear_event_source);
g_source_attach (event_source, context);
monitor->priv->event_source = event_source;
priv->event_source = event_source;
}
void
nm_netlink_monitor_detach (NmNetlinkMonitor *monitor)
nm_netlink_monitor_detach (NMNetlinkMonitor *monitor)
{
NMNetlinkMonitorPrivate *priv;
g_return_if_fail (NM_IS_NETLINK_MONITOR (monitor));
g_return_if_fail (monitor->priv->context != NULL);
priv = NM_NETLINK_MONITOR_GET_PRIVATE (monitor);
g_return_if_fail (priv->context != NULL);
g_source_destroy (monitor->priv->event_source);
monitor->priv->event_source = NULL;
g_source_destroy (priv->event_source);
priv->event_source = NULL;
g_main_context_unref (monitor->priv->context);
monitor->priv->context = NULL;
g_main_context_unref (priv->context);
priv->context = NULL;
}
gboolean
nm_netlink_monitor_request_status (NmNetlinkMonitor *monitor,
nm_netlink_monitor_request_status (NMNetlinkMonitor *monitor,
GError **error)
{
typedef struct
{
struct nlmsghdr header;
struct rtgenmsg request;
} NmNetlinkMonitorStatusPacket;
} NMNetlinkMonitorStatusPacket;
NmNetlinkMonitorStatusPacket packet;
NMNetlinkMonitorStatusPacket packet;
NMNetlinkMonitorPrivate *priv;
struct sockaddr_nl recipient = { .nl_pad = 0 };
static guint32 sequence_number;
int fd, saved_errno;
@ -356,13 +341,17 @@ nm_netlink_monitor_request_status (NmNetlinkMonitor *monitor,
const gchar *buffer;
GError *socket_error;
fd = g_io_channel_unix_get_fd (monitor->priv->io_channel);
g_return_val_if_fail (NM_IS_NETLINK_MONITOR (monitor), FALSE);
priv = NM_NETLINK_MONITOR_GET_PRIVATE (monitor);
fd = g_io_channel_unix_get_fd (priv->io_channel);
recipient.nl_family = AF_NETLINK;
recipient.nl_pid = 0; /* going to kernel */
recipient.nl_groups = RTMGRP_LINK;
memset (&packet, 0, sizeof (NmNetlinkMonitorStatusPacket));
memset (&packet, 0, sizeof (NMNetlinkMonitorStatusPacket));
packet.header.nlmsg_len = NLMSG_LENGTH (sizeof (struct rtgenmsg));
packet.header.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
packet.header.nlmsg_type = RTM_GETLINK;
@ -436,7 +425,7 @@ nm_netlink_monitor_request_status (NmNetlinkMonitor *monitor,
else
{
g_signal_emit (G_OBJECT (monitor),
nm_netlink_monitor_signals[ERROR],
signals[ERROR],
0, socket_error);
g_error_free (socket_error);
}
@ -590,7 +579,7 @@ out:
static gboolean
nm_netlink_monitor_event_handler (GIOChannel *channel,
GIOCondition io_condition,
NmNetlinkMonitor *monitor)
NMNetlinkMonitor *monitor)
{
GError *error;
gchar *received_bytes=NULL;
@ -624,8 +613,8 @@ nm_netlink_monitor_event_handler (GIOChannel *channel,
if (error != NULL)
{
g_signal_emit (G_OBJECT (monitor),
nm_netlink_monitor_signals[ERROR],
0, error);
signals[ERROR],
0, error);
g_error_free (error);
return FALSE;
}
@ -668,8 +657,8 @@ nm_netlink_monitor_event_handler (GIOChannel *channel,
"it was lost"));
g_signal_emit (G_OBJECT (monitor),
nm_netlink_monitor_signals[ERROR],
0, error);
signals[ERROR],
0, error);
g_error_free (error);
error = NULL;
continue;
@ -687,8 +676,8 @@ nm_netlink_monitor_event_handler (GIOChannel *channel,
"%s", g_strerror (error_message->error));
g_signal_emit (G_OBJECT (monitor),
nm_netlink_monitor_signals[ERROR],
0, error);
signals[ERROR],
0, error);
g_error_free (error);
error = NULL;
continue;
@ -718,35 +707,27 @@ nm_netlink_monitor_event_handler (GIOChannel *channel,
{
/* The !! weirdness is to cannonicalize the value to 0 or 1. */
gboolean is_connected = !!((gboolean) (interface_info->ifi_flags & IFF_RUNNING));
NMDevice * dev;
if ((dev = nm_get_device_by_iface (monitor->priv->app_data, iface)))
{
if (is_connected) {
g_signal_emit (G_OBJECT (monitor),
nm_netlink_monitor_signals[INTERFACE_CONNECTED],
0, dev);
} else {
g_signal_emit (G_OBJECT (monitor),
nm_netlink_monitor_signals[INTERFACE_DISCONNECTED],
0, dev);
}
if (is_connected) {
g_signal_emit (G_OBJECT (monitor),
signals[INTERFACE_CONNECTED],
0, iface);
} else {
g_signal_emit (G_OBJECT (monitor),
signals[INTERFACE_DISCONNECTED],
0, iface);
}
}
g_free (iface);
} else if (attribute->rta_type == IFLA_WIRELESS) {
char * iface = nm_system_get_iface_from_rtnl_index (interface_info->ifi_index);
if (iface != NULL) {
NMDevice *dev;
if ((dev = nm_get_device_by_iface (monitor->priv->app_data, iface)))
{
char * data = g_malloc0 (data_len);
memcpy (data, RTA_DATA (attribute), data_len);
g_signal_emit (G_OBJECT (monitor),
nm_netlink_monitor_signals[WIRELESS_EVENT],
0, dev, data, data_len);
g_free (data);
}
char * data = g_malloc0 (data_len);
memcpy (data, RTA_DATA (attribute), data_len);
g_signal_emit (G_OBJECT (monitor),
signals[WIRELESS_EVENT],
0, iface, data, data_len);
g_free (data);
}
g_free (iface);
}
@ -760,7 +741,7 @@ nm_netlink_monitor_event_handler (GIOChannel *channel,
static gboolean
nm_netlink_monitor_error_handler (GIOChannel *channel,
GIOCondition io_condition,
NmNetlinkMonitor *monitor)
NMNetlinkMonitor *monitor)
{
GError *socket_error;
@ -774,15 +755,15 @@ nm_netlink_monitor_error_handler (GIOChannel *channel,
_("error occurred while waiting for data on socket"));
g_signal_emit (G_OBJECT (monitor),
nm_netlink_monitor_signals[ERROR],
0, socket_error);
signals[ERROR],
0, socket_error);
return TRUE;
}
static gboolean
nm_netlink_monitor_disconnect_handler (GIOChannel *channel,
GIOCondition io_condition,
NmNetlinkMonitor *monitor)
NMNetlinkMonitor *monitor)
{
g_return_val_if_fail (!(io_condition &

87
src/nm-netlink-monitor.h
View file

@ -27,46 +27,14 @@
G_BEGIN_DECLS
#define NM_TYPE_NETLINK_MONITOR (nm_netlink_monitor_get_type ())
#define NM_NETLINK_MONITOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NM_TYPE_NETLINK_MONITOR, NmNetlinkMonitor))
#define NM_NETLINK_MONITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), NM_TYPE_NETLINK_MONITOR, NmNetlinkMonitorClass))
#define NM_NETLINK_MONITOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NM_TYPE_NETLINK_MONITOR, NMNetlinkMonitor))
#define NM_NETLINK_MONITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), NM_TYPE_NETLINK_MONITOR, NMNetlinkMonitorClass))
#define NM_IS_NETLINK_MONITOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NM_TYPE_NETLINK_MONITOR))
#define NM_IS_NETLINK_MONITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), NM_TYPE_NETLINK_MONITOR))
#define NM_NETLINK_MONITOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_NETLINK_MONITOR, NmNetlinkMonitorClass))
#define NM_NETLINK_MONITOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_NETLINK_MONITOR, NMNetlinkMonitorClass))
#define NM_NETLINK_MONITOR_ERROR (nm_netlink_monitor_error_quark ())
typedef struct _NmNetlinkMonitor NmNetlinkMonitor;
typedef struct _NmNetlinkMonitorClass NmNetlinkMonitorClass;
typedef struct _NmNetlinkMonitorPrivate NmNetlinkMonitorPrivate;
typedef enum _NmNetlinkMonitorError NmNetlinkMonitorError;
struct _NmNetlinkMonitor
{
GObject parent;
/*< private >*/
NmNetlinkMonitorPrivate *priv;
};
struct _NmNetlinkMonitorClass
{
GObjectClass parent_class;
/* Signals */
void (* interface_connected) (NmNetlinkMonitor * monitor,
GObject *dev);
void (* interface_disconnected) (NmNetlinkMonitor * monitor,
GObject *dev);
void (* wireless_event) (NmNetlinkMonitor * monitor,
GObject *dev,
const gchar * data,
int data_len);
void (* error) (NmNetlinkMonitor * monitor,
GError * error);
};
enum _NmNetlinkMonitorError
{
typedef enum {
NM_NETLINK_MONITOR_ERROR_GENERIC = 0,
NM_NETLINK_MONITOR_ERROR_OPENING_SOCKET,
NM_NETLINK_MONITOR_ERROR_BINDING_TO_SOCKET,
@ -75,26 +43,41 @@ enum _NmNetlinkMonitorError
NM_NETLINK_MONITOR_ERROR_WAITING_FOR_SOCKET_DATA,
NM_NETLINK_MONITOR_ERROR_READING_FROM_SOCKET,
NM_NETLINK_MONITOR_ERROR_SENDING_TO_SOCKET
};
} NMNetlinkMonitorError;
typedef struct {
GObject parent;
} NMNetlinkMonitor;
typedef struct {
GObjectClass parent_class;
/* Signals */
void (*interface_connected) (NMNetlinkMonitor *monitor, const char *iface);
void (*interface_disconnected) (NMNetlinkMonitor *monitor, const char *iface);
void (*wireless_event) (NMNetlinkMonitor *monitor,
const char *iface,
const gchar *data,
int data_len);
void (*error) (NMNetlinkMonitor *monitor,
GError *error);
} NMNetlinkMonitorClass;
GType nm_netlink_monitor_get_type (void) G_GNUC_CONST;
GQuark nm_netlink_monitor_error_quark (void) G_GNUC_CONST;
struct NMData;
NmNetlinkMonitor *nm_netlink_monitor_new (struct NMData *data);
NMNetlinkMonitor *nm_netlink_monitor_get (void);
gboolean
nm_netlink_monitor_open_connection (NmNetlinkMonitor *monitor,
GError **error);
void
nm_netlink_monitor_close_connection (NmNetlinkMonitor *monitor);
void nm_netlink_monitor_attach (NmNetlinkMonitor *monitor,
GMainContext *context);
void nm_netlink_monitor_detach (NmNetlinkMonitor *monitor);
gboolean nm_netlink_monitor_request_status (NmNetlinkMonitor *monitor,
GError **error);
gboolean nm_netlink_monitor_open_connection (NMNetlinkMonitor *monitor,
GError **error);
void nm_netlink_monitor_close_connection (NMNetlinkMonitor *monitor);
void nm_netlink_monitor_attach (NMNetlinkMonitor *monitor,
GMainContext *context);
void nm_netlink_monitor_detach (NMNetlinkMonitor *monitor);
gboolean nm_netlink_monitor_request_status (NMNetlinkMonitor *monitor,
GError **error);
G_END_DECLS
#endif /* NM_NETLINK_MONITOR_H */

56
src/vpn-manager/nm-dbus-vpn.c
View file

@ -367,7 +367,7 @@ out:
typedef struct UpdateOneVPNCBData {
NMData * data;
NMVPNManager *manager;
char * vpn;
} UpdateOneVPNCBData;
@ -403,8 +403,7 @@ nm_dbus_vpn_update_one_connection_cb (DBusPendingCall *pcall,
g_return_if_fail (pcall != NULL);
g_return_if_fail (cb_data != NULL);
g_return_if_fail (cb_data->data != NULL);
g_return_if_fail (cb_data->data->vpn_manager != NULL);
g_return_if_fail (cb_data->manager != NULL);
nm_dbus_send_with_callback_replied (pcall, __func__);
@ -425,10 +424,10 @@ nm_dbus_vpn_update_one_connection_cb (DBusPendingCall *pcall,
if (dbus_message_is_error (reply, "BadVPNConnectionData")) {
/* Bad VPN, remove it from our VPN connection list */
if ((vpn = nm_vpn_manager_find_connection_by_name (cb_data->data->vpn_manager,
if ((vpn = nm_vpn_manager_find_connection_by_name (cb_data->manager,
cb_data->vpn))) {
nm_vpn_connection_ref (vpn);
nm_vpn_manager_remove_connection (cb_data->data->vpn_manager, vpn);
nm_vpn_manager_remove_connection (cb_data->manager, vpn);
nm_dbus_vpn_signal_vpn_connection_update (dbus_connection,
vpn,
"VPNConnectionRemoved");
@ -446,7 +445,7 @@ nm_dbus_vpn_update_one_connection_cb (DBusPendingCall *pcall,
goto unref_reply;
}
vpn = nm_vpn_manager_find_connection_by_name (cb_data->data->vpn_manager,
vpn = nm_vpn_manager_find_connection_by_name (cb_data->manager,
con_name);
if (vpn) {
/* If all attributes of the existing connection are the same as
@ -455,14 +454,14 @@ nm_dbus_vpn_update_one_connection_cb (DBusPendingCall *pcall,
vpn_service_name = nm_vpn_connection_get_service_name (vpn);
if ( (strcmp (vpn_service_name, service_name) != 0)
|| (strcmp (nm_vpn_connection_get_user_name (vpn), user_name) != 0)) {
nm_vpn_manager_remove_connection (cb_data->data->vpn_manager, vpn);
nm_vpn_manager_remove_connection (cb_data->manager, vpn);
} else {
new = FALSE;
}
}
if (new) {
vpn = nm_vpn_manager_add_connection (cb_data->data->vpn_manager,
vpn = nm_vpn_manager_add_connection (cb_data->manager,
con_name,
service_name,
user_name);
@ -493,7 +492,7 @@ static void
nm_dbus_vpn_connections_update_cb (DBusPendingCall *pcall,
void *user_data)
{
NMData * data = (NMData *) user_data;
NMVPNManager *manager = (NMVPNManager *) user_data;
DBusMessage * reply;
DBusMessageIter iter, array_iter;
GSList * remove_list = NULL;
@ -502,7 +501,7 @@ nm_dbus_vpn_connections_update_cb (DBusPendingCall *pcall,
DBusConnection * dbus_connection;
g_return_if_fail (pcall);
g_return_if_fail (data != NULL);
g_return_if_fail (manager != NULL);
nm_dbus_send_with_callback_replied (pcall, __func__);
@ -526,7 +525,7 @@ nm_dbus_vpn_connections_update_cb (DBusPendingCall *pcall,
nm_info ("Updating VPN Connections...");
remove_list = nm_vpn_manager_vpn_connection_list_copy (data->vpn_manager);
remove_list = nm_vpn_manager_vpn_connection_list_copy (manager);
dbus_message_iter_init (reply, &iter);
dbus_message_iter_recurse (&iter, &array_iter);
@ -538,7 +537,7 @@ nm_dbus_vpn_connections_update_cb (DBusPendingCall *pcall,
dbus_message_iter_get_basic (&array_iter, &con_name);
/* If the connection already exists, remove it from the remove list */
if ((vpn = nm_vpn_manager_find_connection_by_name (data->vpn_manager, con_name)))
if ((vpn = nm_vpn_manager_find_connection_by_name (manager, con_name)))
remove_list = g_slist_remove (remove_list, vpn);
message = dbus_message_new_method_call (NMI_DBUS_SERVICE,
@ -552,7 +551,7 @@ nm_dbus_vpn_connections_update_cb (DBusPendingCall *pcall,
DBUS_TYPE_STRING, &con_name,
DBUS_TYPE_INVALID);
vpn_cb_data->data = data;
vpn_cb_data->manager = manager;
vpn_cb_data->vpn = g_strdup (con_name);
nm_dbus_send_with_callback (dbus_connection,
message,
@ -567,7 +566,7 @@ nm_dbus_vpn_connections_update_cb (DBusPendingCall *pcall,
/* VPN connections left in the remove list aren't known by NMI, therefore we delete them */
for (elt = remove_list; elt; elt = g_slist_next (elt)) {
nm_vpn_manager_remove_connection (data->vpn_manager, elt->data);
nm_vpn_manager_remove_connection (manager, elt->data);
nm_vpn_connection_unref (elt->data);
}
@ -591,15 +590,15 @@ out:
*/
void
nm_dbus_vpn_update_one_vpn_connection (DBusConnection *connection,
const char *vpn,
NMData *data)
NMVPNManager *manager,
const char *vpn)
{
DBusMessage * message;
UpdateOneVPNCBData *cb_data;
g_return_if_fail (connection != NULL);
g_return_if_fail (manager != NULL);
g_return_if_fail (vpn != NULL);
g_return_if_fail (data != NULL);
message = dbus_message_new_method_call (NMI_DBUS_SERVICE,
NMI_DBUS_PATH,
@ -613,7 +612,7 @@ nm_dbus_vpn_update_one_vpn_connection (DBusConnection *connection,
dbus_message_append_args (message, DBUS_TYPE_STRING, &vpn, DBUS_TYPE_INVALID);
cb_data = g_slice_new0 (UpdateOneVPNCBData);
cb_data->data = data;
cb_data->manager = manager;
cb_data->vpn = g_strdup (vpn);
nm_dbus_send_with_callback (connection,
message,
@ -632,13 +631,13 @@ nm_dbus_vpn_update_one_vpn_connection (DBusConnection *connection,
*
*/
static gboolean
nm_dbus_vpn_connections_update_from_nmi (NMData *data)
nm_dbus_vpn_connections_update_from_nmi (NMVPNManager *manager)
{
DBusMessage * message;
NMDBusManager * dbus_mgr;
DBusConnection * dbus_connection;
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (manager != NULL, FALSE);
dbus_mgr = nm_dbus_manager_get ();
dbus_connection = nm_dbus_manager_get_dbus_connection (dbus_mgr);
@ -659,7 +658,7 @@ nm_dbus_vpn_connections_update_from_nmi (NMData *data)
nm_dbus_send_with_callback (dbus_connection,
message,
(DBusPendingCallNotifyFunction) nm_dbus_vpn_connections_update_cb,
data,
manager,
NULL,
__func__);
dbus_message_unref (message);
@ -676,17 +675,14 @@ out:
* Schedule an update of VPN connections in the main thread
*
*/
void nm_dbus_vpn_schedule_vpn_connections_update (NMData *app_data)
void nm_dbus_vpn_schedule_vpn_connections_update (NMVPNManager *manager)
{
GSource * source = NULL;
guint id;
g_return_if_fail (manager != NULL);
g_return_if_fail (app_data != NULL);
id = g_idle_add ((GSourceFunc) nm_dbus_vpn_connections_update_from_nmi,
app_data);
source = g_main_context_find_source_by_id (NULL, id);
g_source_set_priority (source, G_PRIORITY_HIGH_IDLE);
g_idle_add_full (G_PRIORITY_HIGH_IDLE,
(GSourceFunc) nm_dbus_vpn_connections_update_from_nmi,
manager,
NULL);
}

6
src/vpn-manager/nm-dbus-vpn.h
View file

@ -26,8 +26,10 @@
#include "nm-vpn-manager.h"
#include "nm-vpn-connection.h"
void nm_dbus_vpn_schedule_vpn_connections_update (NMData *app_data);
void nm_dbus_vpn_update_one_vpn_connection (DBusConnection *connection, const char *vpn, NMData *data);
void nm_dbus_vpn_schedule_vpn_connections_update (NMVPNManager *manager);
void nm_dbus_vpn_update_one_vpn_connection (DBusConnection *connection,
NMVPNManager *manager,
const char *vpn);
void nm_dbus_vpn_signal_vpn_connection_update (DBusConnection *con, NMVPNConnection *vpn, const char *signal);
void nm_dbus_vpn_signal_vpn_failed (DBusConnection *con, const char *signal, NMVPNConnection *vpn, const char *error_msg);

83
src/vpn-manager/nm-vpn-manager.c
View file

@ -45,10 +45,59 @@ struct NMVPNManager
NMVPNActRequest * act_req;
NMDbusMethodList * dbus_methods;
gulong device_signal_id;
};
static void load_services (NMVPNManager *manager, GHashTable *table);
static void
nm_name_owner_changed_handler (NMDBusManager *mgr,
DBusConnection *connection,
const char *name,
const char *old,
const char *new,
gpointer user_data)
{
NMVPNManager *vpn_manager = (NMVPNManager *) user_data;
gboolean old_owner_good = (old && (strlen (old) > 0));
gboolean new_owner_good = (new && (strlen (new) > 0));
if (strcmp (name, NMI_DBUS_SERVICE) == 0 && (!old_owner_good && new_owner_good))
/* NMI appeared, update stuff */
nm_dbus_vpn_schedule_vpn_connections_update (vpn_manager);
}
static gboolean
nm_dbus_nmi_vpn_signal_handler (DBusConnection *connection,
DBusMessage *message,
gpointer user_data)
{
NMVPNManager *manager = (NMVPNManager *) user_data;
const char * object_path;
gboolean handled = FALSE;
if (!(object_path = dbus_message_get_path (message)))
return FALSE;
if (strcmp (object_path, NMI_DBUS_PATH) != 0)
return FALSE;
if (dbus_message_is_signal (message, NMI_DBUS_INTERFACE, "VPNConnectionUpdate")) {
char *name = NULL;
if (dbus_message_get_args (message,
NULL,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID)) {
nm_debug ("NetworkManagerInfo triggered update of VPN connection '%s'", name);
nm_dbus_vpn_update_one_vpn_connection (connection, manager, name);
handled = TRUE;
}
}
return handled;
}
/*
* nm_vpn_manager_new
*
@ -75,6 +124,21 @@ NMVPNManager *nm_vpn_manager_new (NMManager *nm_manager, NMData *app_data)
manager->dbus_methods = nm_dbus_vpn_methods_setup (manager);
dbus_mgr = nm_dbus_manager_get ();
g_signal_connect (dbus_mgr,
"name-owner-changed",
G_CALLBACK (nm_name_owner_changed_handler),
manager);
nm_dbus_manager_register_signal_handler (dbus_mgr,
NMI_DBUS_INTERFACE,
NULL,
nm_dbus_nmi_vpn_signal_handler,
manager);
if (nm_dbus_manager_name_has_owner (dbus_mgr, NMI_DBUS_SERVICE))
nm_dbus_vpn_schedule_vpn_connections_update (manager);
/* FIXME */
/* nm_dbus_manager_register_method_list (dbus_mgr, manager->dbus_methods); */
g_object_unref (dbus_mgr);
@ -308,6 +372,16 @@ NMVPNActRequest *nm_vpn_manager_get_vpn_act_request (NMVPNManager *manager)
}
static void
device_state_changed (NMDevice *device, NMDeviceState state, gpointer user_data)
{
NMVPNManager *manager = (NMVPNManager *) user_data;
if (state == NM_DEVICE_STATE_DISCONNECTED)
nm_vpn_manager_deactivate_vpn_connection (manager, device);
}
/*
* nm_vpn_manager_activate_vpn_connection
*
@ -345,6 +419,10 @@ void nm_vpn_manager_activate_vpn_connection (NMVPNManager *manager, NMVPNConnect
user_routes, user_routes_count);
manager->act_req = req;
manager->device_signal_id = g_signal_connect (parent_dev, "state-changed",
G_CALLBACK (device_state_changed),
manager);
nm_vpn_service_start_connection (service, req);
}
@ -365,6 +443,11 @@ void nm_vpn_manager_deactivate_vpn_connection (NMVPNManager *manager, NMDevice *
if (!manager->act_req || (dev != nm_vpn_act_request_get_parent_dev (manager->act_req)))
return;
if (manager->device_signal_id) {
g_signal_handler_disconnect (dev, manager->device_signal_id);
manager->device_signal_id = 0;
}
if (nm_vpn_act_request_is_activating (manager->act_req)
|| nm_vpn_act_request_is_activated (manager->act_req)
|| nm_vpn_act_request_is_failed (manager->act_req))