← Back to branch summary

~cairo-dock-team/cairo-dock-plug-ins/plug-ins

« back to all changes in this revision

Viewing changes to Network-Monitor/src/applet-connections.c

  • Committer: Matthieu Baerts
  • Date: 2014-10-19 00:26:10 UTC
  • Revision ID: matttbe@gmail.com-20141019002610-ulf26s9b4c4rw10r
We just switched from BZR to Git.
Follow us on Github: https://github.com/Cairo-Dock

Note: we will only use Github to manage our source code and all pull requests.
Please continue to report your bugs/ideas/messages on our forum or Launchpad! 

Show diffs side-by-side

added added

removed removed

Lines of Context:
Network-Monitor/src/applet-connections.c
1
 
/**
2
 
* This file is a part of the Cairo-Dock project
3
 
*
4
 
* Copyright : (C) see the 'copyright' file.
5
 
* E-mail    : see the 'copyright' file.
6
 
*
7
 
* This program is free software; you can redistribute it and/or
8
 
* modify it under the terms of the GNU General Public License
9
 
* as published by the Free Software Foundation; either version 3
10
 
* of the License, or (at your option) any later version.
11
 
*
12
 
* This program is distributed in the hope that it will be useful,
13
 
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
* GNU General Public License for more details.
16
 
* You should have received a copy of the GNU General Public License
17
 
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
18
 
*/
19
 
// http://projects.gnome.org/NetworkManager/developers/spec-08.html
20
 
 
21
 
#define _BSD_SOURCE
22
 
 
23
 
#include <unistd.h>
24
 
#include <string.h>
25
 
 
26
 
#include "applet-struct.h"
27
 
#include "applet-notifications.h"
28
 
#include "applet-draw.h"
29
 
#include "applet-dbus-callbacks.h"
30
 
#include "applet-connections.h"
31
 
 
32
 
#define _reset_proxy(p) if (p) {\
33
 
        g_object_unref (p);\
34
 
        p = NULL; }
35
 
 
36
 
static void g_cclosure_marshal_VOID__GHashTable_GHashTable (GClosure *c, GValue *r, guint n, const GValue *p, gpointer i, gpointer d)
37
 
{
38
 
        
39
 
}
40
 
 
41
 
gboolean cd_NetworkMonitor_connect_to_bus (void)
42
 
