← Back to branch summary

~dylanmccall/ubuntu/oneiric/network-manager-applet/lp852961-disable-autostart-for-gnome-shell

« back to all changes in this revision

Viewing changes to src/nm-device.c

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Mercatante
  • Date: 2007-06-15 12:46:22 UTC
  • Revision ID: james.westby@ubuntu.com-20070615124622-01cyrnf0uxxun4lz
Tags: upstream-0.6.5
Import upstream version 0.6.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/nm-device.c
 
1
/* -*- Mode: C; tab-width: 5; indent-tabs-mode: t; c-basic-offset: 5 -*- */
 
2
/* NetworkManager Wireless Applet -- Display wireless access points and allow user control
 
3
 *
 
4
 * Dan Williams <dcbw@redhat.com>
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; either version 2 of the License, or
 
9
 * (at your option) any later version.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 * GNU General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License
 
17
 * along with this program; if not, write to the Free Software
 
18
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
19
 *
 
20
 * (C) Copyright 2004-2005 Red Hat, Inc.
 
21
 */
 
22
 
 
23
 
 
24
#include <glib.h>
 
25
#include <string.h>
 
26
#include "nm-device.h"
 
27
 
 
28
 
 
29
/*
 
30
 * Representation of network device
 
31
 *
 
32
 */
 
33
struct NetworkDevice
 
34
{
 
35
        int                     refcount;
 
36
        char *          iface;
 
37
        char *          driver;
 
38
        char *          desc;
 
39
        char *          nm_path;
 
40
        NMDeviceType    type;
 
41
        gboolean                active;
 
42
        gboolean                link;
 
43
        guint32         caps;
 
44
        guint32         type_caps;
 
45
        char *          addr;
 
46
        char *          ip4addr;
 
47
        char *          broadcast;
 
48
        char *          netmask;
 
49
        char *          udi;
 
50
        char *          route;
 
51
        char *          primary_dns;
 
52
        char *          secondary_dns;
 
53
        gint                    strength;
 
54
        gint                    speed;
 
55
        GSList *                networks;
 
56
        NMActStage      act_stage;
 
57
};
 
58
 
 
59
 
 
60
/*
 
61
 * network_device_new
 
62
 *
 
63
 * Create a new network device representation
 
64
 *
 
65
 */
 
66
NetworkDevice *network_device_new (const char *iface, NMDeviceType type, const char *nm_path)
 
67
{
 
68
        NetworkDevice *dev = g_malloc0 (sizeof (NetworkDevice));
 
69
 
 
70
        dev->refcount = 1;
 
71
        dev->iface = g_strdup (iface);
 
72
        dev->type = type;
 
73
        dev->nm_path = g_strdup (nm_path);
 
74
 
 
75
        return dev;
 
76
}
 
77
 
 
78
 
 
79
/*
 
80
 * network_device_copy
 
81
 *
 
82
 * Create a new network device representation, filling its
 
83
 * data in from an already existing one.  Deep-copies the
 
84
 * wireless networks too.
 
85
 *
 
86
 */
 
87
NetworkDevice *network_device_copy (NetworkDevice *src)
 
