← Back to branch summary

~ubuntu-branches/ubuntu/wily/bluez/wily

« back to all changes in this revision

Viewing changes to src/sdpd-database.c

Import upstream version 4.81

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/sdpd-database.c
4
4
 *
5
5
 *  Copyright (C) 2001-2002  Nokia Corporation
6
6
 *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
7
 
 *  Copyright (C) 2002-2009  Marcel Holtmann <marcel@holtmann.org>
 
7
 *  Copyright (C) 2002-2010  Marcel Holtmann <marcel@holtmann.org>
8
8
 *  Copyright (C) 2002-2003  Stephen Crane <steve.crane@rococosoft.com>
9
9
 *
10
10
 *
39
39
#include <bluetooth/sdp_lib.h>
40
40
 
41
41
#include "sdpd.h"
42
 
#include "logging.h"
 
42
#include "log.h"
 
43
#include "adapter.h"
43
44
 
44
45
static sdp_list_t *service_db;
45
46
static sdp_list_t *access_db;
54
55
 * The service repository is a linked list in sorted order
55
56
 * and the service record handle is the sort key
56
57
 */
57
 
static int record_sort(const void *r1, const void *r2)
 
58
int record_sort(const void *r1, const void *r2)
58
59
{
59
 
        const sdp_record_t *rec1 = (const sdp_record_t *) r1;
60
 
        const sdp_record_t *rec2 = (const sdp_record_t *) r2;
 
60
        const sdp_record_t *rec1 = r1;
 
61
        const sdp_record_t *rec2 = r2;
61
62
 
62
63
        if (!rec1 || !rec2) {
63
64
                error("NULL RECORD LIST FATAL");
69
70
 
70
71
static int access_sort(const void *r1, const void *r2)
71
72
{
72
 
        const sdp_access_t *rec1 = (const sdp_access_t *) r1;
73
 
        const sdp_access_t *rec2 = (const sdp_access_t *) r2;
 
73
        const sdp_access_t *rec1 = r1;
 
74
        const sdp_access_t *rec2 = r2;
74
75
 
75
76
        if (!rec1 || !rec2) {
76
77
                error("NULL RECORD LIST FATAL");
109
110
        sdp_list_t *p, *q;
110
111
 
111
112
        for (p = socket_index, q = 0; p; ) {
112
 
                sdp_indexed_t *item = (sdp_indexed_t *) p->data;
 
113
                sdp_indexed_t *item = p->data;
113
114
                if (item->sock == sock) {
114
115
                        sdp_list_t *next = p->next;
115
116
                        sdp_record_remove(item->record->handle);
135
136
        sdp_list_t *p, *q;
136
137
 
137
138
        for (p = socket_index, q = 0; p; q = p, p = p->next) {
138
 
                sdp_indexed_t *item = (sdp_indexed_t *) p->data;
 
139
                sdp_indexed_t *item = p->data;
139
140
                if (rec == item->record) {
140
141
                        free(item);
141
142
                        if (q)
150
151
 
151
152
static int compare_indices(const void *i1, const void *i2)
152
153
{
153
 
        const sdp_indexed_t *s1 = (const sdp_indexed_t *) i1;
154
 
        const sdp_indexed_t *s2 = (const sdp_indexed_t *) i2;
 
154
        const sdp_indexed_t *s1 = i1;
 
155
        const sdp_indexed_t *s2 = i2;
155
156
        return s1->sock - s2->sock;
156
157
}
157
158
 
183
184
        dev->handle = rec->handle;
184
185
 
185
186
        access_db = sdp_list_insert_sorted(access_db, dev, access_sort);
 
187
 
 
188
        adapter_service_insert(device, rec);
186
189
}
187
190
 
188
191
static sdp_list_t *record_locate(uint32_t handle)
227
230
                return 0;
228
231
        }
229
232
 
230
 
        return (sdp_record_t *) p->data;
 
233
        return p->data;
231
234
}
232
235
 
233
236
/*
244
247
                return -1;
245
248
        }
246
249
 
247
 
        r = (sdp_record_t *) p->data;
 
250
        r = p->data;
248
251
        if (r)
249
252
                service_db = sdp_list_remove(service_db, r);
250
253
 
251
254
        p = access_locate(handle);
252
255
        if (p) {
253
 
                a = (sdp_access_t *) p->data;
 
256
                a = p->data;
254
257
                if (a) {
 
258
                        adapter_service_remove(&a->device, r);
255
259
                        access_db = sdp_list_remove(access_db, a);
256
260
                        access_free(a);
257
261
                }
281
285
        if (!p)
282
286
                return 1;
283
287
 
284
 
        a = (sdp_access_t *) p->data;
 
288
        a = p->data;
285
289
        if (!a)
286
290
                return 1;
287
291
 
302
306
 
303
307
        return handle;
304
308
}
 
309
 
 
310
void sdp_init_services_list(bdaddr_t *device)
 
311
{
 
312
        sdp_list_t *p;
 
313
 
 
314
        SDPDBG("");
 
315
 
 
316
        for (p = access_db; p != NULL; p = p->next) {
 
317
                sdp_access_t *access = p->data;
 
318
                sdp_record_t *rec;
 
319
 
 
320
                if (bacmp(BDADDR_ANY, &access->device))
 
321
                        continue;
 
322
 
 
323
                rec = sdp_record_find(access->handle);
 
324
                if (rec == NULL)
 
325
                        continue;
 
326
 
 
327
                SDPDBG("adding record with handle %x", access->handle);
 
328
 
 
329
                adapter_service_insert(device, rec);
 
330
        }
 
331
}