← Back to branch summary

~shakaran/ubuntu/quantal/connman/bug-pattern-update

« back to all changes in this revision

Viewing changes to src/element.c

  • Committer: Bazaar Package Importer
  • Author(s): Mathieu Trudel
  • Date: 2010-02-12 10:08:03 UTC
  • mfrom: (1.1.8 upstream) (0.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20100212100803-s8iaj8g1dmgwm2uz
Tags: 0.48+dfsg-2
http://bugs.debian.org/546616
* Ubuntu/Debian sync upload
* Re-add missing changes from 0.45+dfsg that made it only in Ubuntu:
  - ship development parts in a connman-dev package (Closes: 546616)
    - add debian/connman-dev.install
    - update debian/control
* Update long descriptions for connman and connman-dev
  - update debian/control
* Add missing Depends on libglib2.0-dev, libdbus-1-dev for connman-dev
  - update debian/control
* Don't run bootstrap twice during build.
  - update debian/rules
* Remove old configure option: enable-ppp, with-pppd, enable-novatel,
  enable-huawei and enable-modemmgr are no longer recognized.
  - update debian/rules

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/element.c
56
56
                return "network";
57
57
        case CONNMAN_ELEMENT_TYPE_SERVICE:
58
58
                return "service";
59
 
        case CONNMAN_ELEMENT_TYPE_PPP:
60
 
                return "ppp";
61
59
        case CONNMAN_ELEMENT_TYPE_IPV4:
62
60
                return "ipv4";
63
61
        case CONNMAN_ELEMENT_TYPE_IPV6:
77
75
        return NULL;
78
76
}
79
77
 
80
 
static void emit_element_signal(DBusConnection *conn, const char *member,
81
 
                                        struct connman_element *element)
82
 
{
83
 
        DBusMessage *signal;
84
 
 
85
 
        if (__connman_debug_enabled() == FALSE)
86
 
                return;
87
 
 
88
 
        DBG("conn %p member %s", conn, member);
89
 
 
90
 
        if (element == NULL)
91
 
                return;
92
 
 
93
 
        signal = dbus_message_new_signal(element->path,
94
 
                                        CONNMAN_DEBUG_INTERFACE, member);
95
 
        if (signal == NULL)
96
 
                return;
97
 
 
98
 
        g_dbus_send_message(conn, signal);
99
 
}
100
 
 
101
78
struct foreach_data {
102
79
        enum connman_element_type type;
103
80
        element_cb_t callback;
274
251
        case CONNMAN_DEVICE_TYPE_UNKNOWN:
275
252
        case CONNMAN_DEVICE_TYPE_VENDOR:
276
253
        case CONNMAN_DEVICE_TYPE_GPS:
277
 
        case CONNMAN_DEVICE_TYPE_NOZOMI:
278
 
        case CONNMAN_DEVICE_TYPE_HUAWEI:
279
 
        case CONNMAN_DEVICE_TYPE_NOVATEL:
280
254
                break;
281
255
        case CONNMAN_DEVICE_TYPE_ETHERNET:
282
 
                service = __connman_service_lookup_from_device(device);
283
 