88
{
 
89
        NetworkDevice   *dev;
 
90
        GSList          *elt;
 
91
 
 
92
        g_return_val_if_fail (src != NULL, NULL);
 
93
 
 
94
        dev = g_malloc0 (sizeof (NetworkDevice));
 
95
 
 
96
        network_device_ref (dev);
 
97
        dev->nm_path = g_strdup (src->nm_path);
 
98
        dev->driver = g_strdup (src->driver);
 
99
        dev->type = src->type;
 
100
        dev->link = src->link;
 
101
        dev->addr = g_strdup (src->addr);
 
102
        dev->ip4addr = g_strdup (src->ip4addr);
 
103
        dev->broadcast = g_strdup (src->broadcast);
 
104
        dev->netmask = g_strdup (src->netmask);
 
105
        dev->caps = src->caps;
 
106
        dev->iface = g_strdup (src->iface);
 
107
        dev->desc = g_strdup (src->desc);
 
108
        dev->route = g_strdup (src->route);
 
109
        dev->udi = g_strdup (src->udi);
 
110
        dev->active = src->active;
 
111
        dev->act_stage = src->act_stage;
 
112
        dev->strength = src->strength;
 
113
 
 
114
        for (elt = src->networks; elt; elt = g_slist_next (elt))
 
115
        {
 
116
                WirelessNetwork *net = (WirelessNetwork *)elt->data;
 
117
                if (net)
 
118
                {
 
119
                        WirelessNetwork *copy = wireless_network_copy (net);
 
120
                        dev->networks = g_slist_append (dev->networks, copy);
 
121
                }
 
122
        }
 
123
 
 
124
        return dev;
 
125
}
 
126
 
 
127
 
 
128
/*
 
129
 * network_device_ref
 
130
 *
 
131
 * Increment the reference count of the network device
 
132
 *
 
133
 */
 
134
void network_device_ref (NetworkDevice *dev)
 
135
{
 
136
        g_return_if_fail (dev != NULL);
 
137
 
 
138
        dev->refcount++;
 
139
}
 
140
 
 
141
 
 
142
/*
 
143
 * network_device_unref
 
144
 *
 
145
 * Unrefs (and possibly frees) the representation of a network device
 
146
 *
 
147
 */
 
148
void network_device_unref (NetworkDevice *dev)
 
149
{
 
150
        g_return_if_fail (dev != NULL);
 
151
 
 
152
        dev->refcount--;
 
153
        if (dev->refcount < 1)
 
154
        {
 
155
                if (dev->type == DEVICE_TYPE_802_11_WIRELESS)
 
156
                        network_device_clear_wireless_networks (dev);
 
157
                g_free (dev->nm_path);
 
158
                g_free (dev->iface);
 
159
                g_free (dev->driver);
 
160
                g_free (dev->route);
 
161
                g_free (dev->udi);
 
162
                g_free (dev->desc);
 
163
                g_free (dev->addr);
 
164
                g_free (dev->broadcast);
 
165
                g_free (dev->netmask);
 
166
                g_free (dev->ip4addr);
 
167
                g_free (dev->primary_dns);
 
168
                g_free (dev->secondary_dns);
 
169
                memset (dev, 0, sizeof (NetworkDevice));
 
170
                g_free (dev);
 
171
        }
 
172
}
 
173
 
 
174
 
 
175
gboolean network_device_is_wired (NetworkDevice *dev)
 
176
{
 
177
        g_return_val_if_fail (dev != NULL, FALSE);
 
178
 
 
179
        return (network_device_get_type (dev) == DEVICE_TYPE_802_3_ETHERNET);
 
180
}
 
181
 
 
182
 
 
183
gboolean network_device_is_wireless (NetworkDevice *dev)
 
184
{
 
185
        g_return_val_if_fail (dev != NULL, FALSE);
 
186
 
 
187
        return (network_device_get_type (dev) == DEVICE_TYPE_802_11_WIRELESS);
 
188
}
 
189
 
 
190
 
 
191
/*
 
192
 * network_device_get_active_wireless_network
 
193
 *
 
194
 * Return the active wireless network.
 
195
 *
 
196
 */
 
197
WirelessNetwork *network_device_get_active_wireless_network (NetworkDevice *dev)
 
198
{
 
199
        GSList *                        list;
 
200
        WirelessNetwork *       active = NULL;
 
201
 
 
202
        g_return_val_if_fail (dev != NULL, NULL);
 
203
        g_return_val_if_fail (dev->type == DEVICE_TYPE_802_11_WIRELESS, NULL);
 
204
 
 
205
        for (list = dev->networks; list; list = list->next)
 
206
        {
 
207
                WirelessNetwork *net = (WirelessNetwork *) list->data;
 
208
 
 
209
                if (wireless_network_get_active (net))
 
210
                {
 
211
                        active = net;
 
212
                        break;
 
213
                }
 
214
        }
 
215
 
 
216
        return active;  
 
217
}
 