{
43
 
        cd_debug ("%s ()", __func__);
44
 
        //\_____________ On verifie la presence de NM sur le bus.
45
 
        if (! cairo_dock_dbus_detect_system_application("org.freedesktop.NetworkManager"))
46
 
                return FALSE;
47
 
        dbus_g_object_register_marshaller(g_cclosure_marshal_VOID__GHashTable_GHashTable,
48
 
                G_TYPE_NONE, CD_DBUS_TYPE_HASH_TABLE_OF_HASH_TABLE, G_TYPE_INVALID);  // pour la methode GetSettings (il faut le faire avant de recuperer tout proxy, sinon les signaux ne passent plus !)
49
 
        
50
 
        //\_____________ On recupere l'objet principal de NM.
51
 
        myData.dbus_proxy_NM = cairo_dock_create_new_system_proxy (
52
 
                "org.freedesktop.NetworkManager",
53
 
                "/org/freedesktop/NetworkManager",
54
 
                "org.freedesktop.NetworkManager");
55
 
        g_return_val_if_fail (DBUS_IS_G_PROXY (myData.dbus_proxy_NM), FALSE);
56
 
        myData.dbus_proxy_NM_prop = cairo_dock_create_new_system_proxy (
57
 
                "org.freedesktop.NetworkManager",
58
 
                "/org/freedesktop/NetworkManager",
59
 
                "org.freedesktop.DBus.Properties");
60
 
        g_return_val_if_fail (DBUS_IS_G_PROXY (myData.dbus_proxy_NM_prop), FALSE);
61
 
        
62
 
        //\_____________ On se connecte aux signaux de base : wifi active (WirelessEnabled && WirelessHardwareEnabled ), etat de NM (State).
63
 
        dbus_g_object_register_marshaller(g_cclosure_marshal_VOID__BOXED,
64
 
                G_TYPE_NONE, G_TYPE_HASH_TABLE ,G_TYPE_INVALID);  // enregistrement d'un marshaller specifique au signal (sinon impossible de le recuperer ni de le voir
65
 
        
66
 
        dbus_g_proxy_add_signal(myData.dbus_proxy_NM, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID);
67
 
        dbus_g_proxy_connect_signal(myData.dbus_proxy_NM, "PropertiesChanged",
68
 
                G_CALLBACK(onChangeNMProperties), NULL, NULL);
69
 
        
70
 
        //\_____________ On recupere l'objet des connections.
71
 
        myData.cServiceName = g_strdup ("org.freedesktop.NetworkManagerUserSettings");
72
 
        
73
 
        myData.dbus_proxy_Settings = cairo_dock_create_new_system_proxy (
74
 
                myData.cServiceName,
75
 
                "/org/freedesktop/NetworkManagerSettings",
76
 
                "org.freedesktop.NetworkManagerSettings");
77
 
        dbus_g_proxy_add_signal(myData.dbus_proxy_Settings, "NewConnection", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
78
 
        dbus_g_proxy_connect_signal(myData.dbus_proxy_Settings, "NewConnection",
79
 
                G_CALLBACK(onNewConnection), NULL, NULL);
80
 
        
81
 
        return TRUE;
82
 
}
83
 
 
84
 
gboolean cd_NetworkMonitor_get_device (void)
85
 
{
86
 
        cd_debug ("%s ()", __func__);
87
 
        //\_____________ On recupere la liste des devices.
88
 
        GPtrArray *paDevices = cairo_dock_dbus_get_array (myData.dbus_proxy_NM, "GetDevices");
89
 
        g_return_val_if_fail (paDevices != NULL, FALSE);
90
 
        
91
 
        //\_____________ On choisit celui defini en conf, ou un par defaut (wifi de preference).
92
 
        cd_debug ("%d devices", paDevices->len);
93
 
        DBusGProxy *dbus_proxy_Device_prop;
94
 
        gchar *cDevice;
95
 
        uint i;
96
 
        for (i = 0; i < paDevices->len; i++)
97
 
        {
98
 
                // on recupere le device.
99
 
                cDevice = (gchar *)g_ptr_array_index(paDevices, i);
100
 
                dbus_proxy_Device_prop = cairo_dock_create_new_system_proxy (
101
 
                        "org.freedesktop.NetworkManager",
102
 
                        cDevice,
103
 
                        "org.freedesktop.DBus.Properties");
104
 
                if (!DBUS_IS_G_PROXY (dbus_proxy_Device_prop))
105
 
                        continue;
106
 
                cd_debug (" device %s", cDevice);
107
 
                
108
 
                // on regarde son type.
109
 
                guint iDeviceType = cairo_dock_dbus_get_property_as_uint (dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device", "DeviceType");  // 1 : ethernet, 2 : wifi
110
 
                cd_debug (" device type : %d", iDeviceType);
111
 
                if (iDeviceType != 1 && iDeviceType != 2)  // ne nous insteresse pas.
112
 
                {
113
 
                        cd_debug (" useless device type\n");
114
 
                        g_object_unref (dbus_proxy_Device_prop);
115
 
                        continue;
116
 
                }
117
 
                
118
 
                // on recupere son interface.
119
 
                gchar *cInterface = cairo_dock_dbus_get_property_as_string (dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device", "Interface");
120
 
                cd_debug (" interface :%s", cInterface);
121
 
                
122
 
                // on regarde si on doit le selectionner ou pas.
123
 
                if (myData.cDevice != NULL)  // on a deja trouve un device, on regarde si celui-ci convient mieux.
124
 
                {
125
 
                        if (myConfig.cInterface && cInterface && strcmp (cInterface, myConfig.cInterface) == 0)  // c'est celui qu'on veut.
126
 
                        {
127
 
                                g_free (myData.cDevice);
128
 
                                myData.cDevice = NULL;
129
 
                                g_free (myData.cInterface);
130
 
                                myData.cInterface = NULL;
131
 
                                g_object_unref (myData.dbus_proxy_Device_prop);
132
 
                                myData.dbus_proxy_Device_prop = NULL;
133
 
                        }
134
 
                        else if (iDeviceType == 2 && myData.bWiredExt)  // c'est un wifi alors que celui qu'on a deja est un ethernet, on le prend a sa place.
135
 
                        {
136
 
                                g_free (myData.cDevice);
137
 
                                myData.cDevice = NULL;
138
 
                                g_free (myData.cInterface);
139
 
                                myData.cInterface = NULL;
140
 
                                g_object_unref (myData.dbus_proxy_Device_prop);
141
 
                                myData.dbus_proxy_Device_prop = NULL;
142
 
                        }
143
 
                }
144
 
                if (myData.cDevice == NULL)  // aucun autre device, on selectionne celui-la.
145
 
                {
146
 
                        cd_debug (" on selectionne ce device\n");
147
 
                        myData.dbus_proxy_Device_prop = dbus_proxy_Device_prop;
148
 
                        myData.cInterface = cInterface;
149
 
                        myData.cDevice = g_strdup (cDevice);
150
 
                        myData.bWiredExt = (iDeviceType == 1);
151
 
                        myData.bWirelessExt = (iDeviceType == 2);
152
 
                        if (myConfig.cInterface && cInterface && strcmp (cInterface, myConfig.cInterface) == 0)
153
 
                        {
154
 
                                cd_debug ("  c'est l'interface qu'on veut\n");
155
 
                                break;
156
 
                        }
157
 
                }
158
 
                else
159
 
                {
160
 
                        g_free (cInterface);
161
 
                        g_object_unref (dbus_proxy_Device_prop);
162
 
                }
163
 
        }
164
 
        g_ptr_array_free (paDevices, TRUE);  // on suppose qu'une GDestroyFunc a ete assignee au tableau.
165
 
        g_return_val_if_fail (myData.cDevice != NULL, FALSE);
166
 
        
167
 
        //\_____________ On complete le device.
168
 
        myData.dbus_proxy_Device = cairo_dock_create_new_system_proxy (
169
 
                "org.freedesktop.NetworkManager",
170
 
                myData.cDevice,
171
 
                "org.freedesktop.NetworkManager.Device");
172
 
        /// se conecter au changement de propriete State ?...
173
 
        
174
 
        if (myData.bWirelessExt)
175
 
        {
176
 
                // on se connecte au changement de la propriete ActiveAccessPoint.
177
 
                myData.dbus_proxy_WirelessDevice = cairo_dock_create_new_system_proxy (
178
 
                        "org.freedesktop.NetworkManager",
179
 
                        myData.cDevice,
180
 
                        "org.freedesktop.NetworkManager.Device.Wireless");
181
 
                dbus_g_proxy_add_signal(myData.dbus_proxy_WirelessDevice, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID);
182
 
                dbus_g_proxy_connect_signal(myData.dbus_proxy_WirelessDevice, "PropertiesChanged",
183
 
                        G_CALLBACK(onChangeWirelessDeviceProperties), NULL, NULL);
184
 
                
185
 
                cd_NetworkMonitor_get_wireless_connection_infos ();
186
 
        }
187
 
        else
188
 
        {
189
 
                // on se connecte au changement de la propriete Carrier.
190
 
                myData.dbus_proxy_WiredDevice = cairo_dock_create_new_system_proxy (
191
 
                        "org.freedesktop.NetworkManager",
192
 
                        myData.cDevice,
193
 
                        "org.freedesktop.NetworkManager.Device.Wired");
194
 
                dbus_g_proxy_add_signal(myData.dbus_proxy_WiredDevice, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID);
195
 
                dbus_g_proxy_connect_signal(myData.dbus_proxy_WiredDevice, "PropertiesChanged",
196
 
                        G_CALLBACK(onChangeWiredDeviceProperties), NULL, NULL);
197
 
                
198
 
                cd_NetworkMonitor_get_wired_connection_infos ();
199
 
        }
200
 
        
201
 
        return TRUE;
202
 
}
203
 
 
204
 
gboolean cd_NetworkMonitor_get_connection (void)
205
 
{
206
 
        cd_debug ("%s ()", __func__);
207
 
        
208
 
        myData.cServiceName = g_strdup ("org.freedesktop.NetworkManagerUserSettings");
209
 
        
210
 
        //\_____________ On recupere la liste des connexions disponibles (ce sont les configs tout-en-un de NM).
211
 
        DBusGProxy *dbus_proxy_Settings = cairo_dock_create_new_system_proxy (
212
 
                myData.cServiceName,
213
 
                "/org/freedesktop/NetworkManagerSettings",
214
 
                "org.freedesktop.NetworkManagerSettings");
215
 
        GPtrArray *paConnections = cairo_dock_dbus_get_array (dbus_proxy_Settings, "ListConnections");
216
 
        cd_debug ("%d connections", paConnections->len);
217
 
        
218
 
        //\_____________ On en choisit une.
219
 
        gchar *cConnection;
220
 
        uint i;
221
 
        for (i = 0; i < paConnections->len; i++)
222
 
        {
223
 
                cConnection = (gchar *)g_ptr_array_index(paConnections, i);
224
 
                cd_debug (" Connection path : %s", cConnection);
225
 
                
226
 
                myData.cConnection = g_strdup (cConnection);
227
 
        }
228
 
        
229
 
        g_ptr_array_free (paConnections, TRUE);
230
 
        g_object_unref (dbus_proxy_Settings);
231
 
        
232
 
        return (myData.cConnection != NULL);
233
 
}
234
 
 
235
 
gboolean cd_NetworkMonitor_get_active_connection_info (void)
236
 
{
237
 
        cd_debug ("%s ()", __func__);
238
 
        //\_____________ on reset tout.
239
 
        myData.bWiredExt = myData.bWirelessExt = FALSE;
240
 
        g_free (myData.cDevice);
241
 
        myData.cDevice = NULL;
242
 
        g_free (myData.cInterface);
243
 
        myData.cInterface = NULL;
244
 
        g_free (myData.cAccessPoint);
245
 
        myData.cAccessPoint = NULL;
246
 
        _reset_proxy (myData.dbus_proxy_ActiveConnection);
247
 
        _reset_proxy (myData.dbus_proxy_ActiveConnection_prop);
248
 
        _reset_proxy (myData.dbus_proxy_Device);
249
 
        _reset_proxy (myData.dbus_proxy_Device_prop);
250
 
        _reset_proxy (myData.dbus_proxy_ActiveAccessPoint);
251
 
        _reset_proxy (myData.dbus_proxy_ActiveAccessPoint_prop);
252
 
        _reset_proxy (myData.dbus_proxy_WirelessDevice);
253
 
        _reset_proxy (myData.dbus_proxy_WiredDevice);
254
 
        
255
 
        DBusGProxy *dbus_proxy_ActiveConnection_prop = NULL;
256
 
        DBusGProxy *dbus_proxy_Device_prop = NULL;
257
 
        
258
 
        uint j,k;
259
 
        GPtrArray *paActiveConnections = NULL;
260
 
        gchar *cActiveConnection, *cDevice, *cAccessPointPath, *cConnection;
261
 
        const gchar *cServiceName;
262
 
        
263
 
        //\_____________ On recupere la liste des connexions actives (ce sont les configs tout-en-un de NM qui sont actuellement utilisees).
264
 
        paActiveConnections = (GPtrArray*) cairo_dock_dbus_get_property_as_boxed (myData.dbus_proxy_NM_prop, "org.freedesktop.NetworkManager", "ActiveConnections");
265
 
        cd_debug ("%d connections", paActiveConnections->len);
266
 
        for (j=0; j < paActiveConnections->len; j++)
267
 
        {
268
 
                cActiveConnection = (gchar *)g_ptr_array_index(paActiveConnections,j);
269
 
                cd_debug ("Network-Monitor : Active Connection path : %s", cActiveConnection);
270
 
                
271
 
                // on recupere les proprietes de la connexion.
272
 
                dbus_proxy_ActiveConnection_prop = cairo_dock_create_new_system_proxy (
273
 
                        "org.freedesktop.NetworkManager",
274
 
                        cActiveConnection,
275
 
                        "org.freedesktop.DBus.Properties");
276
 
                GHashTable *props = cairo_dock_dbus_get_all_properties (dbus_proxy_ActiveConnection_prop, "org.freedesktop.NetworkManager.Connection.Active");
277
 
                if (props == NULL)
278
 
                {
279
 
                        g_object_unref (dbus_proxy_ActiveConnection_prop);
280
 
                        continue;
281
 
                }
282
 
                
283
 
                // on regarde si c'est la connexion par defaut.
284
 
                GValue *v = g_hash_table_lookup (props, "Default");
285
 
                if (!v || !G_VALUE_HOLDS_BOOLEAN (v) || ! g_value_get_boolean (v))
286
 
                {
287
 
                        g_hash_table_unref (props);
288
 
                        g_object_unref (dbus_proxy_ActiveConnection_prop);
289
 
                        continue;
290
 
                }
291
 
                cd_debug (" c'est la connexion par defaut\n");
292
 
                myData.cActiveConnection = g_strdup (cActiveConnection);
293
 
                
294
 
                // on recupere le SpecificObject qui contient le point d'acces courant.
295
 
                cAccessPointPath=NULL;
296
 
                v = g_hash_table_lookup (props, "SpecificObject");
297
 
                if (v && G_VALUE_HOLDS_BOXED (v))
298
 
                {
299
 
                        cAccessPointPath = g_value_get_boxed (v);
300
 
                        cd_debug (" cAccessPointPath : %s", cAccessPointPath);
301
 
                }
302
 
                
303
 
                // on recupere le nom du service qui fournit cette connexion.
304
 
                cServiceName=NULL;
305
 
                v = g_hash_table_lookup (props, "ServiceName");
306
 
                if (v && G_VALUE_HOLDS_STRING (v))
307
 
                {
308
 
                        cServiceName = g_value_get_string (v);
309
 
                        cd_debug (" cServiceName : %s", cServiceName);
310
 
                }
311
 
                
312
 
                // on recupere le chemin de la connection.
313
 
                cConnection=NULL;
314
 
                v = g_hash_table_lookup (props, "Connection");
315
 
                if (v && G_VALUE_HOLDS (v, DBUS_TYPE_G_OBJECT_PATH))
316
 
                {
317
 
                        cConnection = g_value_get_boxed (v);
318
 
                        cd_debug (" cConnectionPath : %s", cConnection);
319
 
                }
320
 
                
321
 
                // on parcourt la liste des devices associes.
322
 
                v = g_hash_table_lookup (props, "Devices");
323
 
                if (v && G_VALUE_HOLDS_BOXED (v))
324
 
                {
325
 
                        GPtrArray *paDevices = g_value_get_boxed (v);
326
 
                        cd_debug (" %d devices", paDevices->len);
327
 
                        for (k=0;  k < paDevices->len; k++)
328
 
                        {
329
 
                                // on recupere le device.
330
 
                                cDevice = (gchar *)g_ptr_array_index(paDevices,k);
331
 
                                cd_debug (" device path : %s", cDevice);
332
 
                                dbus_proxy_Device_prop = cairo_dock_create_new_system_proxy (
333
 
                                        "org.freedesktop.NetworkManager",
334
 
                                        cDevice,
335
 
                                        "org.freedesktop.DBus.Properties");
336
 
                                
337
 
                                // on regarde son type.
338
 
                                guint iDeviceType = cairo_dock_dbus_get_property_as_uint (dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device", "DeviceType");  // 1 : ethernet, 2 : wifi
339
 
                                cd_debug (" device type : %d", iDeviceType);
340
 
                                if (iDeviceType != 1 && iDeviceType != 2)  // ne nous insteresse pas.
341
 
                                {
342
 
                                        g_object_unref (dbus_proxy_Device_prop);
343
 
                                        continue;
344
 
                                }
345
 
                                
346
 
                                // on recupere son interface.
347
 
                                gchar *cInterface = cairo_dock_dbus_get_property_as_string (dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device", "Interface");
348
 
                                cd_debug (" interface :%s", cInterface);
349
 
                                
350
 
                                // on garde toutes les infos en memoire.
351
 
                                myData.cInterface = cInterface;
352
 
                                myData.cDevice = g_strdup(cDevice);
353
 
                                myData.cServiceName = g_strdup (cServiceName);
354
 
                                myData.cConnection = g_strdup (cConnection);
355
 
                                myData.dbus_proxy_ActiveConnection_prop = dbus_proxy_ActiveConnection_prop;
356
 
                                myData.dbus_proxy_ActiveConnection =  cairo_dock_create_new_system_proxy (
357
 
                                        "org.freedesktop.NetworkManager",
358
 
                                        myData.cActiveConnection,
359
 
                                        "org.freedesktop.NetworkManager.Connection.Active");
360
 
                                dbus_g_proxy_add_signal(myData.dbus_proxy_ActiveConnection, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID);
361
 
                                dbus_g_proxy_connect_signal(myData.dbus_proxy_ActiveConnection, "PropertiesChanged",
362
 
                                        G_CALLBACK(onChangeActiveConnectionProperties), NULL, NULL);
363
 
                                
364
 
                                myData.dbus_proxy_Device_prop = dbus_proxy_Device_prop;
365
 
                                myData.dbus_proxy_Device = cairo_dock_create_new_system_proxy (
366
 
                                        "org.freedesktop.NetworkManager",
367
 
                                        cDevice,
368
 
                                        "org.freedesktop.NetworkManager.Device");
369
 
                                
370
 
                                if (cAccessPointPath && strncmp (cAccessPointPath, "/org/freedesktop/NetworkManager/AccessPoint/", 44) == 0)
371
 
                                {
372
 
                                        myData.cAccessPoint = g_strdup (cAccessPointPath);
373
 
                                        myData.dbus_proxy_ActiveAccessPoint_prop = cairo_dock_create_new_system_proxy (
374
 
                                                "org.freedesktop.NetworkManager",
375
 
                                                cAccessPointPath,
376
 
                                                "org.freedesktop.DBus.Properties");
377
 
                                        myData.dbus_proxy_ActiveAccessPoint = cairo_dock_create_new_system_proxy (
378
 
                                                "org.freedesktop.NetworkManager",
379
 
                                                cAccessPointPath,
380
 
                                                "org.freedesktop.NetworkManager.AccessPoint");
381
 
                                        dbus_g_proxy_add_signal(myData.dbus_proxy_ActiveAccessPoint, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID);
382
 
                                        dbus_g_proxy_connect_signal(myData.dbus_proxy_ActiveAccessPoint, "PropertiesChanged",
383
 
                                                G_CALLBACK(onChangeAccessPointProperties), NULL, NULL);
384
 
                                }
385
 
                                
386
 
                                if (iDeviceType == 1)
387
 
                                {
388
 
                                        cd_debug (" => Network-Monitor : Connexion filaire\n");
389
 
                                        myData.bWiredExt = TRUE;
390
 
                                        
391
 
                                        // on se connecte au changement de la propriete Carrier.
392
 
                                        myData.dbus_proxy_WiredDevice = cairo_dock_create_new_system_proxy (
393
 
                                                "org.freedesktop.NetworkManager",
394
 
                                                myData.cDevice,
395
 
                                                "org.freedesktop.NetworkManager.Device.Wired");
396
 
                                        dbus_g_proxy_add_signal(myData.dbus_proxy_WiredDevice, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID);
397
 
                                        dbus_g_proxy_connect_signal(myData.dbus_proxy_WiredDevice, "PropertiesChanged",
398
 
                                                G_CALLBACK(onChangeWiredDeviceProperties), NULL, NULL);
399
 
                                        
400
 
                                        // on recupere les proprietes de la carte reseau, et de son etat connecte ou non.
401
 
                                        cd_NetworkMonitor_get_wired_connection_infos();
402
 
                                }
403
 
                                else
404
 
                                {
405
 
                                        cd_debug (" => Network-Monitor : Connexion sans fil\n");
406
 
                                        myData.bWirelessExt = TRUE;
407
 
                                        
408
 
                                        // on se connecte au changement de la propriete ActiveAccessPoint.
409
 
                                        myData.dbus_proxy_WirelessDevice = cairo_dock_create_new_system_proxy (
410
 
                                                "org.freedesktop.NetworkManager",
411
 
                                                myData.cDevice,
412
 
                                                "org.freedesktop.NetworkManager.Device.Wireless");
413
 
                                        dbus_g_proxy_add_signal(myData.dbus_proxy_WirelessDevice, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID);
414
 
                                        dbus_g_proxy_connect_signal(myData.dbus_proxy_WirelessDevice, "PropertiesChanged",
415
 
                                                G_CALLBACK(onChangeWirelessDeviceProperties), NULL, NULL);
416
 
                                        
417
 
                                        // Recuperation de l'AP active.
418
 
                                        cd_NetworkMonitor_get_wireless_connection_infos();
419
 
                                        
420
 
                                        // Calcul de la qualite du signal
421
 
                                        cd_NetworkMonitor_quality();
422
 
                                }
423
 
                                
424
 
                                cd_NetworkMonitor_draw_icon ();
425
 
                                
426
 
                                break ;
427
 
                        }  // fin de la liste des devices.
428
 
                }
429
 
                
430
 
                g_hash_table_unref (props);
431
 
                break;  // on prend la premierr connexion.
432
 
        }
433
 
        
434
 
        g_ptr_array_free(paActiveConnections,TRUE);
435
 
        return (myData.bWiredExt || myData.bWirelessExt);
436
 
}
437
 
 
438
 
 
439
 
void cd_NetworkMonitor_get_wireless_connection_infos (void)
440
 
{
441
 
        cd_debug ("%s ()", __func__);
442
 
        GHashTable *hProperties;
443
 
        GValue *v;
444
 
        
445
 
        g_free (myData.cAccessPointHwAdress);
446
 
        myData.cAccessPointHwAdress = NULL;
447
 
        myData.iSpeed = 0;
448
 
        
449
 
        //\_____________ On recupere les proprietes du device "wireless".
450
 
        hProperties = cairo_dock_dbus_get_all_properties (myData.dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device.Wireless");
451
 
        g_return_if_fail (hProperties != NULL);
452
 
        
453
 
        v = (GValue *)g_hash_table_lookup (hProperties, "Bitrate");
454
 
        if (v && G_VALUE_HOLDS_UINT (v))
455
 
        {
456
 
                myData.iSpeed = g_value_get_uint (v);
457
 
                cd_debug ("  Bitrate : %d\n",myData.iSpeed);
458
 
        }
459
 
        
460
 
        v = (GValue *)g_hash_table_lookup (hProperties, "HwAddress");
461
 
        if (v && G_VALUE_HOLDS_STRING (v))
462
 
        {
463
 
                myData.cAccessPointHwAdress = g_strdup(g_value_get_string (v));
464
 
                cd_debug ("  Adresse physique : %s\n",myData.cAccessPointHwAdress);
465
 
        }
466
 
        
467
 
        v = (GValue *)g_hash_table_lookup (hProperties, "ActiveAccessPoint");
468
 
        if (v && G_VALUE_HOLDS (v, DBUS_TYPE_G_OBJECT_PATH))
469
 
        {
470
 
                gchar *cAccessPoint = g_value_get_boxed (v);
471
 
                cd_debug ("  Access point : %s", cAccessPoint);
472
 
                if (cAccessPoint && strncmp (cAccessPoint, "/org/freedesktop/NetworkManager/AccessPoint/", 44) == 0)
473
 
                {
474
 
                        g_free (myData.cAccessPoint);
475
 
                        myData.cAccessPoint = g_strdup (cAccessPoint);
476
 
                }
477
 
        }
478
 
        
479
 
        g_hash_table_unref (hProperties);
480
 
        
481
 
        //\_____________ On recupere le point d'acces courant sur le bus.
482
 
        myData.iQuality = WIFI_QUALITY_NO_SIGNAL;
483
 
        if (myData.cAccessPoint != NULL)
484
 
        {
485
 
                cd_NetworkMonitor_get_new_access_point ();
486
 
        }
487
 
}
488
 
 
489
 
void cd_NetworkMonitor_get_wired_connection_infos (void)
490
 
{
491
 
        cd_debug ("%s ()", __func__);
492
 
        GHashTable *hProperties;
493
 
        GValue *v;
494
 
        
495
 
        //\_____________ On recupere les proprietes du device "wired"
496
 
        hProperties = cairo_dock_dbus_get_all_properties (myData.dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device.Wired");
497
 
        g_return_if_fail (hProperties != NULL);
498
 
        
499
 
        v = (GValue *)g_hash_table_lookup (hProperties, "Speed");
500
 
        if (v != NULL && G_VALUE_HOLDS_UINT (v))
501
 
        {
502
 
                myData.iSpeed = g_value_get_uint (v);
503
 
                cd_debug("  Vitesse de connexion : %d",myData.iSpeed);
504
 
        }
505
 
        
506
 
        v = (GValue *)g_hash_table_lookup (hProperties, "HwAddress");
507
 
        if (v != NULL && G_VALUE_HOLDS_STRING (v))
508
 
        {
509
 
                myData.cAccessPointHwAdress = g_strdup(g_value_get_string (v));
510
 
                cd_debug("  Adresse physique : %s",myData.cAccessPointHwAdress);
511
 
        }
512
 
        
513
 
        myData.iQuality = WIRED_NO_CONNECTION;
514
 
        v = (GValue *)g_hash_table_lookup (hProperties, "Carrier");
515
 
        if (v != NULL && G_VALUE_HOLDS_BOOLEAN (v))
516
 
        {
517
 
                if (g_value_get_boolean (v))
518
 
                        myData.iQuality = WIRED_CONNECTION;
519
 
                cd_debug("  cable branche : %d", g_value_get_boolean (v));
520
 
        }
521
 
        
522
 
        g_hash_table_unref (hProperties);
523
 
}
524
 
 
525
 
 
526
 
  //////////////////
527
 
 // ACCESS POINT //
528
 
//////////////////
529
 
 
530
 
void cd_NetworkMonitor_quality (void)
531
 
{
532
 
        if (myData.bWirelessExt)
533
 
        {
534
 
                if (myData.iPercent <= 0)
535
 
                        myData.iQuality = WIFI_QUALITY_NO_SIGNAL;
536
 
                else if (myData.iPercent < 20)
537
 
                        myData.iQuality = WIFI_QUALITY_VERY_LOW;
538
 
                else if (myData.iPercent < 40)
539
 
                        myData.iQuality = WIFI_QUALITY_LOW;
540
 
                else if (myData.iPercent < 60)
541
 
                        myData.iQuality = WIFI_QUALITY_MIDDLE;
542
 
                else if (myData.iPercent < 80)
543
 
                        myData.iQuality = WIFI_QUALITY_GOOD;
544
 
                else
545
 
                        myData.iQuality = WIFI_QUALITY_EXCELLENT;
546
 
        }
547
 
        else if (myData.bWiredExt)
548
 
                myData.iQuality = WIRED_CONNECTION;
549
 
}
550
 
 
551
 
// les proprietes d'un AccessPoint sont :
552
 
// Flags - u - (read)  (NM_802_11_AP_FLAGS)
553
 
//     Flags describing the capabilities of the access point.
554
 
// WpaFlags - u - (read) (NM_802_11_AP_SEC)
555
 
//     Flags describing the access point's capabilities according to WPA (Wifi Protected Access).
556
 
// RsnFlags - u - (read) (NM_802_11_AP_SEC)
557
 
//     Flags describing the access point's capabilities according to the RSN (Robust Secure Network) protocol.
558
 
// Ssid - ay - (read)
559
 
//     The Service Set Identifier identifying the access point.
560
 
// Frequency - u - (read)
561
 
//     The radio channel frequency in use by the access point, in MHz.
562
 
// HwAddress - s - (read)
563
 
//     The hardware address (BSSID) of the access point.
564
 
// Mode - u - (read) (NM_802_11_MODE)
565
 
//     Describes the operating mode of the access point.
566
 
// MaxBitrate - u - (read)
567
 
//     The maximum bitrate this access point is capable of, in kilobits/second (Kb/s).
568
 
// Strength - y - (read)
569
 
//     The current signal quality of the access point, in percent.
570
 
void cd_NetworkMonitor_fetch_access_point_properties (GHashTable *hProperties)
571
 
{
572
 
        GValue *v;
573
 
        v = (GValue *)g_hash_table_lookup (hProperties, "Strength");
574
 
        if (v != NULL && G_VALUE_HOLDS_UCHAR (v))
575
 
        {
576
 
                myData.iPercent = MIN (100, (gint) g_value_get_uchar (v));  // pas clair si c'est deja des % ou s'il faut convertir par 100/255, des fois on se chope des 255 ...
577
 
                cd_debug ("Network-Monitor : Force du signal : %d %%", myData.iPercent);
578
 
                cd_NetworkMonitor_quality ();
579
 
                cd_NetworkMonitor_draw_icon ();
580
 
        }
581
 
        
582
 
        v = (GValue *)g_hash_table_lookup (hProperties, "HwAddress");
583
 
        if (v != NULL && G_VALUE_HOLDS_STRING (v))
584
 
        {
585
 
                myData.cAccessPointHwAdress = g_strdup(g_value_get_string (v));
586
 
                cd_debug ("Network-Monitor : Adresse physique de l'AP active : %s", myData.cAccessPointHwAdress);
587
 
        }
588
 
        
589
 
        v = (GValue *)g_hash_table_lookup (hProperties, "Ssid");
590
 
        if (v != NULL && G_VALUE_HOLDS_BOXED (v))
591
 
        {
592
 
                GByteArray *a = g_value_get_boxed (v);
593
 
                myData.cESSID = g_new0 (gchar, a->len+1);
594
 
                for (uint i = 0; i < a->len; i ++)
595
 
                {
596
 
                        myData.cESSID[i] = a->data[i];
597
 
                }
598
 
                cd_debug ("Network-Monitor : SSID : %s", myData.cESSID);
599
 
        }
600
 
 
601
 
        v = (GValue *)g_hash_table_lookup (hProperties, "MaxBitrate");  // in kilobits/second (Kb/s).
602
 
        if (v != NULL && G_VALUE_HOLDS_UINT (v))
603
 
        {
604
 
                myData.iSpeed = (gint) g_value_get_uint (v) / 8;  // Ko/s
605
 
                cd_debug("Network-Monitor : Max Bitrate au demarrage : %d",myData.iSpeed);
606
 
        }
607
 
}
608
 
 
609
 
void cd_NetworkMonitor_get_access_point_properties (void)
610
 
{
611
 
        //\_____________ On recupere les proprietes associees.
612
 
        GHashTable *hProperties = cairo_dock_dbus_get_all_properties (myData.dbus_proxy_ActiveAccessPoint_prop, "org.freedesktop.NetworkManager.AccessPoint");
613
 
        g_return_if_fail (hProperties != NULL);
614
 
        
615
 
        myData.iQuality = WIFI_QUALITY_NO_SIGNAL;
616
 
        cd_NetworkMonitor_fetch_access_point_properties (hProperties);
617
 
        
618
 
        g_hash_table_unref (hProperties);
619
 
}
620
 
 
621
 
void cd_NetworkMonitor_get_new_access_point (void)
622
 
{
623
 
        myData.iQuality = WIFI_QUALITY_NO_SIGNAL;
624
 
        if (myData.cAccessPoint != NULL)
625
 
        {
626
 
                cd_debug (" on recupere le nouveau point d'acces...\n");
627
 
                if (myData.dbus_proxy_ActiveAccessPoint)
628
 
                {
629
 
                        dbus_g_proxy_disconnect_signal(myData.dbus_proxy_ActiveAccessPoint, "PropertiesChanged",
630
 
                                G_CALLBACK(onChangeAccessPointProperties), NULL);
631
 
                        g_object_unref (myData.dbus_proxy_ActiveAccessPoint);
632
 
                }
633
 
                if (myData.dbus_proxy_ActiveAccessPoint_prop)
634
 
                {
635
 
                        g_object_unref (myData.dbus_proxy_ActiveAccessPoint_prop);
636
 
                }
637
 
                
638
 
                myData.dbus_proxy_ActiveAccessPoint_prop = cairo_dock_create_new_system_proxy (
639
 
                        "org.freedesktop.NetworkManager",
640
 
                        myData.cAccessPoint,
641
 
                        "org.freedesktop.DBus.Properties");
642
 
                myData.dbus_proxy_ActiveAccessPoint = cairo_dock_create_new_system_proxy (
643
 
                        "org.freedesktop.NetworkManager",
644
 
                        myData.cAccessPoint,
645
 
                        "org.freedesktop.NetworkManager.AccessPoint");
646
 
                dbus_g_proxy_add_signal(myData.dbus_proxy_ActiveAccessPoint, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID);
647
 
                dbus_g_proxy_connect_signal(myData.dbus_proxy_ActiveAccessPoint, "PropertiesChanged",
648
 
                        G_CALLBACK(onChangeAccessPointProperties), NULL, NULL);
649
 
                
650
 
                cd_NetworkMonitor_get_access_point_properties ();
651
 
        }
652
 
}
653
 
 
654
 
/*
655
 
#!/usr/bin/env python
656
 
# The url the program will try to open hoping to be redirected to the portal
657
 
URL = 'http://perdu.com/'
658
 
 
659
 
import sys
660
 
import gobject
661
 
import dbus
662
 
import dbus.mainloop.glib
663
 
import urllib2, urllib
664
 
from BeautifulSoup import BeautifulSoup
665
 
import re
666
 
import ConfigParser
667
 
import os
668
 
import pynotify
669
 
 
670
 
def properties_changed_signal_handler(props):
671
 
    if not props.has_key('ActiveConnections'):
672
 
        return
673
 
    for device_path in props['ActiveConnections']:
674
 
        device = bus.get_object('org.freedesktop.NetworkManager', device_path)
675
 
        device_props = device.GetAll("org.freedesktop.NetworkManager.Connection.Active", dbus_interface="org.freedesktop.DBus.Properties")
676
 
        if device_props['Default']:
677
 
            return
678
 
        ap_path = device_props['SpecificObject']
679
 
        if ap_path.startswith('/org/freedesktop/NetworkManager/AccessPoint/'):
680
 
            ap = bus.get_object('org.freedesktop.NetworkManager', ap_path)
681
 
            ssid = ap.Get("org.freedesktop.NetworkManager.AccessPoint", "Ssid", dbus_interface="org.freedesktop.DBus.Properties")
682
 
            ssid = ''.join([chr(c) for c in ssid])
683
 
            if ssid not in config.sections():
684
 
                return
685
 
            print ssid
686
 
            device.connect_to_signal("PropertiesChanged", device_properties_changed_signal_handler(ssid), dbus_interface="org.freedesktop.NetworkManager.Connection.Active")
687
 
 
688
 
def device_properties_changed_signal_handler(ssid):
689
 
    def handler(props):
690
 
        if not props.has_key('State'):
691
 
            return
692
 
        if props['State'] != 2:
693
 
            return
694
 
        print ssid
695
 
        section = dict(config.items(ssid))
696
 
 
697
 
        if login(section):
698
 
            txt = "Successfully logged on " + ssid
699
 
        else:
700
 
            txt = "Failled to log on " + ssid
701
 
        n = pynotify.Notification("Open Wifi Auto Connect", txt, "dialog-warning")
702
 
        n.set_urgency(pynotify.URGENCY_NORMAL)
703
 
        n.set_timeout(10)
704
 
        #n.add_action("clicked","Button text", callback_function, None)
705
 
        n.show()
706
 
    return handler
707
 
 
708
 
 
709
 
def login(values):
710
 
    # build an http fetcher that support cookies
711
 
    opener = urllib2.build_opener( urllib2.HTTPCookieProcessor() )
712
 
    urllib2.install_opener(opener)
713
 
 
714
 
    # try to open the portal page
715
 
    f = opener.open(URL)
716
 
    data = f.read()
717
 
    redirect_url = f.geturl().split('?')[0]
718
 
    f.close()
719
 
    if redirect_url == URL:
720
 
        return # Our request wasn't hijacked by the portal (maybe the wifi network isn't the default connection)
721
 
 
722
 
    # parse the portal page
723
 
    soup = BeautifulSoup(data)
724
 
    form = soup.find('form')
725
 
    if not form:
726
 
        return # There's no form on this page
727
 
    
728
 
    # creating the post values
729
 
    login_post = {}
730
 
    for input in form.findAll('input'):
731
 
        if input.has_key('name'):
732
 
            default = ''
733
 
            if input.has_key('type') and input['type'] == 'checkbox':
734
 
                default = 'on'
735
 
            login_post[input['name']] = input.has_key('value') and input['value'] or default
736
 
 
737
 
    login_post.update(values)
738
 
 
739
 
    # guessing the post url
740
 
    if not form.has_key('action'):
741
 
        url = redirect_url
742
 
    elif not form['action'].startswith('/'):
743
 
        url = '/'.join(redirect_url.split('/')[:-1]) + '/' + form['action']
744
 
    else:
745
 
        url = '/'.join(redirect_url.split('/')[:3]) + form['action']
746
 
 
747
 
    # GET ou POST ?
748
 
    postBody = None
749
 
    if form.has_key('method') and form['method'].lower() == 'post':
750
 
        postBody = urllib.urlencode(login_post)
751
 
    else:
752
 
        url += '?' + urllib.urlencode(login_post).replace(' ', '+')
753
 
 
754
 
    # submit the form
755
 
    f = opener.open(url, postBody)
756
 
    data = f.read()
757
 
    f.close()
758
 
 
759
 
    # Test if the login was a success
760
 
    f = opener.open(URL)
761
 
    data = f.read()
762
 
    status = f.geturl() == URL
763
 
    f.close()
764
 
    return status
765
 
 
766
 
if __name__ == '__main__':
767
 
    config = ConfigParser.RawConfigParser()
768
 
    config.read(os.path.expanduser('~/.OpenWifiAutoConnect'))
769
 
 
770
 
    pynotify.init( "Open Wifi Auto Connect" )
771
 
 
772
 
    dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
773
 
 
774
 
    bus = dbus.SystemBus()
775
 
    nm = bus.get_object("org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager")
776
 
    nm.connect_to_signal("PropertiesChanged", properties_changed_signal_handler, dbus_interface="org.freedesktop.NetworkManager")
777
 
 
778
 
    loop = gobject.MainLoop()
779
 
    loop.run()
780
 
*/