← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/bluez/oneiric-proposed

« back to all changes in this revision

Viewing changes to src/adapter.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2011-06-06 18:11:44 UTC
  • mfrom: (1.1.33 upstream) (6.3.13 sid)
  • Revision ID: james.westby@ubuntu.com-20110606181144-28qwmmobedosb2ct
Tags: 4.94-0ubuntu1
* Resynchronize on Debian, remaining diff:
* debian/bluez.bluetooth.default:
  - Drop.  Doesn't do anything now.
* debian/control:
  - use arch: any rather than a list of architectures
* debian/bluez.bluetooth.init:
  - Drop most calls in this script as now all it serves as is to 
    workaround a problem with dbus not being ready early enough. Once dbus is 
    started by an upstart service, this should be able to be converted 
    to an upstart service too.
* debian/rules:
  - Don't build hid2hci anymore.  It's part of udev now.
  - Don't install bluez_agent.udev, doesn't work in Ubuntu.
  - Don't use simple-patchsys
* debian/source_bluez.py, debian/bluez.install:
  - apport hook made by Baptiste Mille-Mathias.      
* debian/source/format: 
  - use source format 3.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/adapter.c
58
58
#include "storage.h"
59
59
#include "attrib-server.h"
60
60
#include "att.h"
61
 
 
62
 
/* Interleaved discovery window: 5.12 sec */
63
 
#define GAP_INTER_DISCOV_WIN            5120
 
61
#include "eir.h"
64
62
 
65
63
/* Flags Descriptions */
66
64
#define EIR_LIM_DISC                0x01 /* LE Limited Discoverable Mode */
71
69
#define EIR_SIM_HOST                0x10 /* Simultaneous LE and BR/EDR to Same
72
70
                                            Device Capable (Host) */
73
71
 
74
 
#define ADV_TYPE_IND            0x00
75
 
#define ADV_TYPE_DIRECT_IND     0x01
76
 
 
77
72
#define IO_CAPABILITY_DISPLAYONLY       0x00
78
73
#define IO_CAPABILITY_DISPLAYYESNO      0x01
79
74
#define IO_CAPABILITY_KEYBOARDONLY      0x02
139
134
        sdp_list_t *services;           /* Services associated to adapter */
140
135
 
141
136
        uint8_t  features[8];
142
 
        uint8_t  extfeatures[8];
143
137
 
144
138
        gboolean pairable;              /* pairable state */
145
139
        gboolean initialized;
266
260
        if (!dev) /* no pending request */
267
261
                return -ENODATA;
268
262
 
269
 
        adapter->state &= ~STATE_RESOLVNAME;
270
263
        err = adapter_ops->cancel_resolve_name(adapter->dev_id, &dev->bdaddr);
271
264
        if (err < 0)
272
265
                error("Remote name cancel failed: %s(%d)",
273
266
                                                strerror(errno), errno);
 
267
 
 
268
        adapter_set_state(adapter, STATE_IDLE);
 
269
 
274
270
        return err;
275
271
}
276
272
 
280
276
        int err;
281
277
 
282
278
        /* Do not attempt to resolve more names if on suspended state */
283
 
        if (adapter->state & STATE_SUSPENDED)
 
279
        if (adapter->state == STATE_SUSPENDED)
284
280
                return 0;
285
281
 
286
282
        memset(&match, 0, sizeof(struct remote_dev_info));
464
460
 