218
 
 
219
 
 
220
/*
 
221
 * network_device_get_wireless_network_by_essid
 
222
 *
 
223
 * Return the wireless network with the specified essid.
 
224
 *
 
225
 */
 
226
WirelessNetwork *network_device_get_wireless_network_by_essid (NetworkDevice *dev, const char *essid)
 
227
{
 
228
        GSList *                        list;
 
229
        WirelessNetwork *       return_net = NULL;
 
230
 
 
231
        g_return_val_if_fail (dev != NULL, NULL);
 
232
        g_return_val_if_fail (dev->type == DEVICE_TYPE_802_11_WIRELESS, NULL);
 
233
        g_return_val_if_fail (essid != NULL, NULL);
 
234
 
 
235
        for (list = dev->networks; list; list = list->next)
 
236
        {
 
237
                WirelessNetwork *net = (WirelessNetwork *) list->data;
 
238
 
 
239
                if (!strcmp (wireless_network_get_essid (net), essid))
 
240
                {
 
241
                        return_net = net;
 
242
                        break;
 
243
                }
 
244
        }
 
245
 
 
246
        return return_net;      
 
247
}
 
248
 
 
249
 
 
250
/*
 
251
 * network_device_get_wireless_network_by_nm_path
 
252
 *
 
253
 * Return the wireless network with the specified NetworkManager object path.
 
254
 *
 
255
 */
 
256
WirelessNetwork *network_device_get_wireless_network_by_nm_path (NetworkDevice *dev, const char *nm_path)
 
257
{
 
258
        GSList *                        list;
 
259
        WirelessNetwork *       return_net = NULL;
 
260
 
 
261
        g_return_val_if_fail (dev != NULL, NULL);
 
262
        g_return_val_if_fail (dev->type == DEVICE_TYPE_802_11_WIRELESS, NULL);
 
263
        g_return_val_if_fail (nm_path != NULL, NULL);
 
264
 
 
265
        for (list = dev->networks; list; list = list->next)
 
266
        {
 
267
                WirelessNetwork *net = (WirelessNetwork *) list->data;
 
268
 
 
269
                if (!strcmp (wireless_network_get_nm_path (net), nm_path))
 
270
                {
 
271
                        return_net = net;
 
272
                        break;
 
273
                }
 
274
        }
 
275
 
 
276
        return return_net;      
 
277
}
 
278
 
 
279
 
 
280
/*
 
281
 * network_device_get_wireless_network_by_nm_path
 
282
 *
 
283
 * Return the wireless network with the specified NetworkManager object path.
 
284
 *
 
285
 */
 
286
void network_device_foreach_wireless_network (NetworkDevice *dev, WirelessNetworkForeach func, gpointer user_data)
 
287
{
 
288
        GSList *                        list;
 
289
 
 
290
        g_return_if_fail (dev != NULL);
 
291
        g_return_if_fail (dev->type == DEVICE_TYPE_802_11_WIRELESS);
 
292
        g_return_if_fail (func != NULL);
 
293
 
 
294
        for (list = dev->networks; list; list = list->next)
 
295
        {
 
296
                WirelessNetwork *net = (WirelessNetwork *) list->data;
 
297
 
 
298
                if (net)
 
299
                        (*func)(dev, net, user_data);
 
300
        }
 
301
}
 
302
 
 
303
 
 
304
/*
 
305
 * network_device_add_wireless_network
 
306
 *
 
307
 * Adds a wireless network to the network device's network list
 
308
 *
 
309
 */
 
310
void network_device_add_wireless_network (NetworkDevice *dev, WirelessNetwork *net)
 