                break;
284
256
        case CONNMAN_DEVICE_TYPE_WIFI:
285
257
        case CONNMAN_DEVICE_TYPE_WIMAX:
286
258
        case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 
259
        case CONNMAN_DEVICE_TYPE_CELLULAR:
287
260
        case CONNMAN_DEVICE_TYPE_MBM:
288
261
        case CONNMAN_DEVICE_TYPE_HSO:
289
262
                network = __connman_element_get_network(element);
381
354
 
382
355
        switch (type) {
383
356
        case CONNMAN_SERVICE_TYPE_UNKNOWN:
 
357
        case CONNMAN_SERVICE_TYPE_SYSTEM:
384
358
        case CONNMAN_SERVICE_TYPE_ETHERNET:
385
359
        case CONNMAN_SERVICE_TYPE_BLUETOOTH:
386
360
        case CONNMAN_SERVICE_TYPE_CELLULAR:
 
361
        case CONNMAN_SERVICE_TYPE_VPN:
387
362
                return FALSE;
388
363
        case CONNMAN_SERVICE_TYPE_WIFI:
389
364
        case CONNMAN_SERVICE_TYPE_WIMAX:
424
399
 
425
400
        switch (type) {
426
401
        case CONNMAN_SERVICE_TYPE_UNKNOWN:
 
402
        case CONNMAN_SERVICE_TYPE_SYSTEM:
 
403
        case CONNMAN_SERVICE_TYPE_VPN:
427
404
                return FALSE;
428
405
        case CONNMAN_SERVICE_TYPE_ETHERNET:
429
406
        case CONNMAN_SERVICE_TYPE_WIFI:
467
444
 
468
445
        switch (type) {
469
446
        case CONNMAN_SERVICE_TYPE_UNKNOWN:
 
447
        case CONNMAN_SERVICE_TYPE_SYSTEM:
 
448
        case CONNMAN_SERVICE_TYPE_VPN:
470
449
                return FALSE;
471
450
        case CONNMAN_SERVICE_TYPE_ETHERNET:
472
451
        case CONNMAN_SERVICE_TYPE_WIFI:
703
682
                g_free(element->ipv4.network);
704
683
                g_free(element->ipv4.broadcast);
705
684
                g_free(element->ipv4.nameserver);
 
685
                g_free(element->ipv4.timeserver);
706
686
                g_free(element->devname);
707
687
                g_free(element->path);
708
688
                g_free(element->name);
888
868
                *((char **) value) = element->ipv4.nameserver;
889
869
                __connman_element_unlock(element);
890
870
                break;
 
871
        case CONNMAN_PROPERTY_ID_IPV4_TIMESERVER:
 
872
                if (element->ipv4.timeserver == NULL)
 
873
                        return connman_element_get_value(element->parent,
 
874
                                                                id, value);
 
875
                __connman_element_lock(element);
 
876
                *((char **) value) = element->ipv4.timeserver;
 
877
                __connman_element_unlock(element);
 
878
                break;
891
879
        default:
892
880
                return -EINVAL;
893
881
        }
1111
1099
        const char *method = NULL;
1112
1100
        const char *address = NULL, *netmask = NULL, *gateway = NULL;
1113
1101
        const char *broadcast = NULL, *nameserver = NULL;
 
1102
        const char *timeserver = NULL;
1114
1103
 
1115
1104
        connman_element_get_value(element,
1116
1105
                                CONNMAN_PROPERTY_ID_IPV4_METHOD, &method);
1125
1114
                        CONNMAN_PROPERTY_ID_IPV4_BROADCAST, &broadcast);
1126
1115
        connman_element_get_value(element,
1127
1116
                        CONNMAN_PROPERTY_ID_IPV4_NAMESERVER, &nameserver);
 
1117
        connman_element_get_value(element,
 
1118
                        CONNMAN_PROPERTY_ID_IPV4_TIMESERVER, &timeserver);
1128
1119
 
1129
1120
        if (method != NULL)
1130
 
                connman_dbus_dict_append_variant(dict, "IPv4.Method",
 
1121
                connman_dbus_dict_append_basic(dict, "IPv4.Method",
1131
1122
                                                DBUS_TYPE_STRING, &method);
1132
1123
 
1133
1124
        if (address != NULL)
1134
 
                connman_dbus_dict_append_variant(dict, "IPv4.Address",
 
1125
                connman_dbus_dict_append_basic(dict, "IPv4.Address",
1135
1126
                                                DBUS_TYPE_STRING, &address);
1136
1127
 
1137
1128
        if (netmask != NULL)
1138
 
                connman_dbus_dict_append_variant(dict, "IPv4.Netmask",
 
1129
                connman_dbus_dict_append_basic(dict, "IPv4.Netmask",
1139
1130
                                                DBUS_TYPE_STRING, &netmask);
1140
1131
 
1141
1132
        if (gateway != NULL)
1142
 
                connman_dbus_dict_append_variant(dict, "IPv4.Gateway",
 
1133
                connman_dbus_dict_append_basic(dict, "IPv4.Gateway",
1143
1134
                                                DBUS_TYPE_STRING, &gateway);
1144
1135
 
1145
1136
        if (broadcast != NULL)
1146
 
                connman_dbus_dict_append_variant(dict, "IPv4.Broadcast",
 
1137
                connman_dbus_dict_append_basic(dict, "IPv4.Broadcast",
1147
1138
                                                DBUS_TYPE_STRING, &broadcast);
1148
1139
 
1149
1140
        if (nameserver != NULL)
1150
 
                connman_dbus_dict_append_variant(dict, "IPv4.Nameserver",
 
1141
                connman_dbus_dict_append_basic(dict, "IPv4.Nameserver",
1151
1142
                                                DBUS_TYPE_STRING, &nameserver);
1152
1143
 
 
1144
        if (timeserver != NULL)
 
1145
                connman_dbus_dict_append_basic(dict, "IPv4.Timeserver",
 
1146
                                                DBUS_TYPE_STRING, &timeserver);
 
1147
 
1153
1148
        return 0;
1154
1149
}
1155
1150
 
1238
1233
                element->ipv4.nameserver = g_strdup(nameserver);
1239
1234
 
1240
1235
                connman_element_update(element);
 
1236
        } else if (g_str_equal(name, "IPv4.Timeserver") == TRUE) {
 
1237
                const char *timeserver;
 
1238
 
 
1239
                if (type != DBUS_TYPE_STRING)
 
1240
                        return -EINVAL;
 
1241
 
 
1242
                dbus_message_iter_get_basic(value, &timeserver);
 
1243
 
 
1244
                g_free(element->ipv4.timeserver);
 
1245
                element->ipv4.nameserver = g_strdup(timeserver);
 
1246
 
 
1247
                connman_element_update(element);
1241
1248
        }
1242
1249
 
1243
1250
        return 0;
1244
1251
}
1245
1252
 
1246
 
static void append_state(DBusMessageIter *entry, const char *state)
1247
 
{
1248
 
        DBusMessageIter value;
1249
 
        const char *key = "State";
1250
 
 
1251
 
        dbus_message_iter_append_basic(entry, DBUS_TYPE_STRING, &key);
1252
 
 
1253
 
        dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
1254
 
                                        DBUS_TYPE_STRING_AS_STRING, &value);
1255
 
        dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &state);
1256
 
        dbus_message_iter_close_container(entry, &value);
1257
 
}
1258
 
 
1259
1253
static void emit_state_change(DBusConnection *conn, const char *state)
1260
1254
{
1261
1255
        DBusMessage *signal;
1262
 
        DBusMessageIter entry;
1263
 
 
1264
 
        DBG("conn %p", conn);
1265
 
 
1266
 
        signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
1267
 
                                CONNMAN_MANAGER_INTERFACE, "PropertyChanged");
1268
 
        if (signal == NULL)
1269
 
                return;
1270
 
 
1271
 
        dbus_message_iter_init_append(signal, &entry);
1272
 
 
1273
 
        append_state(&entry, state);
1274
 
 
1275
 
        g_dbus_send_message(conn, signal);
 
1256
        DBusMessageIter iter;
 
1257
 
 
1258
        connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
 
1259
                                CONNMAN_MANAGER_INTERFACE, "State",
 
1260
                                                DBUS_TYPE_STRING, &state);
1276
1261
 
1277
1262
        signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
1278
1263
                                CONNMAN_MANAGER_INTERFACE, "StateChanged");
1279
1264
        if (signal == NULL)
1280
1265
                return;
1281
1266
 
1282
 