465
461
static struct session_req *find_session_by_msg(GSList *list, const DBusMessage *msg)
466
462
{
467
 
        GSList *l;
468
 
 
469
 
        for (l = list; l; l = l->next) {
470
 
                struct session_req *req = l->data;
 
463
        for (; list; list = list->next) {
 
464
                struct session_req *req = list->data;
471
465
 
472
466
                if (req->msg == msg)
473
467
                        return req;
481
475
{
482
476
        int err;
483
477
        const char *modestr;
484
 
        gboolean discoverable;
485
478
 
486
479
        if (adapter->pending_mode != NULL)
487
480
                return -EALREADY;
488
481
 
489
 
        discoverable = new_mode == MODE_DISCOVERABLE;
490
 
 
491
482
        if (!adapter->up && new_mode != MODE_OFF) {
492
483
                err = adapter_ops->set_powered(adapter->dev_id, TRUE);
493
484
                if (err < 0)
653
644
 
654
645
static struct session_req *find_session(GSList *list, const char *sender)
655
646
{
656
 
        GSList *l;
657
 
 
658
 
        for (l = list; l; l = l->next) {
659
 
                struct session_req *req = l->data;
 
647
        for (; list; list = list->next) {
 
648
                struct session_req *req = list->data;
660
649
 
661
650
                if (g_str_equal(req->owner, sender))
662
651
                        return req;
701
690
        return le;
702
691
}
703
692
 
704
 
static void stop_discovery(struct btd_adapter *adapter, gboolean suspend)
 
693
static void stop_discovery(struct btd_adapter *adapter)
705
694
{
706
695
        pending_remote_name_cancel(adapter);
707
696
 
708
 
        if (suspend == FALSE)
709
 
                adapter->found_devices = remove_bredr(adapter->found_devices);
 
697
        adapter->found_devices = remove_bredr(adapter->found_devices);
710
698
 
711
699
        if (adapter->oor_devices) {
712
700
                g_slist_free(adapter->oor_devices);
715
703
 
716
704
        /* Reset if suspended, otherwise remove timer (software scheduler)
717
705
           or request inquiry to stop */
718
 
        if (adapter->state & STATE_SUSPENDED) {
719
 
                adapter->state &= ~STATE_SUSPENDED;
 
706
        if (adapter->state == STATE_SUSPENDED) {
 
707
                adapter_set_state(adapter, STATE_IDLE);
720
708
                return;
721
709
        }
722
710
 
726
714
                return;
727
715
        }
728
716
 
729
 
        if (adapter->state & STATE_LE_SCAN)
730
 
                adapter_ops->stop_scanning(adapter->dev_id);
731
 
        else
732
 
                adapter_ops->stop_inquiry(adapter->dev_id);
 
717
        adapter_ops->stop_discovery(adapter->dev_id);
733
718
}
734
719
 
735
720
static void session_remove(struct session_req *req)
766
751
 
767
752
                DBG("Stopping discovery");
768
753
 
769
 
                stop_discovery(adapter, FALSE);
 
754
                stop_discovery(adapter);
770
755
        }
771
756
}
772
757
 
1207
1192
                                                DEVICE_TYPE_BREDR);
1208
1193
}
1209
1194
 
1210
 
static gboolean stop_scanning(gpointer user_data)
1211
 
{
1212
 
        struct btd_adapter *adapter = user_data;
1213
 
 
1214
 
        adapter_ops->stop_scanning(adapter->dev_id);
1215
 
 
1216
 
        return FALSE;
1217
 
}
1218
 
 
1219
1195
static int start_discovery(struct btd_adapter *adapter)
1220
1196
{
1221
 
        int type;
1222
 
 
1223
1197
        /* Do not start if suspended */
1224
 
        if (adapter->state & STATE_SUSPENDED)
 
1198
        if (adapter->state == STATE_SUSPENDED)
1225
1199
                return 0;
1226
1200
 
1227
1201
        /* Postpone discovery if still resolving names */
1228
 
        if (adapter->state & STATE_RESOLVNAME)
 
1202
        if (adapter->state == STATE_RESOLVNAME)
1229
1203
                return -EINPROGRESS;
1230
1204
 
1231
1205
        pending_remote_name_cancel(adapter);
1232
1206
 
1233
 
        type = adapter_get_discover_type(adapter) & ~DISC_RESOLVNAME;
1234
 
 
1235
 
        switch (type) {
1236
 
        case DISC_STDINQ:
1237
 
        case DISC_INTERLEAVE:
1238
 
                return adapter_ops->start_inquiry(adapter->dev_id,
1239
 
                                                        0x08, FALSE);
1240
 
        case DISC_PINQ:
1241
 
                return adapter_ops->start_inquiry(adapter->dev_id,
1242
 
                                                        0x08, TRUE);
1243
 
        case DISC_LE:
1244
 
                return adapter_ops->start_scanning(adapter->dev_id);
1245
 
        default:
1246
 
                return -EINVAL;
1247
 
        }
 
1207
        return adapter_ops->start_discovery(adapter->dev_id);
1248
1208
}
1249
1209
 
1250
1210
static gboolean discovery_cb(gpointer user_data)
1387
1347
                                DBUS_TYPE_UINT32, &adapter->pairable_timeout);
1388
1348
 
1389
1349
 
1390
 
        if (adapter->state & (STATE_PINQ | STATE_STDINQ | STATE_LE_SCAN))
 
1350
        if (adapter->state == STATE_DISCOV)
1391
1351
                value = TRUE;
1392
1352
        else
1393
1353
                value = FALSE;
1634
1594
        return dbus_message_new_method_return(msg);
1635
1595
}
1636
1596
 
1637
 
static device_type_t flags2type(uint8_t flags)
1638
 
{
1639
 
        /* Inferring the remote type based on the EIR Flags field */
1640
 
 
1641
 
        /* For LE only and dual mode the following flags must be zero */
1642
 
        if (flags & (EIR_SIM_CONTROLLER | EIR_SIM_HOST))
1643
 
                return DEVICE_TYPE_UNKNOWN;
1644
 
 
1645
 
        /* Limited or General discoverable mode bit must be enabled */
1646
 
        if (!(flags & (EIR_LIM_DISC | EIR_GEN_DISC)))
1647
 
                return DEVICE_TYPE_UNKNOWN;
1648
 
 
1649
 
        if (flags & EIR_BREDR_UNSUP)
1650
 
                return DEVICE_TYPE_LE;
1651
 
        else
1652
 
                return DEVICE_TYPE_DUALMODE;
1653
 
}
1654
 
 
1655
 
static gboolean event_is_connectable(uint8_t type)
1656
 
{
1657
 
        switch (type) {
1658
 
        case ADV_TYPE_IND:
1659
 
        case ADV_TYPE_DIRECT_IND:
1660
 
                return TRUE;
1661
 
        default:
1662
 
                return FALSE;
1663
 
        }
1664
 
}
1665
 
 
1666
1597
static struct btd_device *create_device_internal(DBusConnection *conn,
1667
1598
                                                struct btd_adapter *adapter,
1668
 
                                                const gchar *address,
1669
 
                                                gboolean force, int *err)
 
1599
                                                const gchar *address, int *err)
1670
1600
{
1671
1601
        struct remote_dev_info *dev, match;
1672
1602
        struct btd_device *device;
1677
1607
        match.name_status = NAME_ANY;
1678
1608
 
1679
1609
        dev = adapter_search_found_devices(adapter, &match);
1680
 
        if (dev && dev->flags)
1681
 
                type = flags2type(dev->flags);
 
1610
        if (dev && dev->le)
 
1611
                type = DEVICE_TYPE_LE;
1682
1612
        else
1683
1613
                type = DEVICE_TYPE_BREDR;
1684
1614
 
1685
 
        if (!force && type == DEVICE_TYPE_LE &&
1686
 
                                        !event_is_connectable(dev->evt_type)) {
1687
 
                if (err)
1688
 
                        *err = -ENOTCONN;
1689
 
 
1690
 
                return NULL;
1691
 
        }
1692
 
 
1693
1615
        device = adapter_create_device(conn, adapter, address, type);
1694
1616
        if (!device && err)
1695
1617
                *err = -ENOMEM;
1721
1643
 
1722
1644
        DBG("%s", address);
1723
1645
 
1724
 
        device = create_device_internal(conn, adapter, address, TRUE, &err);
 
1646
        device = create_device_internal(conn, adapter, address, &err);
1725
1647
        if (!device)
1726
1648
                goto failed;
1727
1649
 
1802
1724
 
1803
1725
        device = adapter_find_device(adapter, address);
1804
1726
        if (!device) {
1805
 
                device = create_device_internal(conn, adapter, address,
1806
 
                                                                FALSE, &err);
 
1727
                device = create_device_internal(conn, adapter, address, &err);
1807
1728
                if (!device)
1808
1729
                        return btd_error_failed(msg, strerror(-err));
1809
1730
        }
2366
2287
        adapter->oor_devices =  g_slist_copy(adapter->found_devices);
2367
2288
}
2368
2289
 
2369
 
static gboolean bredr_capable(struct btd_adapter *adapter)
2370
 
{
2371
 
        return (adapter->features[4] & LMP_NO_BREDR) == 0 ? TRUE : FALSE;
2372
 
}
2373
 
 
2374
 
static gboolean le_capable(struct btd_adapter *adapter)
2375
 
{
2376
 
        return (adapter->features[4] & LMP_LE &&
2377
 
                        adapter->extfeatures[0] & LMP_HOST_LE) ? TRUE : FALSE;
2378
 
}
2379
 
 
2380
 
int adapter_get_discover_type(struct btd_adapter *adapter)
2381
 
{
2382
 
        gboolean le, bredr;
2383
 
        int type;
2384
 
 
2385
 
        le = le_capable(adapter);
2386
 
        bredr = bredr_capable(adapter);
2387
 
 
2388
 
        if (main_opts.le && le)
2389
 
                type = bredr ? DISC_INTERLEAVE : DISC_LE;
2390
 
        else
2391
 
                type = main_opts.discov_interval ? DISC_STDINQ :
2392
 
                                                        DISC_PINQ;
2393
 
 
2394
 
        if (main_opts.name_resolv)
2395
 
                type |= DISC_RESOLVNAME;
2396
 
 
2397
 
        return type;
2398
 
}
2399
 
 
2400
2290
void btd_adapter_get_mode(struct btd_adapter *adapter, uint8_t *mode,
2401
2291
                                        uint8_t *on_mode, gboolean *pairable)
2402
2292
{
2566
2456
        /* check pending requests */
2567
2457
        reply_pending_requests(adapter);
2568
2458
 
2569
 
        stop_discovery(adapter, FALSE);
 
2459
        stop_discovery(adapter);
2570
2460
 
2571
2461
        if (adapter->disc_sessions) {
2572
2462
                g_slist_foreach(adapter->disc_sessions, (GFunc) session_free,
2780
2670
        bacpy(bdaddr, &adapter->bdaddr);
2781
2671
}
2782
2672
 
 
2673
static inline void suspend_discovery(struct btd_adapter *adapter)
 
2674
{
 
2675
        if (adapter->state != STATE_SUSPENDED)
 
2676
                return;
 
2677
 
 
2678
        if (adapter->oor_devices) {
 
2679
                g_slist_free(adapter->oor_devices);
 
2680
                adapter->oor_devices = NULL;
 
2681
        }
 
2682
 
 
2683
        if (adapter->scheduler_id) {
 
2684
                g_source_remove(adapter->scheduler_id);
 
2685
                adapter->scheduler_id = 0;
 
2686
        }
 
2687
 
 
2688
        adapter_ops->stop_discovery(adapter->dev_id);
 
2689
}
 
2690
 
 
2691
static inline void resolve_names(struct btd_adapter *adapter)
 
2692
{
 
2693
        int err;
 
2694
 
 
2695
        if (adapter->state != STATE_RESOLVNAME)
 
2696
                return;
 
2697
 
 
2698
        err = adapter_resolve_names(adapter);
 
2699
        if (err < 0)
 
2700
                adapter_set_state(adapter, STATE_IDLE);
 
2701
}
 
2702
 
2783
2703
void adapter_set_state(struct btd_adapter *adapter, int state)
2784
2704
{
2785
2705
        const char *path = adapter->path;
2786
2706
        gboolean discov_active;
2787
 
        int previous, type;
2788
2707
 
2789
2708
        if (adapter->state == state)
2790
2709
                return;
2791
2710
 
2792
 
        previous = adapter->state;
2793
2711
        adapter->state = state;
2794
2712
 
2795
 
        type = adapter_get_discover_type(adapter);
2796
 
 
2797
 
        switch (state) {
2798
 
        case STATE_STDINQ:
2799
 
        case STATE_PINQ:
2800
 
                discov_active = TRUE;
2801
 
 
2802
 
                /* Started a new session while resolving names ? */
2803
 
                if (previous & STATE_RESOLVNAME)
2804
 
                        return;
2805
 
                break;
2806
 
        case STATE_LE_SCAN:
2807
 
                discov_active = TRUE;
2808
 
 
2809
 
                if (!adapter->disc_sessions)
2810
 
                        break;
2811
 
 
2812
 
                /* Stop scanning after TGAP(100)/2 */
2813
 
                adapter->stop_discov_id = g_timeout_add(GAP_INTER_DISCOV_WIN,
2814
 
                                                        stop_scanning,
2815
 
                                                        adapter);
2816
 
 
2817
 
                /* For dual mode: don't send "Discovering = TRUE" (twice) */
2818
 
                if (bredr_capable(adapter) == TRUE)
2819
 
                        return;
2820
 
 
2821
 
                break;
 
2713
        DBG("hci%d: new state %d", adapter->dev_id, adapter->state);
 
2714
 
 
2715
        switch (adapter->state) {
2822
2716
        case STATE_IDLE:
2823
 
                /*
2824
 
                 * Interleave: from inquiry to scanning. Interleave is not
2825
 
                 * applicable to requests triggered by external applications.
2826
 
                 */
2827
 
                if (adapter->disc_sessions && (type & DISC_INTERLEAVE) &&
2828
 
                                                (previous & STATE_STDINQ)) {
2829
 
                        adapter_ops->start_scanning(adapter->dev_id);
2830
 
                        return;
2831
 
                }
2832
 
                /* BR/EDR only: inquiry finished */
2833
 
                discov_active = FALSE;
2834
 
                break;
2835
 
        default:
2836
 
                discov_active = FALSE;
2837
 
                break;
2838
 
        }
2839
 
 
2840
 
        if (discov_active == FALSE) {
2841
 
                if (type & DISC_RESOLVNAME) {
2842
 
                        if (adapter_resolve_names(adapter) == 0) {
2843
 
                                adapter->state |= STATE_RESOLVNAME;
2844
 
                                return;
2845
 
                        }
2846
 
                }
2847
 
 
2848
2717
                update_oor_devices(adapter);
2849
 
        } else if (adapter->disc_sessions && main_opts.discov_interval)
 
2718
 
 
2719
                discov_active = FALSE;
 
2720
                emit_property_changed(connection, path,
 
2721
                                        ADAPTER_INTERFACE, "Discovering",
 
2722
                                        DBUS_TYPE_BOOLEAN, &discov_active);
 
2723
 
 
2724
                if (adapter_has_discov_sessions(adapter)) {
2850
2725
                        adapter->scheduler_id = g_timeout_add_seconds(
2851
2726
                                                main_opts.discov_interval,
2852
2727
                                                discovery_cb, adapter);
2853
 
 
2854
 
        emit_property_changed(connection, path,
2855
 
                                ADAPTER_INTERFACE, "Discovering",
2856
 
                                DBUS_TYPE_BOOLEAN, &discov_active);
 
2728
                }
 
2729
                break;
 
2730
        case STATE_DISCOV:
 
2731
                discov_active = TRUE;
 
2732
                emit_property_changed(connection, path,
 
2733
                                        ADAPTER_INTERFACE, "Discovering",
 
2734
                                        DBUS_TYPE_BOOLEAN, &discov_active);
 
2735
                break;
 
2736
        case STATE_RESOLVNAME:
 
2737
                resolve_names(adapter);
 
2738
                break;
 
2739
        case STATE_SUSPENDED:
 
2740
                suspend_discovery(adapter);
 
2741
                break;
 
2742
        }
2857
2743
}
2858
2744
 
2859
2745
int adapter_get_state(struct btd_adapter *adapter)
2942
2828
 
2943
2829
static char **strlist2array(GSList *list)
2944
2830
{
2945
 
        GSList *l;
2946
2831
        unsigned int i, n;
2947
2832
        char **array;
2948
2833
 
2952
2837
        n = g_slist_length(list);
2953
2838
        array = g_new0(char *, n + 1);
2954
2839
 
2955
 
        for (l = list, i = 0; l; l = l->next, i++)
2956
 
                array[i] = g_strdup((const gchar *) l->data);
 
2840
        for (i = 0; list; list = list->next, i++)
 
2841
                array[i] = g_strdup((const gchar *) list->data);
2957
2842
 
2958
2843
        return array;
2959
2844
}
3029
2914
        g_free(alias);
3030
2915
}
3031
2916
 
3032
 
static struct remote_dev_info *get_found_dev(struct btd_adapter *adapter,
3033
 
                                                const bdaddr_t *bdaddr,
3034
 
                                                gboolean *new_dev)
 
2917
static struct remote_dev_info *found_device_new(const bdaddr_t *bdaddr,
 
2918
                                        gboolean le, const char *name,
 
2919
                                        const char *alias, uint32_t class,
 
2920
                                        gboolean legacy, name_status_t status,
 
2921
                                        int flags)
3035
2922
{
3036
 
        struct remote_dev_info *dev, match;
3037
 
 
3038
 
        memset(&match, 0, sizeof(struct remote_dev_info));
3039
 
        bacpy(&match.bdaddr, bdaddr);
3040
 
        match.name_status = NAME_ANY;
3041
 
 
3042
 
        dev = adapter_search_found_devices(adapter, &match);
3043
 
        if (dev) {
3044
 
                *new_dev = FALSE;
3045
 
                /* Out of range list update */
3046
 
                adapter->oor_devices = g_slist_remove(adapter->oor_devices,
3047
 
                                                        dev);
3048
 
        } else {
3049
 
                *new_dev = TRUE;
3050
 
                dev = g_new0(struct remote_dev_info, 1);
3051
 
                bacpy(&dev->bdaddr, bdaddr);
3052
 
                adapter->found_devices = g_slist_prepend(adapter->found_devices,
3053
 
                                                                        dev);
3054
 
        }
 
2923
        struct remote_dev_info *dev;
 
2924
 
 
2925
        dev = g_new0(struct remote_dev_info, 1);
 
2926
        bacpy(&dev->bdaddr, bdaddr);
 
2927
        dev->le = le;
 
2928
        dev->name = g_strdup(name);
 
2929
        dev->alias = g_strdup(alias);
 
2930
        dev->class = class;
 
2931
        dev->legacy = legacy;
 
2932
        dev->name_status = status;
 
2933
        if (flags >= 0)
 
2934
                dev->flags = flags;
3055
2935
 
3056
2936
        return dev;
3057
2937
}
3081
2961
        dev->services = g_slist_prepend(dev->services, g_strdup(new_uuid));
3082
2962
}
3083
2963
 
3084
 
void adapter_update_device_from_info(struct btd_adapter *adapter,
3085
 
                                        bdaddr_t bdaddr, int8_t rssi,
3086
 
                                        uint8_t evt_type, const char *name,
3087
 
                                        GSList *services, int flags)
3088
 
{
3089
 
        struct remote_dev_info *dev;
3090
 
        gboolean new_dev;
3091
 
 
3092
 
        dev = get_found_dev(adapter, &bdaddr, &new_dev);
3093
 
 
3094
 
        if (new_dev) {
3095
 
                dev->le = TRUE;
3096
 
                dev->evt_type = evt_type;
3097
 
        } else if (dev->rssi == rssi)
3098
 
                return;
3099
 
 
3100
 
        dev->rssi = rssi;
3101
 
 
3102
 
        adapter->found_devices = g_slist_sort(adapter->found_devices,
3103
 
                                                (GCompareFunc) dev_rssi_cmp);
3104
 
 
3105
 
        g_slist_foreach(services, remove_same_uuid, dev);
3106
 
        g_slist_foreach(services, dev_prepend_uuid, dev);
3107
 
 
3108
 
        if (flags >= 0)
3109
 
                dev->flags = flags;
3110
 
 
3111
 
        if (name) {
3112
 
                g_free(dev->name);
3113
 
                dev->name = g_strdup(name);
3114
 
        }
3115
 
 
3116
 
        /* FIXME: check if other information was changed before emitting the
3117
 
         * signal */
3118
 
        adapter_emit_device_found(adapter, dev);
 
2964
static gboolean pairing_is_legacy(bdaddr_t *local, bdaddr_t *peer,
 
2965
                                        const uint8_t *eir, const char *name)
 
2966
{
 
2967
        unsigned char features[8];
 
2968
 
 
2969
        if (eir)
 
2970
                return FALSE;
 
2971
 
 
2972
        if (name == NULL)
 
2973
                return TRUE;
 
2974
 
 
2975
        if (read_remote_features(local, peer, NULL, features) < 0)
 
2976
                return TRUE;
 
2977
 
 
2978
        if (features[0] & 0x01)
 
2979
                return FALSE;
 
2980
        else
 
2981
                return TRUE;
 
2982
}
 
2983
 
 
2984
static char *read_stored_data(bdaddr_t *local, bdaddr_t *peer, const char *file)
 
2985
{
 
2986
        char local_addr[18], peer_addr[18], filename[PATH_MAX + 1];
 
2987
 
 
2988
        ba2str(local, local_addr);
 
2989
        ba2str(peer, peer_addr);
 
2990
 
 
2991
        create_name(filename, PATH_MAX, STORAGEDIR, local_addr, file);
 
2992
 
 
2993
        return textfile_get(filename, peer_addr);
3119
2994
}
3120
2995
 
3121
2996
void adapter_update_found_devices(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3122
 
                                int8_t rssi, uint32_t class, const char *name,
3123
 
                                const char *alias, gboolean legacy,
3124
 
                                GSList *services, name_status_t name_status)
 
2997
                                                uint32_t class, int8_t rssi,
 
2998
                                                uint8_t *data)
3125
2999
{
3126
 
        struct remote_dev_info *dev;
3127
 
        gboolean new_dev;
3128
 
 
3129
 
        dev = get_found_dev(adapter, bdaddr, &new_dev);
3130
 
 
3131
 
        if (new_dev) {
3132
 
                if (name)
3133
 
                        dev->name = g_strdup(name);
3134
 
 
3135
 
                if (alias)
3136
 
                        dev->alias = g_strdup(alias);
3137
 
 
3138
 
                dev->le = FALSE;
3139
 
                dev->class = class;
3140
 
                dev->legacy = legacy;
3141
 
                dev->name_status = name_status;
3142
 
        } else if (dev->rssi == rssi)
3143
 
                return;
3144
 
 
 
3000
        struct remote_dev_info *dev, match;
 
3001
        struct eir_data eir_data;
 
3002
        char *alias, *name;
 
3003
        gboolean legacy, le;
 
3004
        name_status_t name_status;
 
3005
        int err;
 
3006
 
 
3007
        memset(&eir_data, 0, sizeof(eir_data));
 
3008
        err = eir_parse(&eir_data, data);
 
3009
        if (err < 0) {
 
3010
                error("Error parsing EIR data: %s (%d)", strerror(-err), -err);
 
3011
                return;
 
3012
        }
 
3013
 
 
3014
        if (eir_data.name != NULL && eir_data.name_complete)
 
3015
                write_device_name(&adapter->bdaddr, bdaddr, eir_data.name);
 
3016
 
 
3017
        /* Device already seen in the discovery session ? */
 
3018
        memset(&match, 0, sizeof(struct remote_dev_info));
 
3019
        bacpy(&match.bdaddr, bdaddr);
 
3020
        match.name_status = NAME_ANY;
 
3021
 
 
3022
        dev = adapter_search_found_devices(adapter, &match);
 
3023
        if (dev) {
 
3024
                adapter->oor_devices = g_slist_remove(adapter->oor_devices,
 
3025
                                                        dev);
 
3026
                if (dev->rssi != rssi)
 
3027
                        goto done;
 
3028
 
 
3029
                eir_data_free(&eir_data);
 
3030
 
 
3031
                return;
 
3032
        }
 
3033
 
 
3034
        /* New device in the discovery session */
 
3035
 
 
3036
        name = read_stored_data(&adapter->bdaddr, bdaddr, "names");
 
3037
 
 
3038
        if (eir_data.flags < 0) {
 
3039
                le = FALSE;
 
3040
 
 
3041
                legacy = pairing_is_legacy(&adapter->bdaddr, bdaddr, data,
 
3042
                                                                        name);
 
3043
 
 
3044
                if (!name && main_opts.name_resolv &&
 
3045
                                adapter_has_discov_sessions(adapter))
 
3046
                        name_status = NAME_REQUIRED;
 
3047
                else
 
3048
                        name_status = NAME_NOT_REQUIRED;
 
3049
        } else {
 
3050
                le = TRUE;
 
3051
                legacy = FALSE;
 
3052
                name_status = NAME_NOT_REQUIRED;
 
3053
        }
 
3054
 
 
3055
        alias = read_stored_data(&adapter->bdaddr, bdaddr, "aliases");
 
3056
 
 
3057
        dev = found_device_new(bdaddr, le, name, alias, class, legacy,
 
3058
                                                name_status, eir_data.flags);
 
3059
        free(name);
 
3060
        free(alias);
 
3061
 
 
3062
        adapter->found_devices = g_slist_prepend(adapter->found_devices, dev);
 
3063
 
 
3064
done:
3145
3065
        dev->rssi = rssi;
3146
3066
 
3147
3067
        adapter->found_devices = g_slist_sort(adapter->found_devices,
3148
3068
                                                (GCompareFunc) dev_rssi_cmp);
3149
3069
 
3150
 
        g_slist_foreach(services, remove_same_uuid, dev);
3151
 
        g_slist_foreach(services, dev_prepend_uuid, dev);
 
3070
        g_slist_foreach(eir_data.services, remove_same_uuid, dev);
 
3071
        g_slist_foreach(eir_data.services, dev_prepend_uuid, dev);
3152
3072
 
3153
3073
        adapter_emit_device_found(adapter, dev);
 
3074
 
 
3075
        eir_data_free(&eir_data);
3154
3076
}
3155
3077
 
3156
3078
int adapter_remove_found_device(struct btd_adapter *adapter, bdaddr_t *bdaddr)
3233
3155
 
3234
3156
struct agent *adapter_get_agent(struct btd_adapter *adapter)
3235
3157
{
3236
 
        if (!adapter || !adapter->agent)
 
3158
        if (!adapter)
3237
3159
                return NULL;
3238
3160
 
3239
3161
        return adapter->agent;
3255
3177
void adapter_remove_connection(struct btd_adapter *adapter,
3256
3178
                                                struct btd_device *device)
3257
3179
{
3258
 
        bdaddr_t bdaddr;
3259
 
 
3260
3180
        DBG("");
3261
3181
 
3262
3182
        if (!g_slist_find(adapter->connections, device)) {
3268
3188
 
3269
3189
        adapter->connections = g_slist_remove(adapter->connections, device);
3270
3190
 
3271
 
        /* clean pending HCI cmds */
3272
 
        device_get_address(device, &bdaddr);
3273
 
 
3274
3191
        if (device_is_authenticating(device))
3275
3192
                device_cancel_authentication(device, TRUE);
3276
3193
 
3293
3210
void adapter_suspend_discovery(struct btd_adapter *adapter)
3294
3211
{
3295
3212
        if (adapter->disc_sessions == NULL ||
3296
 
                        adapter->state & STATE_SUSPENDED)
 
3213
                        adapter->state == STATE_SUSPENDED)
3297
3214
                return;
3298
3215
 
3299
3216
        DBG("Suspending discovery");
3300
3217
 
3301
 
        stop_discovery(adapter, TRUE);
3302
 
        adapter->state |= STATE_SUSPENDED;
 
3218
        adapter_set_state(adapter, STATE_SUSPENDED);
3303
3219
}
3304
3220
 
3305
3221
void adapter_resume_discovery(struct btd_adapter *adapter)
3306
3222
{
3307
 
        if (adapter->disc_sessions == NULL)
3308
 
                return;
3309
 
 
3310
3223
        DBG("Resuming discovery");
3311
3224
 
3312
 
        adapter->state &= ~STATE_SUSPENDED;
3313
 
        start_discovery(adapter);
 
3225
        adapter_set_state(adapter, STATE_IDLE);
3314
3226
}
3315
3227
 
3316
3228
int btd_register_adapter_driver(struct btd_adapter_driver *driver)
3524
3436
int btd_adapter_restore_powered(struct btd_adapter *adapter)
3525
3437
{
3526
3438
        char mode[14], address[18];
3527
 
        gboolean discoverable;
3528
3439
 
3529
3440
        if (!adapter_ops)
3530
3441
                return -EINVAL;
3540
3451
                                                g_str_equal(mode, "off"))
3541
3452
                return 0;
3542
3453
 
3543
 
        discoverable = get_mode(&adapter->bdaddr, mode) == MODE_DISCOVERABLE;
3544
 
 
3545
3454
        return adapter_ops->set_powered(adapter->dev_id, TRUE);
3546
3455
}
3547
3456
 
3662
3571
}
3663
3572
 
3664
3573
int btd_adapter_pincode_reply(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3665
 
                                                        const char *pin)
 
3574
                                        const char *pin, size_t pin_len)
3666
3575
{
3667
 
        return adapter_ops->pincode_reply(adapter->dev_id, bdaddr, pin);
 
3576
        return adapter_ops->pincode_reply(adapter->dev_id, bdaddr, pin,
 
3577
                                                                pin_len);
3668
3578
}
3669
3579
 
3670
3580
int btd_adapter_confirm_reply(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3679
3589
        return adapter_ops->passkey_reply(adapter->dev_id, bdaddr, passkey);
3680
3590
}
3681
3591
 
3682
 
void btd_adapter_update_local_ext_features(struct btd_adapter *adapter,
3683
 
                                                const uint8_t *features)
3684
 
{
3685
 
        memcpy(adapter->extfeatures, features, 8);
3686
 
}
3687
 
 
3688
3592
int btd_adapter_encrypt_link(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3689
3593
                                        bt_hci_result_t cb, gpointer user_data)
3690
3594
{