311
{
 
312
        g_return_if_fail (dev != NULL);
 
313
        g_return_if_fail (dev->type == DEVICE_TYPE_802_11_WIRELESS);
 
314
        g_return_if_fail (net != NULL);
 
315
 
 
316
        wireless_network_ref (net);
 
317
        dev->networks = g_slist_append (dev->networks, net);
 
318
}
 
319
 
 
320
 
 
321
/*
 
322
 * network_device_clear_wireless_networks
 
323
 *
 
324
 */
 
325
void network_device_clear_wireless_networks (NetworkDevice *dev)
 
326
{
 
327
        g_return_if_fail (dev != NULL);
 
328
        g_return_if_fail (dev->type == DEVICE_TYPE_802_11_WIRELESS);
 
329
 
 
330
        g_slist_foreach (dev->networks, (GFunc) wireless_network_unref, NULL);
 
331
        g_slist_free (dev->networks);
 
332
        dev->networks = NULL;   
 
333
}
 
334
 
 
335
 
 
336
/*
 
337
 * network_device_remove_wireless_network
 
338
 *
 
339
 * Remove one wireless network from the wireless network list
 
340
 *
 
341
 */
 
342
void network_device_remove_wireless_network (NetworkDevice *dev, WirelessNetwork *net)
 
343
{
 
344
        GSList  *elt;
 
345
 
 
346
        g_return_if_fail (dev != NULL);
 
347
        g_return_if_fail (dev->type == DEVICE_TYPE_802_11_WIRELESS);
 
348
        g_return_if_fail (net != NULL);
 
349
 
 
350
        for (elt = dev->networks; elt; elt = g_slist_next (elt))
 
351
        {
 
352
                if (elt->data == net)
 
353
                {
 
354
                        dev->networks = g_slist_remove_link (dev->networks, elt);
 
355
                        wireless_network_unref ((WirelessNetwork *)elt->data);
 
356
                        g_slist_free (elt);
 
357
                        break;
 
358
                }
 
359
        }
 
360
}
 
361
 
 
362
 
 
363
static int sort_networks_function (WirelessNetwork *a, WirelessNetwork *b)
 
364
{
 
365
        const char *name_a = wireless_network_get_essid (a);
 
366
        const char *name_b = wireless_network_get_essid (b);
 
367
 
 
368
        if (name_a && !name_b)
 
369
                return -1;
 
370
        else if (!name_a && name_b)
 
371
                return 1;
 
372
        else if (!name_a && !name_b)
 
373
                return 0;
 
374
        else
 
375
                return strcasecmp (name_a, name_b);
 
376
}
 
377
 
 
378
 
 
379
/*
 
380
 * network_device_sort_wireless_networks
 
381
 *
 
382
 * Alphabetize the wireless networks list
 
383
 *
 
384
 */
 
385
void network_device_sort_wireless_networks (NetworkDevice *dev)
 
386
{
 
387
        g_return_if_fail (dev != NULL);
 
388
        g_return_if_fail (dev->type == DEVICE_TYPE_802_11_WIRELESS);
 
389
 
 
390
        dev->networks = g_slist_sort (dev->networks, (GCompareFunc) sort_networks_function);
 
391
}
 
392
 
 
393
 
 
394
/*
 
395
 * network_device_get_num_wireless_networks
 
396
 *
 
397
 * Return the number of wireless networks this device knows about.
 
398
 *
 
399
 */
 
400
guint network_device_get_num_wireless_networks (NetworkDevice *dev)
 
401
{
 
402
        g_return_val_if_fail (dev != NULL, 0);
 
403
        g_return_val_if_fail (dev->type == DEVICE_TYPE_802_11_WIRELESS, 0);
 
404
        
 
405
        return g_slist_length (dev->networks);
 
406
}
 
407
 
 
408
 
 
409
/*
 
410
 * Accessors for driver name
 
411
 */
 
412
const char *network_device_get_driver (NetworkDevice *dev)
 
413
{
 
414
        g_return_val_if_fail (dev != NULL, NULL);
 
415
 
 
416
        return dev->driver;
 
417
}
 
