← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/notifier.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/notifier.c
70
70
        notifier_list = g_slist_remove(notifier_list, notifier);
71
71
}
72
72
 
73
 
static const char *type2string(enum connman_service_type type)
74
 
{
75
 
        switch (type) {
76
 
        case CONNMAN_SERVICE_TYPE_UNKNOWN:
77
 
                break;
78
 
        case CONNMAN_SERVICE_TYPE_ETHERNET:
79
 
                return "ethernet";
80
 
        case CONNMAN_SERVICE_TYPE_WIFI:
81
 
                return "wifi";
82
 
        case CONNMAN_SERVICE_TYPE_WIMAX:
83
 
                return "wimax";
84
 
        case CONNMAN_SERVICE_TYPE_BLUETOOTH:
85
 
                return "bluetooth";
86
 
        case CONNMAN_SERVICE_TYPE_CELLULAR:
87
 
                return "cellular";
88
 
        }
89
 
 
90
 
        return NULL;
91
 
}
92
 
 
93
73
#define MAX_TECHNOLOGIES 10
94
74
 
95
75
static volatile gint registered[MAX_TECHNOLOGIES];
96
76
static volatile gint enabled[MAX_TECHNOLOGIES];
97
77
static volatile gint connected[MAX_TECHNOLOGIES];
98
78
 
99
 
void __connman_notifier_list_registered(DBusMessageIter *iter)
 
79
void __connman_notifier_list_registered(DBusMessageIter *iter, void *user_data)
100
80
{
101
81
        int i;
102
82
 
103
83
        for (i = 0; i < 10; i++) {
104
 
                const char *type = type2string(i);
 
84
                const char *type = __connman_service_type2string(i);
105
85
 
106
86
                if (type == NULL)
107
87
                        continue;
112
92
        }
113
93
}
114
94
 
115
 
void __connman_notifier_list_enabled(DBusMessageIter *iter)
 
95
void __connman_notifier_list_enabled(DBusMessageIter *iter, void *user_data)
116
96
{
117
97
        int i;
118
98
 
119
99
        for (i = 0; i < 10; i++) {
120
 
                const char *type = type2string(i);
 
100
                const char *type = __connman_service_type2string(i);
121
101
 
122
102
                if (type == NULL)
123
103
                        continue;
128
108
        }
129
109
}
130
110
 
131
 
void __connman_notifier_list_connected(DBusMessageIter *iter)
 
111
void __connman_notifier_list_connected(DBusMessageIter *iter, void *user_data)
132
112
{
133
113
        int i;
134
114
 
135
115
        for (i = 0; i < 10; i++) {
136
 
                const char *type = type2string(i);
 
116
                const char *type = __connman_service_type2string(i);
137
117
 
138
118
                if (type == NULL)
139
119
                        continue;
147
127
static void technology_registered(enum connman_service_type type,
148
128
                                                connman_bool_t registered)
149
129
{
150
 
        DBusMessage *signal;
151
 
        DBusMessageIter entry, value, iter;
152
 
        const char *key = "AvailableTechnologies";
153
 
 
154
130
        DBG("type %d registered %d", type, registered);
155
131
 
156
 
        signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
157
 
                                CONNMAN_MANAGER_INTERFACE, "PropertyChanged");
158
 
        if (signal == NULL)
159
 
                return;
160
 
 
161
 
        dbus_message_iter_init_append(signal, &entry);
162
 
 
163
 
        dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
164
 
 
165
 
        dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
166
 
                        DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING,
167
 
                                                                &value);
168
 
 
169
 
        dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
170
 
                                        DBUS_TYPE_STRING_AS_STRING, &iter);
171
 
        __connman_notifier_list_registered(&iter);
172
 
        dbus_message_iter_close_container(&value, &iter);
173
 
 
174
 
        dbus_message_iter_close_container(&entry, &value);
175
 
 
176
 
        g_dbus_send_message(connection, signal);
 
132
        connman_dbus_property_changed_array(CONNMAN_MANAGER_PATH,
 
133
                CONNMAN_MANAGER_INTERFACE, "AvailableTechnologies",
 
134
                DBUS_TYPE_STRING, __connman_notifier_list_registered, NULL);
177
135
}
178
136
 
