← Back to branch summary

~mdz/network-manager/ubuntu.0.7

« back to all changes in this revision

Viewing changes to libnm-glib/nm-device.c

  • Committer: tambeti
  • Date: 2007-02-12 09:23:43 UTC
  • Revision ID: vcs-imports@canonical.com-20070212092343-96d46863e2821ee2
2007-02-12  Tambet Ingo  <tambet@ximian.com>

        Totally break NetworkManager. Please use 0.6 branch until futher notice.

        * src/:
                - Remove old low-level dbus interface implementations and replace them
                  with dbus-glib one.

        * configure.in:
                - Require dbus-glib >= 0.72.
                - Plug in new sources to build.

        * libnm-glib/:
                - Implement GObject wrappers on top of DBUS glib auto-generated bindings
                  to make it more convenient to use from GObject based programs.

        * introspection/:
                - Implement DBUS XML introspection files, used by both NM and libnm-glib.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libnm-glib/nm-device.c
 
1
#include "nm-device.h"
 
2
#include "nm-device-private.h"
 
3
 
 
4
#include "nm-device-bindings.h"
 
5
 
 
6
G_DEFINE_TYPE (NMDevice, nm_device, DBUS_TYPE_G_PROXY)
 
7
 
 
8
enum {
 
9
        STATE_CHANGED,
 
10
 
 
11
        LAST_SIGNAL
 
12
};
 
13
 
 
14
static guint signals[LAST_SIGNAL] = { 0 };
 
15
 
 
16
static void device_state_change_proxy (DBusGProxy *proxy, guint state, gpointer user_data);
 
17
 
 
18
static void
 
19
nm_device_init (NMDevice *device)
 
20
{
 
21
}
 
22
 
 
23
static GObject*
 
24
constructor (GType type,
 
25
                         guint n_construct_params,
 
26
                         GObjectConstructParam *construct_params)
 
27
{
 
28
        GObject *object;
 
29
 
 
30
        object = G_OBJECT_CLASS (nm_device_parent_class)->constructor (type,
 
31
                                                                                                                                   n_construct_params,
 
32
                                                                                                                                   construct_params);
 
33
 
 
34
        if (!object)
 
35
                return NULL;
 
36
 
 
37
        dbus_g_proxy_add_signal (DBUS_G_PROXY (object), "StateChanged", G_TYPE_UINT, G_TYPE_INVALID);
 
38
        dbus_g_proxy_connect_signal (DBUS_G_PROXY (object),
 
39
                                                                 "StateChanged",
 
40
                                                                 G_CALLBACK (device_state_change_proxy),
 
41
                                                                 object,
 
42
                                                                 NULL);
 
43
        return object;
 
44
}
 
45
 
 
46
static void
 
47
nm_device_class_init (NMDeviceClass *device_class)
 
48
{
 
49
        GObjectClass *object_class = G_OBJECT_CLASS (device_class);
 
50
 
 
51
        /* virtual methods */
 
52
        object_class->constructor = constructor;
 
53
 
 
54
        /* signals */
 
55
        signals[STATE_CHANGED] =
 
56
                g_signal_new ("state-changed",
 
57
                                          G_OBJECT_CLASS_TYPE (object_class),
 
58
                                          G_SIGNAL_RUN_FIRST,
 
59
                                          G_STRUCT_OFFSET (NMDeviceClass, state_changed),
 
60
                                          NULL, NULL,
 
61
                                          g_cclosure_marshal_VOID__UINT,
 
62
                                          G_TYPE_NONE, 1,
 
63
                                          G_TYPE_UINT);
 
64
 
 
65
}
 
66
 
 
67
static void
 
68
device_state_change_proxy (DBusGProxy *proxy, guint state, gpointer user_data)
 
69
{
 
70
        NMDevice *device = NM_DEVICE (user_data);
 
71
 
 
72
        g_signal_emit (device, signals[STATE_CHANGED], 0, state);
 
73
}
 
74
 
 
75
NMDevice *
 
76
nm_device_new (DBusGConnection *connection, const char *path)
 
77
{
 
78
        return (NMDevice *) g_object_new (NM_TYPE_DEVICE,
 
79
                                                                          "name", NM_DBUS_SERVICE,
 
80
                                                                          "path", path, 
 
81
                                                                          "interface", NM_DBUS_INTERFACE_DEVICE,
 
82
                                                                          "connection", connection,
 
83
                                                                          NULL);
 
84
}
 
85
 
 
86
void
 
87
nm_device_deactivate (NMDevice *device)
 
88
{
 
89
        GError *err = NULL;
 
90
 
 
91
        g_return_if_fail (NM_IS_DEVICE (device));
 
92
 
 
93
        if (!org_freedesktop_NetworkManager_Device_deactivate (DBUS_G_PROXY (device), &err)) {
 
94
                g_warning ("Cannot deactivate device: %s", err->message);
 
95
                g_error_free (err);
 
96
        }
 
97
}
 