418
 
 
419
void network_device_set_driver (NetworkDevice *dev, const char *driver)
 
420
{
 
421
        g_return_if_fail (dev != NULL);
 
422
 
 
423
        if (dev->driver)
 
424
                g_free (dev->driver);
 
425
        dev->driver = driver ? g_strdup (driver) : NULL;
 
426
}
 
427
 
 
428
/*
 
429
 * Accessors for hardware address
 
430
 */
 
431
const char *network_device_get_address (NetworkDevice *dev)
 
432
{
 
433
        g_return_val_if_fail (dev != NULL, NULL);
 
434
 
 
435
        return (dev->addr);
 
436
}
 
437
 
 
438
void network_device_set_address (NetworkDevice *dev, const char *addr)
 
439
{
 
440
        g_return_if_fail (dev != NULL);
 
441
 
 
442
        if (dev->addr)
 
443
                g_free (dev->addr);
 
444
        dev->addr = addr ? g_strdup (addr) : NULL;
 
445
}
 
446
 
 
447
/*
 
448
 * Accessors for broadcast address
 
449
 */
 
450
const char *network_device_get_broadcast (NetworkDevice *dev)
 
451
{
 
452
        g_return_val_if_fail (dev != NULL, NULL);
 
453
 
 
454
        return (dev->broadcast);
 
455
}
 
456
 
 
457
void network_device_set_broadcast (NetworkDevice *dev, const char *addr)
 
458
{
 
459
        g_return_if_fail (dev != NULL);
 
460
 
 
461
        if (dev->broadcast)
 
462
                g_free (dev->broadcast);
 
463
        dev->broadcast = addr ? g_strdup (addr) : NULL;
 
464
}
 
465
 
 
466
/*
 
467
 * Accessors for subnet address
 
468
 */
 
469
const char *network_device_get_netmask (NetworkDevice *dev)
 
470
{
 
471
        g_return_val_if_fail (dev != NULL, NULL);
 
472
 
 
473
        return (dev->netmask);
 
474
}
 
475
 
 
476
void network_device_set_netmask (NetworkDevice *dev, const char *addr)
 
477
{
 
478
        g_return_if_fail (dev != NULL);
 
479
 
 
480
        if (dev->netmask)
 
481
                g_free (dev->netmask);
 
482
        dev->netmask = addr ? g_strdup (addr) : NULL;
 
483
}
 
484
 
 
485
/*
 
486
 * Accessors for ip4 address
 
487
 */
 
488
const char *network_device_get_ip4_address (NetworkDevice *dev)
 
489
{
 
490
        g_return_val_if_fail (dev != NULL, NULL);
 
491
 
 
492
        return (dev->ip4addr);
 
493
}
 
494
 
 
495
void network_device_set_ip4_address (NetworkDevice *dev, const char *addr)
 
496
{
 
497
        g_return_if_fail (dev != NULL);
 
498
 
 
499
        if (dev->ip4addr)
 
500
                g_free (dev->ip4addr);
 
501
        dev->ip4addr = addr ? g_strdup (addr) : NULL;
 
502
}
 
503
 
 
504
/*
 
505
 * Accessors for default route
 
506
 */
 
507
const char *network_device_get_route (NetworkDevice *dev)
 
508
{
 
509
        g_return_val_if_fail (dev != NULL, NULL);
 
510
 
 
511
        return (dev->route);
 
512
}
 
513
 
 
514
void network_device_set_route (NetworkDevice *dev, const char *route)
 
515
{
 
516
        g_return_if_fail (dev != NULL);
 
517
 
 
518
        if (dev->route)
 
519
                g_free (dev->route);
 
520
        dev->route = route ? g_strdup (route) : NULL;
 
521
}
 
522
 
 
523
/*
 
524
 * Accessors for primary DNS
 
525
 */
 
526
const char *network_device_get_primary_dns (NetworkDevice *dev)
 
527
{
 
528
        g_return_val_if_fail (dev != NULL, NULL);
 
529
 
 
530
        return (dev->primary_dns);
 
531
}
 