179
137
static void technology_enabled(enum connman_service_type type,
180
138
                                                connman_bool_t enabled)
181
139
{
182
140
        GSList *list;
183
 
        DBusMessage *signal;
184
 
        DBusMessageIter entry, value, iter;
185
 
        const char *key = "EnabledTechnologies";
186
141
 
187
142
        DBG("type %d enabled %d", type, enabled);
188
143
 
189
 
        signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
190
 
                                CONNMAN_MANAGER_INTERFACE, "PropertyChanged");
191
 
        if (signal == NULL)
192
 
                goto done;
193
 
 
194
 
        dbus_message_iter_init_append(signal, &entry);
195
 
 
196
 
        dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
197
 
 
198
 
        dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
199
 
                        DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING,
200
 
                                                                &value);
201
 
 
202
 
        dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
203
 
                                        DBUS_TYPE_STRING_AS_STRING, &iter);
204
 
        __connman_notifier_list_enabled(&iter);
205
 
        dbus_message_iter_close_container(&value, &iter);
206
 
 
207
 
        dbus_message_iter_close_container(&entry, &value);
208
 
 
209
 
        g_dbus_send_message(connection, signal);
210
 
 
211
 
done:
 
144
        connman_dbus_property_changed_array(CONNMAN_MANAGER_PATH,
 
145
                CONNMAN_MANAGER_INTERFACE, "EnabledTechnologies",
 
146
                DBUS_TYPE_STRING, __connman_notifier_list_enabled, NULL);
 
147
 
212
148
        for (list = notifier_list; list; list = list->next) {
213
149
                struct connman_notifier *notifier = list->data;
214
150
 
220
156
static void technology_connected(enum connman_service_type type,
221
157
                                                connman_bool_t connected)
222
158
{
223
 
        DBusMessage *signal;
224
 
        DBusMessageIter entry, value, iter;
225
 
        const char *key = "ConnectedTechnologies";
226
 
 
227
159
        DBG("type %d connected %d", type, connected);
228
160
 
229
 
        signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
230
 
                                CONNMAN_MANAGER_INTERFACE, "PropertyChanged");
231
 
        if (signal == NULL)
232
 
                return;
233
 
 
234
 
        dbus_message_iter_init_append(signal, &entry);
235
 
 
236
 
        dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
237
 
 
238
 
        dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
239
 
                        DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING,
240
 
                                                                &value);
241
 
 
242
 
        dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
243
 
                                        DBUS_TYPE_STRING_AS_STRING, &iter);
244
 
        __connman_notifier_list_connected(&iter);
245
 
        dbus_message_iter_close_container(&value, &iter);
246
 
 
247
 
        dbus_message_iter_close_container(&entry, &value);
248
 
 
249
 
        g_dbus_send_message(connection, signal);
 
161
        connman_dbus_property_changed_array(CONNMAN_MANAGER_PATH,
 
162
                CONNMAN_MANAGER_INTERFACE, "ConnectedTechnologies",
 
163
                DBUS_TYPE_STRING, __connman_notifier_list_connected, NULL);
250
164
}
251
165
 
252
166
void __connman_notifier_register(enum connman_service_type type)
255
169
 