        dbus_message_iter_init_append(signal, &entry);
1283
 
        dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &state);
 
1267
        dbus_message_iter_init_append(signal, &iter);
 
1268
        dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &state);
1284
1269
 
1285
1270
        g_dbus_send_message(conn, signal);
1286
1271
}
1364
1349
                        emit_state_change(connection, "online");
1365
1350
        }
1366
1351
 
1367
 
        emit_element_signal(connection, "ElementAdded", element);
1368
 
 
1369
1352
        if (started == FALSE)
1370
1353
                return;
1371
1354
 
1475
1458
                        emit_state_change(connection, "offline");
1476
1459
        }
1477
1460
 
1478
 
        emit_element_signal(connection, "ElementRemoved", element);
1479
 
 
1480
1461
        connman_element_unref(element);
1481
1462
 
1482
1463
        return FALSE;
1517
1498
        if (element->driver && element->driver->update)
1518
1499
                element->driver->update(element);
1519
1500
 
1520
 
        emit_element_signal(connection, "ElementUpdated", element);
1521
 
 
1522
1501
        return FALSE;
1523
1502
}
1524
1503
 
1612
1591
 
1613
1592
        __connman_notifier_init();
1614
1593
        __connman_service_init();
 
1594
        __connman_provider_init();
1615
1595
        __connman_network_init();
1616
1596
        __connman_device_init();
1617
1597
 
1651
1631
 
1652
1632
        __connman_connection_init();
1653
1633
        __connman_ipv4_init();
 
1634
        __connman_dhcp_init();
1654
1635
 
1655
1636
        if (__connman_rfkill_init() < 0)
1656
1637
                __connman_udev_enable_rfkill_processing();
1662
1643
 
1663
1644
        __connman_rfkill_cleanup();
1664
1645
 
 
1646
        __connman_dhcp_cleanup();
1665
1647
        __connman_ipv4_cleanup();
 
1648
        __connman_provider_cleanup();
1666
1649
        __connman_connection_cleanup();
1667
1650
}
1668
1651