98
 
 
99
char *
 
100
nm_device_get_iface (NMDevice *device)
 
101
{
 
102
        char *iface = NULL;
 
103
        GValue value = {0,};
 
104
 
 
105
        g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
 
106
 
 
107
        if (nm_dbus_get_property (DBUS_G_PROXY (device),
 
108
                                                          NM_DBUS_INTERFACE_DEVICE,
 
109
                                                          "Interface",
 
110
                                                          &value))
 
111
                iface = g_strdup (g_value_get_string (&value));
 
112
 
 
113
        return iface;
 
114
}
 
115
 
 
116
char *
 
117
nm_device_get_udi (NMDevice *device)
 
118
{
 
119
        char *udi = NULL;
 
120
        GValue value = {0,};
 
121
 
 
122
        g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
 
123
 
 
124
        if (nm_dbus_get_property (DBUS_G_PROXY (device),
 
125
                                                          NM_DBUS_INTERFACE_DEVICE,
 
126
                                                          "Udi",
 
127
                                                          &value))
 
128
                udi = g_strdup (g_value_get_string (&value));
 
129
 
 
130
        return udi;
 
131
}
 
132
 
 
133
char *
 
134
nm_device_get_driver (NMDevice *device)
 
135
{
 
136
        char *driver = NULL;
 
137
        GValue value = {0,};
 
138
 
 
139
        g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
 
140
 
 
141
        if (nm_dbus_get_property (DBUS_G_PROXY (device),
 
142
                                                          NM_DBUS_INTERFACE_DEVICE,
 
143
                                                          "Driver",
 
144
                                                          &value))
 
145
                driver = g_strdup (g_value_get_string (&value));
 
146
 
 
147
        return driver;
 
148
}
 
149
 
 
150
gboolean
 
151
nm_device_get_use_dhcp (NMDevice *device)
 
152
{
 
153
        gboolean dhcp = FALSE;
 
154
        GValue value = {0,};
 
155
 
 
156
        g_return_val_if_fail (NM_IS_DEVICE (device), FALSE);
 
157
 
 
158
        if (nm_dbus_get_property (DBUS_G_PROXY (device),
 
159
                                                          NM_DBUS_INTERFACE_DEVICE,
 
160
                                                          "UseDhcp",
 
161
                                                          &value))
 
162
                dhcp = g_value_get_boolean (&value);
 
163
 
 
164
        return dhcp;
 
165
}
 
166
 
 
167
guint32
 
168
nm_device_get_ip4_address (NMDevice *device)
 
169
{
 
170
        guint32 address = 0;
 
171
        GValue value = {0,};
 
172
 
 
173
        g_return_val_if_fail (NM_IS_DEVICE (device), 0);
 
174
 
 
175
        if (nm_dbus_get_property (DBUS_G_PROXY (device),
 
176
                                                          NM_DBUS_INTERFACE_DEVICE,
 
177
                                                          "Ip4Address",
 
178
                                                          &value))
 
179
                address = g_value_get_uint (&value);
 
180
 
 
181
        return address;
 
182
}
 
183
 
 
184
NMDeviceState
 
185
nm_device_get_state (NMDevice *device)
 
186
{
 
187
        NMDeviceState state = NM_DEVICE_STATE_UNKNOWN;
 
188
        GValue value = {0,};
 
189
 
 
190
        g_return_val_if_fail (NM_IS_DEVICE (device), 0);
 
191
 
 
192
        if (nm_dbus_get_property (DBUS_G_PROXY (device),
 
193
                                                          NM_DBUS_INTERFACE_DEVICE,
 
194
                                                          "State",
 
195
                                                          &value))
 
196
                state = g_value_get_uint (&value);
 
197
 
 
198
        return state;
 
199
}
 
200
 
 
201
NMDeviceType
 
202
nm_device_type_for_path (DBusGConnection *connection,
 
203
                                                 const char *path)
 
204
{
 
205
        DBusGProxy *proxy;
 
206
        GValue value = {0,};
 
207
        NMDeviceType type = DEVICE_TYPE_UNKNOWN;
 
208
 
 
209
        g_return_val_if_fail (connection != NULL, type);
 
210
        g_return_val_if_fail (path != NULL, type);
 
211
 
 
212
        proxy = dbus_g_proxy_new_for_name (connection,
 
213
                                                                           NM_DBUS_SERVICE,
 
214
                                                                           path,
 
215
                                                                           NM_DBUS_INTERFACE_DEVICE);
 
216
 
 
217
        if (nm_dbus_get_property (proxy,
 
218
                                                          NM_DBUS_INTERFACE_DEVICE,
 
219
                                                          "DeviceType",
 
220
                                                          &value))
 
221
                type = (NMDeviceType) g_value_get_uint (&value);
 
222
 
 
223
        g_object_unref (proxy);
 
224
 
 
225
        return type;
 
226
}