532
 
 
533
void network_device_set_primary_dns (NetworkDevice *dev, const char *dns)
 
534
{
 
535
        g_return_if_fail (dev != NULL);
 
536
 
 
537
        if (dev->primary_dns)
 
538
                g_free (dev->primary_dns);
 
539
        dev->primary_dns = dns ? g_strdup (dns) : NULL;
 
540
}
 
541
 
 
542
/*
 
543
 * Accessors for secondary DNS
 
544
 */
 
545
const char *network_device_get_secondary_dns (NetworkDevice *dev)
 
546
{
 
547
        g_return_val_if_fail (dev != NULL, NULL);
 
548
 
 
549
        return (dev->secondary_dns);
 
550
}
 
551
 
 
552
void network_device_set_secondary_dns (NetworkDevice *dev, const char *dns)
 
553
{
 
554
        g_return_if_fail (dev != NULL);
 
555
 
 
556
        if (dev->secondary_dns)
 
557
                g_free (dev->secondary_dns);
 
558
        dev->secondary_dns = dns ? g_strdup (dns) : NULL;
 
559
}
 
560
 
 
561
/*
 
562
 * Accessors for device capabilities
 
563
 */
 
564
guint32 network_device_get_capabilities (NetworkDevice *dev)
 
565
{
 
566
        g_return_val_if_fail (dev != NULL, NM_DEVICE_CAP_NONE);
 
567
 
 
568
        return dev->caps;
 
569
}
 
570
 
 
571
void network_device_set_capabilities (NetworkDevice *dev, guint32 caps)
 
572
{
 
573
        g_return_if_fail (dev != NULL);
 
574
 
 
575
        dev->caps = caps;
 
576
}
 
577
 
 
578
/*
 
579
 * Accessors for type-specific device capabilities
 
580
 */
 
581
guint32 network_device_get_type_capabilities (NetworkDevice *dev)
 
582
{
 
583
        g_return_val_if_fail (dev != NULL, NM_DEVICE_CAP_NONE);
 
584
 
 
585
        return dev->type_caps;
 
586
}
 
587
 
 
588
void network_device_set_type_capabilities (NetworkDevice *dev, guint32 type_caps)
 
589
{
 
590
        g_return_if_fail (dev != NULL);
 
591
 
 
592
        dev->type_caps = type_caps;
 
593
}
 
594
 
 
595
/*
 
596
 * Accessors for NM object path
 
597
 */
 
598
const char *network_device_get_nm_path (NetworkDevice *dev)
 
599
{
 
600
        g_return_val_if_fail (dev != NULL, NULL);
 
601
 
 
602
        return (dev->nm_path);
 
603
}
 
604
 
 
605
/*
 
606
 * Accessors for device type
 
607
 */
 
608
NMDeviceType network_device_get_type (NetworkDevice *dev)
 
609
{
 
610
        g_return_val_if_fail (dev != NULL, DEVICE_TYPE_UNKNOWN);
 
611
 
 
612
        return (dev->type);
 
613
}
 
614
 
 
615
/*
 
616
 * Accessors for strength
 
617
 */
 
618
gint network_device_get_strength (NetworkDevice *dev)
 
619
{
 
620
        g_return_val_if_fail (dev != NULL, -1);
 
621
        g_return_val_if_fail (dev->type == DEVICE_TYPE_802_11_WIRELESS, -1);
 
622
 
 
623
        return (dev->strength);
 
624
}
 
625
 
 
626
void network_device_set_strength (NetworkDevice *dev, gint strength)
 
627
{
 
628
        g_return_if_fail (dev != NULL);
 
629
        g_return_if_fail (dev->type == DEVICE_TYPE_802_11_WIRELESS);
 
630
 
 
631
        dev->strength = strength;
 
632
}
 
633
 
 
634
/*
 
635
 * Accessors for device's interface name
 
636
 */
 