256
170
        switch (type) {
257
171
        case CONNMAN_SERVICE_TYPE_UNKNOWN:
 
172
        case CONNMAN_SERVICE_TYPE_SYSTEM:
 
173
        case CONNMAN_SERVICE_TYPE_VPN:
258
174
                return;
259
175
        case CONNMAN_SERVICE_TYPE_ETHERNET:
260
176
        case CONNMAN_SERVICE_TYPE_WIFI:
274
190
 
275
191
        switch (type) {
276
192
        case CONNMAN_SERVICE_TYPE_UNKNOWN:
 
193
        case CONNMAN_SERVICE_TYPE_SYSTEM:
 
194
        case CONNMAN_SERVICE_TYPE_VPN:
277
195
                return;
278
196
        case CONNMAN_SERVICE_TYPE_ETHERNET:
279
197
        case CONNMAN_SERVICE_TYPE_WIFI:
293
211
 
294
212
        switch (type) {
295
213
        case CONNMAN_SERVICE_TYPE_UNKNOWN:
 
214
        case CONNMAN_SERVICE_TYPE_SYSTEM:
 
215
        case CONNMAN_SERVICE_TYPE_VPN:
296
216
                return;
297
217
        case CONNMAN_SERVICE_TYPE_ETHERNET:
298
218
        case CONNMAN_SERVICE_TYPE_WIFI:
312
232
 
313
233
        switch (type) {
314
234
        case CONNMAN_SERVICE_TYPE_UNKNOWN:
 
235
        case CONNMAN_SERVICE_TYPE_SYSTEM:
 
236
        case CONNMAN_SERVICE_TYPE_VPN:
315
237
                return;
316
238
        case CONNMAN_SERVICE_TYPE_ETHERNET:
317
239
        case CONNMAN_SERVICE_TYPE_WIFI:
331
253
 
332
254
        switch (type) {
333
255
        case CONNMAN_SERVICE_TYPE_UNKNOWN:
 
256
        case CONNMAN_SERVICE_TYPE_SYSTEM:
 
257
        case CONNMAN_SERVICE_TYPE_VPN:
334
258
                return;
335
259
        case CONNMAN_SERVICE_TYPE_ETHERNET:
336
260
        case CONNMAN_SERVICE_TYPE_WIFI:
350
274
 
351
275
        switch (type) {
352
276
        case CONNMAN_SERVICE_TYPE_UNKNOWN:
 
277
        case CONNMAN_SERVICE_TYPE_SYSTEM:
 
278
        case CONNMAN_SERVICE_TYPE_VPN:
353
279
                return;
354
280
        case CONNMAN_SERVICE_TYPE_ETHERNET:
355
281
        case CONNMAN_SERVICE_TYPE_WIFI:
363
289
                technology_connected(type, FALSE);
364
290
}
365
291
 
 
292
static void technology_default(enum connman_service_type type)
 
293
{
 
294
        const char *str;
 
295
 
 
296
        str = __connman_service_type2string(type);
 
297
        if (str == NULL)
 
298
                str = "";
 
299
 
 
300
        connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
 
301
                        CONNMAN_MANAGER_INTERFACE, "DefaultTechnology",
 
302
                                                DBUS_TYPE_STRING, &str);
 
303
}
 
304
 
 
305
void __connman_notifier_default_changed(struct connman_service *service)
 
306
{
 
307
        enum connman_service_type type = connman_service_get_type(service);
 
308
        GSList *list;
 
309
 
 
310
        technology_default(type);
 
311
 
 
312
        for (list = notifier_list; list; list = list->next) {
 
313
                struct connman_notifier *notifier = list->data;
 
314
 
 
315
                if (notifier->default_changed)
 
316
                        notifier->default_changed(service);
 
317
        }
 
318
}
 
319
 
366
320
static void offlinemode_changed(dbus_bool_t enabled)
367
321
{
368
 
        DBusMessage *signal;
369
 
        DBusMessageIter entry, value;
370
 
        const char *key = "OfflineMode";
371
 
 
372
322
        DBG("enabled %d", enabled);
373
323
 
374
 
        signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
375
 
                                CONNMAN_MANAGER_INTERFACE, "PropertyChanged");
376
 
        if (signal == NULL)
377
 
                return;
378
 
 
379
 
        dbus_message_iter_init_append(signal, &entry);
380
 
 
381
 
        dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
382
 
 
383
 
        dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
384
 
                                        DBUS_TYPE_BOOLEAN_AS_STRING, &value);
385
 
        dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &enabled);
386
 
        dbus_message_iter_close_container(&entry, &value);
387
 
 
388
 
        g_dbus_send_message(connection, signal);
 
324
        connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
 
325
                                CONNMAN_MANAGER_INTERFACE, "OfflineMode",
 
326
                                                DBUS_TYPE_BOOLEAN, &enabled);
389
327
}
390
328
 
391
329
void __connman_notifier_offlinemode(connman_bool_t enabled)
412
350
 
413
351
        switch (type) {
414
352
        case CONNMAN_SERVICE_TYPE_UNKNOWN:
 
353
        case CONNMAN_SERVICE_TYPE_SYSTEM:
 
354
        case CONNMAN_SERVICE_TYPE_VPN:
415
355
                return FALSE;
416
356
        case CONNMAN_SERVICE_TYPE_ETHERNET:
417
357
        case CONNMAN_SERVICE_TYPE_WIFI: