← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/bluez/oneiric-201105191013

« back to all changes in this revision

Viewing changes to src/manager.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Ancell
  • Date: 2011-01-07 13:21:49 UTC
  • mfrom: (1.1.25 upstream)
  • Revision ID: james.westby@ubuntu.com-20110107132149-h5s1m62mgctaqdyu
Tags: 4.84-0ubuntu1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/manager.c
105
105
        } else if (!strncmp(pattern, "hci", 3) && strlen(pattern) >= 4) {
106
106
                dev_id = atoi(pattern + 3);
107
107
                adapter = manager_find_adapter_by_id(dev_id);
108
 
        } else
109
 
                adapter = manager_find_adapter_by_address(pattern);
 
108
        } else {
 
109
                bdaddr_t bdaddr;
 
110
                str2ba(pattern, &bdaddr);
 
111
                adapter = manager_find_adapter(&bdaddr);
 
112
        }
110
113
 
111
114
        if (!adapter)
112
115
                return btd_error_no_such_adapter(msg);
179
182
        for (i = 0, list = adapters; list; list = list->next) {
180
183
                struct btd_adapter *adapter = list->data;
181
184
 
182
 
                if (!adapter_is_ready(adapter))
183
 
                        continue;
184
 
 
185
185
                array[i] = (char *) adapter_get_path(adapter);
186
186
                i++;
187
187
        }
231
231
        for (i = 0, list = adapters; list; list = list->next) {
232
232
                struct btd_adapter *adapter = list->data;
233
233
 
234
 
                if (!adapter_is_ready(adapter))
235
 
                        continue;
236
 
 
237
234
                array[i] = (char *) adapter_get_path(adapter);
238
235
                i++;
239
236
        }
245
242
        g_free(array);
246
243
}
247
244
 
 
245
static void manager_set_default_adapter(int id)
 
246
{
 
247
        struct btd_adapter *adapter;
 
248
        const gchar *path;
 
249
 
 
250
        default_adapter_id = id;
 
251
 
 
252
        adapter = manager_find_adapter_by_id(id);
 
253
        if (!adapter)
 
254
                return;
 
255
 
 
256
        path = adapter_get_path(adapter);
 
257
 
 
258
        g_dbus_emit_signal(connection, "/",
 
259
                        MANAGER_INTERFACE,
 
260
                        "DefaultAdapterChanged",
 
261
                        DBUS_TYPE_OBJECT_PATH, &path,
 
262
                        DBUS_TYPE_INVALID);
 
263
}
 
264
 
248
265
static void manager_remove_adapter(struct btd_adapter *adapter)
249
266
{
250
267
        uint16_t dev_id = adapter_get_dev_id(adapter);
288
305
        return dev_id == id ? 0 : -1;
289
306
}
290
307
 
291
 
static gint adapter_path_cmp(gconstpointer a, gconstpointer b)
292
 
{
293
 
        struct btd_adapter *adapter = (struct btd_adapter *) a;
294
 
        const char *path = b;
295
 
        const gchar *adapter_path = adapter_get_path(adapter);
296
 
 
297
 
        return strcmp(adapter_path, path);
298
 
}
299
 
 
300
308
static gint adapter_cmp(gconstpointer a, gconstpointer b)
301
309
{
302
310
        struct btd_adapter *adapter = (struct btd_adapter *) a;
308
316
        return bacmp(&src, bdaddr);
309
317
}
310
318
 
311
 
static gint adapter_address_cmp(gconstpointer a, gconstpointer b)
312
 
{
313
 
        struct btd_adapter *adapter = (struct btd_adapter *) a;
314
 
        const char *address = b;
315
 
        bdaddr_t bdaddr;
316
 
        char addr[18];
317
 
 
318
 
        adapter_get_address(adapter, &bdaddr);
319
 
        ba2str(&bdaddr, addr);
320
 
 
321
 
        return strcasecmp(addr, address);
322
 
}
323
 
 
324
319
struct btd_adapter *manager_find_adapter(const bdaddr_t *sba)
325
320
{
326
321
        GSList *match;
332
327
        return match->data;
333
328
}
334
329
 
335
 
struct btd_adapter *manager_find_adapter_by_address(const char *address)
336
 
{
337
 
        GSList *match;
338
 
 
339
 
        match = g_slist_find_custom(adapters, address, adapter_address_cmp);
340
 
        if (!match)
341
 
                return NULL;
342
 
 
343
 
        return match->data;
344
 
}
345
 
 
346
 
struct btd_adapter *manager_find_adapter_by_path(const char *path)
347
 
{
348
 
        GSList *match;
349
 
 
350
 
        match = g_slist_find_custom(adapters, path, adapter_path_cmp);
351
 
        if (!match)
352
 
                return NULL;
353
 
 
354
 
        return match->data;
355
 
}
356
 
 
357
330
struct btd_adapter *manager_find_adapter_by_id(int id)
358
331
{
359
332
        GSList *match;
366
339
        return match->data;
367
340
}
368
341
 
 
342
void manager_foreach_adapter(adapter_cb func, gpointer user_data)
 
343
{
 
344
        g_slist_foreach(adapters, (GFunc) func, user_data);
 
345
}
 
346
 
369
347
GSList *manager_get_adapters(void)
370
348
{
371
349
        return adapters;
383
361
        btd_stop_exit_timer();
384
362
}
385
363
 
386
 
int manager_register_adapter(int id, gboolean devup)
 
364
struct btd_adapter *btd_manager_register_adapter(int id)
387
365
{
388
366
        struct btd_adapter *adapter;
 
367
        const char *path;
389
368
 
390
369
        adapter = manager_find_adapter_by_id(id);
391
370
        if (adapter) {
392
371
                error("Unable to register adapter: hci%d already exist", id);
393
 
                return -1;
 
372
                return NULL;
394
373
        }
395
374
 
396
 
        adapter = adapter_create(connection, id, devup);
 
375
        adapter = adapter_create(connection, id);
397
376
        if (!adapter)
398
 
                return -1;
 
377
                return NULL;
399
378
 
400
379
        adapters = g_slist_append(adapters, adapter);
401
380
 
402
 
        return 0;
 
381
        if (!adapter_init(adapter)) {
 
382
                btd_adapter_unref(adapter);
 
383
                return NULL;
 
384
        }
 
385
 
 
386
        path = adapter_get_path(adapter);
 
387
        g_dbus_emit_signal(connection, "/",
 
388
                                MANAGER_INTERFACE, "AdapterAdded",
 
389
                                DBUS_TYPE_OBJECT_PATH, &path,
 
390
                                DBUS_TYPE_INVALID);
 
391
 
 
392
        manager_update_adapters();
 
393
 
 
394
        btd_stop_exit_timer();
 
395
 
 
396
        if (default_adapter_id < 0)
 
397
                manager_set_default_adapter(id);
 
398
 
 
399
        DBG("Adapter %s registered", path);
 
400
 
 
401
        return btd_adapter_ref(adapter);
403
402
}
404
403
 
405
 
int manager_unregister_adapter(int id)
 
404
int btd_manager_unregister_adapter(int id)
406
405
{
407
406
        struct btd_adapter *adapter;
408
407
        const gchar *path;
420
419
        return 0;
421
420
}
422
421
 
423
 
int manager_start_adapter(int id)
424
 
{
425
 
        struct btd_adapter *adapter;
426
 
        int ret;
427
 
 
428
 
        adapter = manager_find_adapter_by_id(id);
429
 
        if (!adapter) {
430
 
                error("Getting device data failed: hci%d", id);
431
 
                return -EINVAL;
432
 
        }
433
 
 
434
 
        ret = adapter_start(adapter);
435
 
        if (ret < 0)
436
 
                return ret;
437
 
 
438
 
        if (default_adapter_id < 0)
439
 
                manager_set_default_adapter(id);
440
 
 
441
 
        return ret;
442
 
}
443
 
 
444
 
int manager_stop_adapter(int id)
445
 
{
446
 
        struct btd_adapter *adapter;
447
 
 
448
 
        adapter = manager_find_adapter_by_id(id);
449
 
        if (!adapter) {
450
 
                error("Getting device data failed: hci%d", id);
451
 
                return -EINVAL;
452
 
        }
453
 
 
454
 
        return adapter_stop(adapter);
455
 
}
456
 
 
457
 
int manager_get_default_adapter()
458
 
{
459
 
        return default_adapter_id;
460
 
}
461
 
 
462
 
void manager_set_default_adapter(int id)
463
 
{
464
 
        struct btd_adapter *adapter;
465
 
        const gchar *path;
466
 
 
467
 
        default_adapter_id = id;
468
 
 
469
 
        adapter = manager_find_adapter_by_id(id);
470
 
        if (!adapter)
471
 
                return;
472
 
 
473
 
        path = adapter_get_path(adapter);
474
 
 
475
 
        g_dbus_emit_signal(connection, "/",
476
 
                        MANAGER_INTERFACE,
477
 
                        "DefaultAdapterChanged",
478
 
                        DBUS_TYPE_OBJECT_PATH, &path,
479
 
                        DBUS_TYPE_INVALID);
480
 
}
481
 
 
482
 
void btd_manager_set_offline(gboolean offline)
483
 
{
484
 
        GSList *l;
485
 
 
486
 
        for (l = adapters; l != NULL; l = g_slist_next(l)) {
487
 
                struct btd_adapter *adapter = l->data;
488
 
 
489
 
                if (offline)
490
 
                        btd_adapter_switch_offline(adapter);
491
 
                else
492
 
                        btd_adapter_restore_powered(adapter);
493
 
        }
494
 
}
495
 
 
496
422
void btd_manager_set_did(uint16_t vendor, uint16_t product, uint16_t version)
497
423
{
498
424
        GSList *l;