637
const char *network_device_get_iface (NetworkDevice *dev)
 
638
{
 
639
        g_return_val_if_fail (dev != NULL, NULL);
 
640
 
 
641
        return (dev->iface);
 
642
}
 
643
 
 
644
/*
 
645
 * Accessors for HAL udi
 
646
 */
 
647
const char *network_device_get_hal_udi (NetworkDevice *dev)
 
648
{
 
649
        g_return_val_if_fail (dev != NULL, NULL);
 
650
 
 
651
        return (dev->udi);
 
652
}
 
653
 
 
654
void network_device_set_hal_udi (NetworkDevice *dev, const char *hal_udi)
 
655
{
 
656
        g_return_if_fail (dev != NULL);
 
657
 
 
658
        if (dev->udi)
 
659
        {
 
660
                g_free (dev->udi);
 
661
                dev->udi = NULL;
 
662
        }
 
663
        if (hal_udi)
 
664
                dev->udi = g_strdup (hal_udi);
 
665
}
 
666
 
 
667
/*
 
668
 * Accessors for link
 
669
 */
 
670
gboolean network_device_get_link (NetworkDevice *dev)
 
671
{
 
672
        g_return_val_if_fail (dev != NULL, FALSE);
 
673
 
 
674
        return (dev->link);
 
675
}
 
676
 
 
677
void network_device_set_link (NetworkDevice *dev, gboolean new_link)
 
678
{
 
679
        g_return_if_fail (dev != NULL);
 
680
 
 
681
        dev->link = new_link;
 
682
}
 
683
 
 
684
/*
 
685
 * Accessors for speed (in Mb/s)
 
686
 */
 
687
int network_device_get_speed (NetworkDevice *dev)
 
688
{
 
689
        g_return_val_if_fail (dev != NULL, FALSE);
 
690
 
 
691
        return (dev->speed);
 
692
}
 
693
 
 
694
void network_device_set_speed (NetworkDevice *dev, int speed)
 
695
{
 
696
        g_return_if_fail (dev != NULL);
 
697
 
 
698
        dev->speed = speed;
 
699
}
 
700
 
 
701
/*
 
702
 * Accessors for active
 
703
 */
 
704
gboolean network_device_get_active (NetworkDevice *dev)
 
705
{
 
706
        g_return_val_if_fail (dev != NULL, FALSE);
 
707
 
 
708
        return (dev->active);
 
709
}
 
710
 
 
711
void network_device_set_active (NetworkDevice *dev, gboolean active)
 
712
{
 
713
        g_return_if_fail (dev != NULL);
 
714
 
 
715
        dev->active = active;
 
716
}
 
717
 
 
718
/*
 
719
 * Accessors for desc
 
720
 */
 
721
const char *network_device_get_desc (NetworkDevice *dev)
 
722
{
 
723
        g_return_val_if_fail (dev != NULL, NULL);
 
724
 
 
725
        return (dev->desc);
 
726
}
 
727
 
 
728
void network_device_set_desc (NetworkDevice *dev, const char *desc)
 
729
{
 
730
        g_return_if_fail (dev != NULL);
 
731
 
 
732
        if (dev->desc)
 
733
        {
 
734
                g_free (dev->desc);
 
735
                dev->desc = NULL;
 
736
        }
 
737
        if (desc)
 
738
                dev->desc = g_strdup (desc);
 
739
}
 
740
 
 
741
/*
 
742
 * Accessors for activation stage
 
743
 */
 
744
NMActStage network_device_get_act_stage (NetworkDevice *dev)
 
745
{
 
746
        g_return_val_if_fail (dev != NULL, FALSE);
 
747
 
 
748
        return (dev->act_stage);
 
749
}
 
750
 
 
751
void network_device_set_act_stage (NetworkDevice *dev, NMActStage act_stage)
 
752
{
 
753
        g_return_if_fail (dev != NULL);
 
754
 
 
755
        dev->act_stage = act_stage;
 
756
}
 
757