← Back to branch summary

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

« back to all changes in this revision

Viewing changes to common/btio.c

Import upstream version 4.81

Show diffs side-by-side

added added

removed removed

Lines of Context:
common/btio.c
1
 
/*
2
 
 *
3
 
 *  BlueZ - Bluetooth protocol stack for Linux
4
 
 *
5
 
 *  Copyright (C) 2009  Marcel Holtmann <marcel@holtmann.org>
6
 
 *  Copyright (C) 2009  Nokia Corporation
7
 
 *
8
 
 *
9
 
 *  This program is free software; you can redistribute it and/or modify
10
 
 *  it under the terms of the GNU General Public License as published by
11
 
 *  the Free Software Foundation; either version 2 of the License, or
12
 
 *  (at your option) any later version.
13
 
 *
14
 
 *  This program is distributed in the hope that it will be useful,
15
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
 
 *  GNU General Public License for more details.
18
 
 *
19
 
 *  You should have received a copy of the GNU General Public License
20
 
 *  along with this program; if not, write to the Free Software
21
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
22
 
 *
23
 
 */
24
 
#include <stdarg.h>
25
 
#include <stdlib.h>
26
 
#include <unistd.h>
27
 
#include <errno.h>
28
 
#include <poll.h>
29
 
#include <sys/types.h>
30
 
#include <sys/socket.h>
31
 
 
32
 
#include <bluetooth/bluetooth.h>
33
 
#include <bluetooth/l2cap.h>
34
 
#include <bluetooth/rfcomm.h>
35
 
#include <bluetooth/sco.h>
36
 
#include <bluetooth/hci.h>
37
 
#include <bluetooth/hci_lib.h>
38
 
 
39
 
#include <glib.h>
40
 
 
41
 
#include "logging.h"
42
 
#include "btio.h"
43
 
 
44
 
#define ERROR_FAILED(gerr, str, err) \
45
 
                g_set_error(gerr, BT_IO_ERROR, BT_IO_ERROR_FAILED, \
46
 
                                str ": %s (%d)", strerror(err), err)
47
 
 
48
 
#define DEFAULT_DEFER_TIMEOUT 30
49
 
 
50
 
struct set_opts {
51
 
        bdaddr_t src;
52
 
        bdaddr_t dst;
53
 
        int defer;
54
 
        int sec_level;
55
 
        uint8_t channel;
56
 
        uint16_t psm;
57
 
        uint16_t mtu;
58
 
        uint16_t imtu;
59
 
        uint16_t omtu;
60
 
        int master;
61
 
};
62
 
 
63
 
struct connect {
64
 
        BtIOConnect connect;
65
 
        gpointer user_data;
66
 
        GDestroyNotify destroy;
67
 
};
68
 
 
69
 
struct accept {
70
 
        BtIOConnect connect;
71
 
        gpointer user_data;
72
 
        GDestroyNotify destroy;
73
 
};
74
 
 
75
 
struct server {
76
 
        BtIOConnect connect;
77
 
        BtIOConfirm confirm;
78
 
        gpointer user_data;
79
 
        GDestroyNotify destroy;
80
 
};
81
 
 
82
 
static void server_remove(struct server *server)
83
 
{
84
 
        if (server->destroy)
85
 
                server->destroy(server->user_data);
86
 
        g_free(server);
87
 
}
88
 
 
89
 
static void connect_remove(struct connect *conn)
90
 
{
91
 
        if (conn->destroy)
92
 
                conn->destroy(conn->user_data);
93
 
        g_free(conn);
94
 
}
95
 
 
96
 
static void accept_remove(struct accept *accept)
97
 
{
98
 
        if (accept->destroy)
99
 
                accept->destroy(accept->user_data);
100
 
        g_free(accept);
101
 
}
102
 
 
103
 
static gboolean accept_cb(GIOChannel *io, GIOCondition cond,
104
 
                                                        gpointer user_data)
105
 
{
106
 
        struct accept *accept = user_data;
107
 
        GError *err = NULL;
108
 
 
109
 
        /* If the user aborted this accept attempt */
110
 
        if (cond & G_IO_NVAL)
111
 
                return FALSE;
112
 
 
113
 
        if (cond & (G_IO_HUP | G_IO_ERR))
114
 
                g_set_error(&err, BT_IO_ERROR, BT_IO_ERROR_DISCONNECTED,
115
 
                                "HUP or ERR on socket");
116
 
 
117
 
        accept->connect(io, err, accept->user_data);
118
 
 
119
 
        g_clear_error(&err);
120
 
 
121
 
        return FALSE;
122
 
}
123
 
 
124
 
static gboolean connect_cb(GIOChannel *io, GIOCondition cond,
125
 
                                                        gpointer user_data)
126
 
{
127
 
        struct connect *conn = user_data;
128
 
        GError *gerr = NULL;
129
 
 
130
 
        /* If the user aborted this connect attempt */
131
 
        if (cond & G_IO_NVAL)
132
 
                return FALSE;
133
 
 
134
 
        if (cond & G_IO_OUT) {
135
 
                int err = 0, sock = g_io_channel_unix_get_fd(io);
136
 
                socklen_t len = sizeof(err);
137
 
 
138
 
                if (getsockopt(sock, SOL_SOCKET, SO_ERROR, &err, &len) < 0)
139
 
                        err = errno;
140
 
 
141
 
                if (err)
142
 
                        g_set_error(&gerr, BT_IO_ERROR,
143
 
                                        BT_IO_ERROR_CONNECT_FAILED, "%s (%d)",
144
 
                                        strerror(err), err);
145
 
        } else if (cond & (G_IO_HUP | G_IO_ERR))
146
 
                g_set_error(&gerr, BT_IO_ERROR, BT_IO_ERROR_CONNECT_FAILED,
147
 
                                "HUP or ERR on socket");
148
 
 
149
 
        conn->connect(io, gerr, conn->user_data);
150
 
 
151
 
        if (gerr)
152
 
                g_error_free(gerr);
153
 
 
154
 
        return FALSE;
155
 
}
156
 
 
157
 
static gboolean server_cb(GIOChannel *io, GIOCondition cond,
158
 
                                                        gpointer user_data)
159
 
{
160
 
        struct server *server = user_data;
161
 
        int srv_sock, cli_sock;
162
 
        GIOChannel *cli_io;
163
 
 
164
 
        /* If the user closed the server */
165
 
        if (cond & G_IO_NVAL)
166
 
                return FALSE;
167
 
 
168
 
        srv_sock = g_io_channel_unix_get_fd(io);
169
 
 
170
 
        cli_sock = accept(srv_sock, NULL, NULL);
171
 
        if (cli_sock < 0) {
172
 
                error("accept: %s (%d)", strerror(errno), errno);
173
 
                return TRUE;
174
 
        }
175
 
 
176
 
        cli_io = g_io_channel_unix_new(cli_sock);
177
 
 
178
 
        g_io_channel_set_close_on_unref(cli_io, TRUE);
179
 
        g_io_channel_set_flags(cli_io, G_IO_FLAG_NONBLOCK, NULL);
180
 
 
181
 
        if (server->confirm)
182
 
                server->confirm(cli_io, server->user_data);
183
 
        else
184
 
                server->connect(cli_io, NULL, server->user_data);
185
 
 
186
 
        g_io_channel_unref(cli_io);
187
 
 
188
 
        return TRUE;
189
 
}
190
 
 
191
 
static void server_add(GIOChannel *io, BtIOConnect connect,
192
 
                                BtIOConfirm confirm, gpointer user_data,
193
 
                                GDestroyNotify destroy)
194
 
{
195
 
        struct server *server;
196
 
        GIOCondition cond;
197
 
 
198
 
        server = g_new0(struct server, 1);
199
 
        server->connect = connect;
200
 
        server->confirm = confirm;
201
 
        server->user_data = user_data;
202
 
        server->destroy = destroy;
203
 
 
204
 
        cond = G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL;
205
 
        g_io_add_watch_full(io, G_PRIORITY_DEFAULT, cond, server_cb, server,
206
 
                                        (GDestroyNotify) server_remove);
207
 
}
208
 
 
209
 
static void connect_add(GIOChannel *io, BtIOConnect connect,
210
 
                                gpointer user_data, GDestroyNotify destroy)
211
 
{
212
 
        struct connect *conn;
213
 
        GIOCondition cond;
214
 
 
215
 
        conn = g_new0(struct connect, 1);
216
 
        conn->connect = connect;
217
 
        conn->user_data = user_data;
218
 
        conn->destroy = destroy;
219
 
 
220
 
        cond = G_IO_OUT | G_IO_ERR | G_IO_HUP | G_IO_NVAL;
221
 
        g_io_add_watch_full(io, G_PRIORITY_DEFAULT, cond, connect_cb, conn,
222
 
                                        (GDestroyNotify) connect_remove);
223
 
}
224
 
 
225
 
static void accept_add(GIOChannel *io, BtIOConnect connect, gpointer user_data,
226
 
                                                        GDestroyNotify destroy)
227
 
{
228
 
        struct accept *accept;
229
 
        GIOCondition cond;
230
 
 
231
 
        accept = g_new0(struct accept, 1);
232
 
        accept->connect = connect;
233
 
        accept->user_data = user_data;
234
 
        accept->destroy = destroy;
235
 
 
236
 
        cond = G_IO_OUT | G_IO_ERR | G_IO_HUP | G_IO_NVAL;
237
 
        g_io_add_watch_full(io, G_PRIORITY_DEFAULT, cond, accept_cb, accept,
238
 
                                        (GDestroyNotify) accept_remove);
239
 
}
240
 
 
241
 
static int l2cap_bind(int sock, const bdaddr_t *src, uint16_t psm)
242
 
{
243
 
        struct sockaddr_l2 addr;
244
 
 
245
 
        memset(&addr, 0, sizeof(addr));
246
 
        addr.l2_family = AF_BLUETOOTH;
247
 
        bacpy(&addr.l2_bdaddr, src);
248
 
        addr.l2_psm = htobs(psm);
249
 
 
250
 
        return bind(sock, (struct sockaddr *) &addr, sizeof(addr));
251
 
}
252
 
 
253
 
static int l2cap_connect(int sock, const bdaddr_t *dst, uint16_t psm)
254
 
{
255
 
        int err;
256
 
        struct sockaddr_l2 addr;
257
 
 
258
 
        memset(&addr, 0, sizeof(addr));
259
 
        addr.l2_family = AF_BLUETOOTH;
260
 
        bacpy(&addr.l2_bdaddr, dst);
261
 
        addr.l2_psm = htobs(psm);
262
 
 
263
 
        err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
264
 
        if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS))
265
 
                return err;
266
 
 
267
 
        return 0;
268
 
}
269
 
 
270
 
static int l2cap_set_master(int sock, int master)
271
 
{
272
 
        int flags;
273
 
        socklen_t len;
274
 
 
275
 
        len = sizeof(flags);
276
 
        if (getsockopt(sock, SOL_L2CAP, L2CAP_LM, &flags, &len) < 0)
277
 
                return -errno;
278
 
 
279
 
        if (master) {
280
 
                if (flags & L2CAP_LM_MASTER)
281
 
                        return 0;
282
 
                flags |= L2CAP_LM_MASTER;
283
 
        } else {
284
 
                if (!(flags & L2CAP_LM_MASTER))
285
 
                        return 0;
286
 
                flags &= ~L2CAP_LM_MASTER;
287
 
        }
288
 
 
289
 
        if (setsockopt(sock, SOL_L2CAP, L2CAP_LM, &flags, sizeof(flags)) < 0)
290
 
                return -errno;
291
 
 
292
 
        return 0;
293
 
}
294
 
 
295
 
static int rfcomm_set_master(int sock, int master)
296
 
{
297
 
        int flags;
298
 
        socklen_t len;
299
 
 
300
 
        len = sizeof(flags);
301
 
        if (getsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &flags, &len) < 0)
302
 
                return -errno;
303
 
 
304
 
        if (master) {
305
 
                if (flags & RFCOMM_LM_MASTER)
306
 
                        return 0;
307
 
                flags |= RFCOMM_LM_MASTER;
308
 
        } else {
309
 
                if (!(flags & RFCOMM_LM_MASTER))
310
 
                        return 0;
311
 
                flags &= ~RFCOMM_LM_MASTER;
312
 
        }
313
 
 
314
 
        if (setsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &flags, sizeof(flags)) < 0)
315
 
                return -errno;
316
 
 
317
 
        return 0;
318
 
}
319
 
 
320
 
static int l2cap_set_lm(int sock, int level)
321
 
{
322
 
        int lm_map[] = {
323
 
                0,
324
 
                L2CAP_LM_AUTH,
325
 
                L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT,
326
 
                L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT | L2CAP_LM_SECURE,
327
 
        }, opt = lm_map[level];
328
 
 
329
 
        if (setsockopt(sock, SOL_L2CAP, L2CAP_LM, &opt, sizeof(opt)) < 0)
330
 
                return -errno;
331
 
 
332
 
        return 0;
333
 
}
334
 
 
335
 
static int rfcomm_set_lm(int sock, int level)
336
 
{
337
 
        int lm_map[] = {
338
 
                0,
339
 
                RFCOMM_LM_AUTH,
340
 
                RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT,
341
 
                RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT | RFCOMM_LM_SECURE,
342
 
        }, opt = lm_map[level];
343
 
 
344
 
        if (setsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &opt, sizeof(opt)) < 0)
345
 
                return -errno;
346
 
 
347
 
        return 0;
348
 
}
349
 
 
350
 
static gboolean set_sec_level(int sock, BtIOType type, int level, GError **err)
351
 
{
352
 
        struct bt_security sec;
353
 
        int ret;
354
 
 
355
 
        if (level < BT_SECURITY_LOW || level > BT_SECURITY_HIGH) {
356
 
                g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
357
 
                                "Valid security level range is %d-%d",
358
 
                                BT_SECURITY_LOW, BT_SECURITY_HIGH);
359
 
                return FALSE;
360
 
        }
361
 
 
362
 
        memset(&sec, 0, sizeof(sec));
363
 
        sec.level = level;
364
 
 
365
 
        if (setsockopt(sock, SOL_BLUETOOTH, BT_SECURITY, &sec,
366
 
                                                        sizeof(sec)) == 0)
367
 
                return TRUE;
368
 
 
369
 
        if (errno != ENOPROTOOPT) {
370
 
                ERROR_FAILED(err, "setsockopt(BT_SECURITY)", errno);
371
 
                return FALSE;
372
 
        }
373
 
 
374
 
        if (type == BT_IO_L2CAP)
375
 
                ret = l2cap_set_lm(sock, level);
376
 
        else
377
 
                ret = rfcomm_set_lm(sock, level);
378
 
 
379
 
        if (ret < 0) {
380
 
                ERROR_FAILED(err, "setsockopt(LM)", -ret);
381
 
                return FALSE;
382
 
        }
383
 
 
384
 
        return TRUE;
385
 
}
386
 
 
387
 
static int l2cap_get_lm(int sock, int *sec_level)
388
 
{
389
 
        int opt;
390
 
        socklen_t len;
391
 
 
392
 
        len = sizeof(opt);
393
 
        if (getsockopt(sock, SOL_L2CAP, L2CAP_LM, &opt, &len) < 0)
394
 
                return -errno;
395
 
 
396
 
        *sec_level = 0;
397
 
 
398
 
        if (opt & L2CAP_LM_AUTH)
399
 
                *sec_level = BT_SECURITY_LOW;
400
 
        if (opt & L2CAP_LM_ENCRYPT)
401
 
                *sec_level = BT_SECURITY_MEDIUM;
402
 
        if (opt & L2CAP_LM_SECURE)
403
 
                *sec_level = BT_SECURITY_HIGH;
404
 
 
405
 
        return 0;
406
 
}
407
 
 
408
 
static int rfcomm_get_lm(int sock, int *sec_level)
409
 
{
410
 
        int opt;
411
 
        socklen_t len;
412
 
 
413
 
        len = sizeof(opt);
414
 
        if (getsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &opt, &len) < 0)
415
 
                return -errno;
416
 
 
417
 
        *sec_level = 0;
418
 
 
419
 
        if (opt & RFCOMM_LM_AUTH)
420
 
                *sec_level = BT_SECURITY_LOW;
421
 
        if (opt & RFCOMM_LM_ENCRYPT)
422
 
                *sec_level = BT_SECURITY_MEDIUM;
423
 
        if (opt & RFCOMM_LM_SECURE)
424
 
                *sec_level = BT_SECURITY_HIGH;
425
 
 
426
 
        return 0;
427
 
}
428
 
 
429
 
static gboolean get_sec_level(int sock, BtIOType type, int *level,
430
 
                                                                GError **err)
431
 
{
432
 
        struct bt_security sec;
433
 
        socklen_t len;
434
 
        int ret;
435
 
 
436
 
        memset(&sec, 0, sizeof(sec));
437
 
        len = sizeof(sec);
438
 
        if (getsockopt(sock, SOL_BLUETOOTH, BT_SECURITY, &sec, &len) == 0) {
439
 
                *level = sec.level;
440
 
                return TRUE;
441
 
        }
442
 
 
443
 
        if (errno != ENOPROTOOPT) {
444
 
                ERROR_FAILED(err, "getsockopt(BT_SECURITY)", errno);
445
 
                return FALSE;
446
 
        }
447
 
 
448
 
        if (type == BT_IO_L2CAP)
449
 
                ret = l2cap_get_lm(sock, level);
450
 
        else
451
 
                ret = rfcomm_get_lm(sock, level);
452
 
 
453
 
        if (ret < 0) {
454
 
                ERROR_FAILED(err, "getsockopt(LM)", -ret);
455
 
                return FALSE;
456
 
        }
457
 
 
458
 
        return TRUE;
459
 
}
460
 
 
461
 
static gboolean l2cap_set(int sock, int sec_level, uint16_t imtu,
462
 
                                uint16_t omtu, int master, GError **err)
463
 
{
464
 
        if (imtu || omtu) {
465
 
                struct l2cap_options l2o;
466
 
                socklen_t len;
467
 
 
468
 
                memset(&l2o, 0, sizeof(l2o));
469
 
                len = sizeof(l2o);
470
 
                if (getsockopt(sock, SOL_L2CAP, L2CAP_OPTIONS, &l2o,
471
 
                                                                &len) < 0) {
472
 
                        ERROR_FAILED(err, "getsockopt(L2CAP_OPTIONS)", errno);
473
 
                        return FALSE;
474
 
                }
475
 
 
476
 
                if (imtu)
477
 
                        l2o.imtu = imtu;
478
 
                if (omtu)
479
 
                        l2o.omtu = omtu;
480
 
 
481
 
                if (setsockopt(sock, SOL_L2CAP, L2CAP_OPTIONS, &l2o,
482
 
                                                        sizeof(l2o)) < 0) {
483
 
                        ERROR_FAILED(err, "setsockopt(L2CAP_OPTIONS)", errno);
484
 
                        return FALSE;
485
 
                }
486
 
        }
487
 
 
488
 
        if (master >= 0 && l2cap_set_master(sock, master) < 0) {
489
 
                ERROR_FAILED(err, "l2cap_set_master", errno);
490
 
                return FALSE;
491
 
        }
492
 
 
493
 
        if (sec_level && !set_sec_level(sock, BT_IO_L2CAP, sec_level, err))
494
 
                return FALSE;
495
 
 
496
 
        return TRUE;
497
 
}
498
 
 
499
 
static int rfcomm_bind(int sock, const bdaddr_t *src, uint8_t channel)
500
 
{
501
 
        struct sockaddr_rc addr;
502
 
 
503
 
        memset(&addr, 0, sizeof(addr));
504
 
        addr.rc_family = AF_BLUETOOTH;
505
 
        bacpy(&addr.rc_bdaddr, src);
506
 
        addr.rc_channel = channel;
507
 
 
508
 
        return bind(sock, (struct sockaddr *) &addr, sizeof(addr));
509
 
}
510
 
 
511
 
static int rfcomm_connect(int sock, const bdaddr_t *dst, uint8_t channel)
512
 
{
513
 
        int err;
514
 
        struct sockaddr_rc addr;
515
 
 
516
 
        memset(&addr, 0, sizeof(addr));
517
 
        addr.rc_family = AF_BLUETOOTH;
518
 
        bacpy(&addr.rc_bdaddr, dst);
519
 
        addr.rc_channel = channel;
520
 
 
521
 
        err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
522
 
        if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS))
523
 
                return err;
524
 
 
525
 
        return 0;
526
 
}
527
 
 
528
 
static gboolean rfcomm_set(int sock, int sec_level, int master, GError **err)
529
 
{
530
 
        if (sec_level && !set_sec_level(sock, BT_IO_RFCOMM, sec_level, err))
531
 
                return FALSE;
532
 
 
533
 
        if (master >= 0 && rfcomm_set_master(sock, master) < 0) {
534
 
                ERROR_FAILED(err, "rfcomm_set_master", errno);
535
 
                return FALSE;
536
 
        }
537
 
 
538
 
        return TRUE;
539
 
}
540
 
 
541
 
static int sco_bind(int sock, const bdaddr_t *src)
542
 
{
543
 
        struct sockaddr_sco addr;
544
 
 
545
 
        memset(&addr, 0, sizeof(addr));
546
 
        addr.sco_family = AF_BLUETOOTH;
547
 
        bacpy(&addr.sco_bdaddr, src);
548
 
 
549
 
        return bind(sock, (struct sockaddr *) &addr, sizeof(addr));
550
 
}
551
 
 
552
 
static int sco_connect(int sock, const bdaddr_t *dst)
553
 
{
554
 
        struct sockaddr_sco addr;
555
 
        int err;
556
 
 
557
 
        memset(&addr, 0, sizeof(addr));
558
 
        addr.sco_family = AF_BLUETOOTH;
559
 
        bacpy(&addr.sco_bdaddr, dst);
560
 
 
561
 
        err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
562
 
        if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS))
563
 
                return err;
564
 
 
565
 
        return 0;
566
 
}
567
 
 
568
 
static gboolean sco_set(int sock, uint16_t mtu, GError **err)
569
 
{
570
 
        struct sco_options sco_opt;
571
 
        socklen_t len;
572
 
 
573
 
        if (!mtu)
574
 
                return TRUE;
575
 
 
576
 
        memset(&sco_opt, 0, len);
577
 
        len = sizeof(sco_opt);
578
 
        if (getsockopt(sock, SOL_SCO, SCO_OPTIONS, &sco_opt, &len) < 0) {
579
 
                ERROR_FAILED(err, "getsockopt(SCO_OPTIONS)", errno);
580
 
                return FALSE;
581
 
        }
582
 
 
583
 
        sco_opt.mtu = mtu;
584
 
        if (setsockopt(sock, SOL_SCO, SCO_OPTIONS, &sco_opt,
585
 
                                                sizeof(sco_opt)) < 0) {
586
 
                ERROR_FAILED(err, "setsockopt(SCO_OPTIONS)", errno);
587
 
                return FALSE;
588
 
        }
589
 
 
590
 
        return TRUE;
591
 
}
592
 
 
593
 
static gboolean parse_set_opts(struct set_opts *opts, GError **err,
594
 
                                                BtIOOption opt1, va_list args)
595
 
{
596
 
        BtIOOption opt = opt1;
597
 
        const char *str;
598
 
 
599
 
        memset(opts, 0, sizeof(*opts));
600
 
 
601
 
        /* Set defaults */
602
 
        opts->defer = DEFAULT_DEFER_TIMEOUT;
603
 
        opts->master = -1;
604
 
 
605
 
        while (opt != BT_IO_OPT_INVALID) {
606
 
                switch (opt) {
607
 
                case BT_IO_OPT_SOURCE:
608
 
                        str = va_arg(args, const char *);
609
 
                        if (strncasecmp(str, "hci", 3) == 0)
610
 
                                hci_devba(atoi(str + 3), &opts->src);
611
 
                        else
612
 
                                str2ba(str, &opts->src);
613
 
                        break;
614
 
                case BT_IO_OPT_SOURCE_BDADDR:
615
 
                        bacpy(&opts->src, va_arg(args, const bdaddr_t *));
616
 
                        break;
617
 
                case BT_IO_OPT_DEST:
618
 
                        str2ba(va_arg(args, const char *), &opts->dst);
619
 
                        break;
620
 
                case BT_IO_OPT_DEST_BDADDR:
621
 
                        bacpy(&opts->dst, va_arg(args, const bdaddr_t *));
622
 
                        break;
623
 
                case BT_IO_OPT_DEFER_TIMEOUT:
624
 
                        opts->defer = va_arg(args, int);
625
 
                        break;
626
 
                case BT_IO_OPT_SEC_LEVEL:
627
 
                        opts->sec_level = va_arg(args, int);
628
 
                        break;
629
 
                case BT_IO_OPT_CHANNEL:
630
 
                        opts->channel = va_arg(args, int);
631
 
                        break;
632
 
                case BT_IO_OPT_PSM:
633
 
                        opts->psm = va_arg(args, int);
634
 
                        break;
635
 
                case BT_IO_OPT_MTU:
636
 
                        opts->mtu = va_arg(args, int);
637
 
                        opts->imtu = opts->mtu;
638
 
                        opts->omtu = opts->mtu;
639
 
                        break;
640
 
                case BT_IO_OPT_OMTU:
641
 
                        opts->omtu = va_arg(args, int);
642
 
                        if (!opts->mtu)
643
 
                                opts->mtu = opts->omtu;
644
 
                        break;
645
 
                case BT_IO_OPT_IMTU:
646
 
                        opts->imtu = va_arg(args, int);
647
 
                        if (!opts->mtu)
648
 
                                opts->mtu = opts->imtu;
649
 
                        break;
650
 
                case BT_IO_OPT_MASTER:
651
 
                        opts->master = va_arg(args, gboolean);
652
 
                        break;
653
 
                default:
654
 
                        g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
655
 
                                        "Unknown option %d", opt);
656
 
                        return FALSE;
657
 
                }
658
 
 
659
 
                opt = va_arg(args, int);
660
 
        }
661
 
 
662
 
        return TRUE;
663
 
}
664
 
 
665
 
static gboolean get_peers(int sock, struct sockaddr *src, struct sockaddr *dst,
666
 
                                socklen_t len, GError **err)
667
 
{
668
 
        socklen_t olen;
669
 
 
670
 
        memset(src, 0, len);
671
 
        olen = len;
672
 
        if (getsockname(sock, src, &olen) < 0) {
673
 
                ERROR_FAILED(err, "getsockname", errno);
674
 
                return FALSE;
675
 
        }
676
 
 
677
 
        memset(dst, 0, len);
678
 
        olen = len;
679
 
        if (getpeername(sock, dst, &olen) < 0) {
680
 
                ERROR_FAILED(err, "getpeername", errno);
681
 
                return FALSE;
682
 
        }
683
 
 
684
 
        return TRUE;
685
 
}
686
 
 
687
 
static int l2cap_get_info(int sock, uint16_t *handle, uint8_t *dev_class)
688
 
{
689
 
        struct l2cap_conninfo info;
690
 
        socklen_t len;
691
 
 
692
 
        len = sizeof(info);
693
 
        if (getsockopt(sock, SOL_L2CAP, L2CAP_CONNINFO, &info, &len) < 0)
694
 
                return -errno;
695
 
 
696
 
        if (handle)
697
 
                *handle = info.hci_handle;
698
 
 
699
 
        if (dev_class)
700
 
                memcpy(dev_class, info.dev_class, 3);
701
 
 
702
 
        return 0;
703
 
}
704
 
 
705
 
static gboolean l2cap_get(int sock, GError **err, BtIOOption opt1,
706
 
                                                                va_list args)
707
 
{
708
 
        BtIOOption opt = opt1;
709
 
        struct sockaddr_l2 src, dst;
710
 
        struct l2cap_options l2o;
711
 
        int flags;
712
 
        uint8_t dev_class[3];
713
 
        uint16_t handle;
714
 
        socklen_t len;
715
 
 
716
 
        len = sizeof(l2o);
717
 
        memset(&l2o, 0, len);
718
 
        if (getsockopt(sock, SOL_L2CAP, L2CAP_OPTIONS, &l2o, &len) < 0) {
719
 
                ERROR_FAILED(err, "getsockopt(L2CAP_OPTIONS)", errno);
720
 
                return FALSE;
721
 
        }
722
 
 
723
 
        if (!get_peers(sock, (struct sockaddr *) &src,
724
 
                                (struct sockaddr *) &dst, sizeof(src), err))
725
 
                return FALSE;
726
 
 
727
 
        if (l2cap_get_info(sock, &handle, dev_class) < 0) {
728
 
                ERROR_FAILED(err, "L2CAP_CONNINFO", errno);
729
 
                return FALSE;
730
 
        }
731
 
 
732
 
        while (opt != BT_IO_OPT_INVALID) {
733
 
                switch (opt) {
734
 
                case BT_IO_OPT_SOURCE:
735
 
                        ba2str(&src.l2_bdaddr, va_arg(args, char *));
736
 
                        break;
737
 
                case BT_IO_OPT_SOURCE_BDADDR:
738
 
                        bacpy(va_arg(args, bdaddr_t *), &src.l2_bdaddr);
739
 
                        break;
740
 
                case BT_IO_OPT_DEST:
741
 
                        ba2str(&dst.l2_bdaddr, va_arg(args, char *));
742
 
                        break;
743
 
                case BT_IO_OPT_DEST_BDADDR:
744
 
                        bacpy(va_arg(args, bdaddr_t *), &dst.l2_bdaddr);
745
 
                        break;
746
 
                case BT_IO_OPT_DEFER_TIMEOUT:
747
 
                        len = sizeof(int);
748
 
                        if (getsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP,
749
 
                                        va_arg(args, int *), &len) < 0) {
750
 
                                ERROR_FAILED(err, "getsockopt(DEFER_SETUP)",
751
 
                                                                        errno);
752
 
                                return FALSE;
753
 
                        }
754
 
                        break;
755
 
                case BT_IO_OPT_SEC_LEVEL:
756
 
                        if (!get_sec_level(sock, BT_IO_L2CAP,
757
 
                                                va_arg(args, int *), err))
758
 
                                return FALSE;
759
 
                        break;
760
 
                case BT_IO_OPT_PSM:
761
 
                        *(va_arg(args, uint16_t *)) = src.l2_psm ?
762
 
                                                src.l2_psm : dst.l2_psm;
763
 
                        break;
764
 
                case BT_IO_OPT_OMTU:
765
 
                        *(va_arg(args, uint16_t *)) = l2o.omtu;
766
 
                        break;
767
 
                case BT_IO_OPT_IMTU:
768
 
                        *(va_arg(args, uint16_t *)) = l2o.imtu;
769
 
                        break;
770
 
                case BT_IO_OPT_MASTER:
771
 
                        len = sizeof(flags);
772
 
                        if (getsockopt(sock, SOL_L2CAP, L2CAP_LM, &flags,
773
 
                                                                &len) < 0) {
774
 
                                ERROR_FAILED(err, "getsockopt(L2CAP_LM)",
775
 
                                                                        errno);
776
 
                                return FALSE;
777
 
                        }
778
 
                        *(va_arg(args, gboolean *)) =
779
 
                                (flags & L2CAP_LM_MASTER) ? TRUE : FALSE;
780
 
                        break;
781
 
                case BT_IO_OPT_HANDLE:
782
 
                        *(va_arg(args, uint16_t *)) = handle;
783
 
                        break;
784
 
                case BT_IO_OPT_CLASS:
785
 
                        memcpy(va_arg(args, uint8_t *), dev_class, 3);
786
 
                        break;
787
 
                default:
788
 
                        g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
789
 
                                        "Unknown option %d", opt);
790
 
                        return FALSE;
791
 
                }
792
 
 
793
 
                opt = va_arg(args, int);
794
 
        }
795
 
 
796
 
        return TRUE;
797
 
}
798
 
 
799
 
static int rfcomm_get_info(int sock, uint16_t *handle, uint8_t *dev_class)
800
 
{
801
 
        struct rfcomm_conninfo info;
802
 
        socklen_t len;
803
 
 
804
 
        len = sizeof(info);
805
 
        if (getsockopt(sock, SOL_RFCOMM, RFCOMM_CONNINFO, &info, &len) < 0)
806
 
                return -errno;
807
 
 
808
 
        if (handle)
809
 
                *handle = info.hci_handle;
810
 
 
811
 
        if (dev_class)
812
 
                memcpy(dev_class, info.dev_class, 3);
813
 
 
814
 
        return 0;
815
 
}
816
 
 
817
 
static gboolean rfcomm_get(int sock, GError **err, BtIOOption opt1,
818
 
                                                                va_list args)
819
 
{
820
 
        BtIOOption opt = opt1;
821
 
        struct sockaddr_rc src, dst;
822
 
        int flags;
823
 
        socklen_t len;
824
 
        uint8_t dev_class[3];
825
 
        uint16_t handle;
826
 
 
827
 
        if (!get_peers(sock, (struct sockaddr *) &src,
828
 
                                (struct sockaddr *) &dst, sizeof(src), err))
829
 
                return FALSE;
830
 
 
831
 
        if (rfcomm_get_info(sock, &handle, dev_class) < 0) {
832
 
                ERROR_FAILED(err, "RFCOMM_CONNINFO", errno);
833
 
                return FALSE;
834
 
        }
835
 
 
836
 
        while (opt != BT_IO_OPT_INVALID) {
837
 
                switch (opt) {
838
 
                case BT_IO_OPT_SOURCE:
839
 
                        ba2str(&src.rc_bdaddr, va_arg(args, char *));
840
 
                        break;
841
 
                case BT_IO_OPT_SOURCE_BDADDR:
842
 
                        bacpy(va_arg(args, bdaddr_t *), &src.rc_bdaddr);
843
 
                        break;
844
 
                case BT_IO_OPT_DEST:
845
 
                        ba2str(&dst.rc_bdaddr, va_arg(args, char *));
846
 
                        break;
847
 
                case BT_IO_OPT_DEST_BDADDR:
848
 
                        bacpy(va_arg(args, bdaddr_t *), &dst.rc_bdaddr);
849
 
                        break;
850
 
                case BT_IO_OPT_DEFER_TIMEOUT:
851
 
                        len = sizeof(int);
852
 
                        if (getsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP,
853
 
                                        va_arg(args, int *), &len) < 0) {
854
 
                                ERROR_FAILED(err, "getsockopt(DEFER_SETUP)",
855
 
                                                                        errno);
856
 
                                return FALSE;
857
 
                        }
858
 
                        break;
859
 
                case BT_IO_OPT_SEC_LEVEL:
860
 
                        if (!get_sec_level(sock, BT_IO_RFCOMM,
861
 
                                                va_arg(args, int *), err))
862
 
                                return FALSE;
863
 
                        break;
864
 
                case BT_IO_OPT_CHANNEL:
865
 
                        *(va_arg(args, uint8_t *)) = src.rc_channel ?
866
 
                                        src.rc_channel : dst.rc_channel;
867
 
                        break;
868
 
                case BT_IO_OPT_MASTER:
869
 
                        len = sizeof(flags);
870
 
                        if (getsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &flags,
871
 
                                                                &len) < 0) {
872
 
                                ERROR_FAILED(err, "getsockopt(RFCOMM_LM)",
873
 
                                                                        errno);
874
 
                                return FALSE;
875
 
                        }
876
 
                        *(va_arg(args, gboolean *)) =
877
 
                                (flags & RFCOMM_LM_MASTER) ? TRUE : FALSE;
878
 
                        break;
879
 
                case BT_IO_OPT_HANDLE:
880
 
                        *(va_arg(args, uint16_t *)) = handle;
881
 
                        break;
882
 
                case BT_IO_OPT_CLASS:
883
 
                        memcpy(va_arg(args, uint8_t *), dev_class, 3);
884
 
                        break;
885
 
                default:
886
 
                        g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
887
 
                                        "Unknown option %d", opt);
888
 
                        return FALSE;
889
 
                }
890
 
 
891
 
                opt = va_arg(args, int);
892
 
        }
893
 
 
894
 
        return TRUE;
895
 
}
896
 
 
897
 
static int sco_get_info(int sock, uint16_t *handle, uint8_t *dev_class)
898
 
{
899
 
        struct sco_conninfo info;
900
 
        socklen_t len;
901
 
 
902
 
        len = sizeof(info);
903
 
        if (getsockopt(sock, SOL_SCO, SCO_CONNINFO, &info, &len) < 0)
904
 
                return -errno;
905
 
 
906
 
        if (handle)
907
 
                *handle = info.hci_handle;
908
 
 
909
 
        if (dev_class)
910
 
                memcpy(dev_class, info.dev_class, 3);
911
 
 
912
 
        return 0;
913
 
}
914
 
 
915
 
static gboolean sco_get(int sock, GError **err, BtIOOption opt1, va_list args)
916
 
{
917
 
        BtIOOption opt = opt1;
918
 
        struct sockaddr_sco src, dst;
919
 
        struct sco_options sco_opt;
920
 
        socklen_t len;
921
 
        uint8_t dev_class[3];
922
 
        uint16_t handle;
923
 
 
924
 
        len = sizeof(sco_opt);
925
 
        memset(&sco_opt, 0, len);
926
 
        if (getsockopt(sock, SOL_SCO, SCO_OPTIONS, &sco_opt, &len) < 0) {
927
 
                ERROR_FAILED(err, "getsockopt(SCO_OPTIONS)", errno);
928
 
                return FALSE;
929
 
        }
930
 
 
931
 
        if (!get_peers(sock, (struct sockaddr *) &src,
932
 
                                (struct sockaddr *) &dst, sizeof(src), err))
933
 
                return FALSE;
934
 
 
935
 
        if (sco_get_info(sock, &handle, dev_class) < 0) {
936
 
                ERROR_FAILED(err, "RFCOMM_CONNINFO", errno);
937
 
                return FALSE;
938
 
        }
939
 
 
940
 
        while (opt != BT_IO_OPT_INVALID) {
941
 
                switch (opt) {
942
 
                case BT_IO_OPT_SOURCE:
943
 
                        ba2str(&src.sco_bdaddr, va_arg(args, char *));
944
 
                        break;
945
 
                case BT_IO_OPT_SOURCE_BDADDR:
946
 
                        bacpy(va_arg(args, bdaddr_t *), &src.sco_bdaddr);
947
 
                        break;
948
 
                case BT_IO_OPT_DEST:
949
 
                        ba2str(&dst.sco_bdaddr, va_arg(args, char *));
950
 
                        break;
951
 
                case BT_IO_OPT_DEST_BDADDR:
952
 
                        bacpy(va_arg(args, bdaddr_t *), &dst.sco_bdaddr);
953
 
                        break;
954
 
                case BT_IO_OPT_MTU:
955
 
                case BT_IO_OPT_IMTU:
956
 
                case BT_IO_OPT_OMTU:
957
 
                        *(va_arg(args, uint16_t *)) = sco_opt.mtu;
958
 
                        break;
959
 
                case BT_IO_OPT_HANDLE:
960
 
                        *(va_arg(args, uint16_t *)) = handle;
961
 
                        break;
962
 
                case BT_IO_OPT_CLASS:
963
 
                        memcpy(va_arg(args, uint8_t *), dev_class, 3);
964
 
                        break;
965
 
                default:
966
 
                        g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
967
 
                                        "Unknown option %d", opt);
968
 
                        return FALSE;
969
 
                }
970
 
 
971
 
                opt = va_arg(args, int);
972
 
        }
973
 
 
974
 
        return TRUE;
975
 
}
976
 
 
977
 
static gboolean get_valist(GIOChannel *io, BtIOType type, GError **err,
978
 
                                                BtIOOption opt1, va_list args)
979
 
{
980
 
        int sock;
981
 
 
982
 
        sock = g_io_channel_unix_get_fd(io);
983
 
 
984
 
        switch (type) {
985
 
        case BT_IO_L2RAW:
986
 
        case BT_IO_L2CAP:
987
 
                return l2cap_get(sock, err, opt1, args);
988
 
        case BT_IO_RFCOMM:
989
 
                return rfcomm_get(sock, err, opt1, args);
990
 
        case BT_IO_SCO:
991
 
                return sco_get(sock, err, opt1, args);
992
 
        }
993
 
 
994
 
        g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
995
 
                        "Unknown BtIO type %d", type);
996
 
        return FALSE;
997
 
}
998
 
 
999
 
gboolean bt_io_accept(GIOChannel *io, BtIOConnect connect, gpointer user_data,
1000
 
                                        GDestroyNotify destroy, GError **err)
1001
 
{
1002
 
        int sock;
1003
 
        char c;
1004
 
        struct pollfd pfd;
1005
 
 
1006
 
        sock = g_io_channel_unix_get_fd(io);
1007
 
 
1008
 
        memset(&pfd, 0, sizeof(pfd));
1009
 
        pfd.fd = sock;
1010
 
        pfd.events = POLLOUT;
1011
 
 
1012
 
        if (poll(&pfd, 1, 0) < 0) {
1013
 
                ERROR_FAILED(err, "poll", errno);
1014
 
                return FALSE;
1015
 
        }
1016
 
 
1017
 
        if (!(pfd.revents & POLLOUT)) {
1018
 
                int ret;
1019
 
                ret = read(sock, &c, 1);
1020
 
        }
1021
 
 
1022
 
        accept_add(io, connect, user_data, destroy);
1023
 
 
1024
 
        return TRUE;
1025
 
}
1026
 
 
1027
 
gboolean bt_io_set(GIOChannel *io, BtIOType type, GError **err,
1028
 
                                                        BtIOOption opt1, ...)
1029
 
{
1030
 
        va_list args;
1031
 
        gboolean ret;
1032
 
        struct set_opts opts;
1033
 
        int sock;
1034
 
 
1035
 
        va_start(args, opt1);
1036
 
        ret = parse_set_opts(&opts, err, opt1, args);
1037
 
        va_end(args);
1038
 
 
1039
 
        if (!ret)
1040
 
                return ret;
1041
 
 
1042
 
        sock = g_io_channel_unix_get_fd(io);
1043
 
 
1044
 
        switch (type) {
1045
 
        case BT_IO_L2RAW:
1046
 
        case BT_IO_L2CAP:
1047
 
                return l2cap_set(sock, opts.sec_level, opts.imtu, opts.omtu,
1048
 
                                                        opts.master, err);
1049
 
        case BT_IO_RFCOMM:
1050
 
                return rfcomm_set(sock, opts.sec_level, opts.master, err);
1051
 
        case BT_IO_SCO:
1052
 
                return sco_set(sock, opts.mtu, err);
1053
 
        }
1054
 
 
1055
 
        g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1056
 
                        "Unknown BtIO type %d", type);
1057
 
        return FALSE;
1058
 
}
1059
 
 
1060
 
gboolean bt_io_get(GIOChannel *io, BtIOType type, GError **err,
1061
 
                                                        BtIOOption opt1, ...)
1062
 
{
1063
 
        va_list args;
1064
 
        gboolean ret;
1065
 
 
1066
 
        va_start(args, opt1);
1067
 
        ret = get_valist(io, type, err, opt1, args);
1068
 
        va_end(args);
1069
 
 
1070
 
        return ret;
1071
 
}
1072
 
 
1073
 
static GIOChannel *create_io(BtIOType type, gboolean server,
1074
 
                                        struct set_opts *opts, GError **err)
1075
 
{
1076
 
        int sock;
1077
 
        GIOChannel *io;
1078
 
 
1079
 
        switch (type) {
1080
 
        case BT_IO_L2RAW:
1081
 
                sock = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_L2CAP);
1082
 
                if (sock < 0) {
1083
 
                        ERROR_FAILED(err, "socket(RAW, L2CAP)", errno);
1084
 
                        return NULL;
1085
 
                }
1086
 
                if (l2cap_bind(sock, &opts->src, server ? opts->psm : 0) < 0) {
1087
 
                        ERROR_FAILED(err, "l2cap_bind", errno);
1088
 
                        return NULL;
1089
 
                }
1090
 
                if (!l2cap_set(sock, opts->sec_level, 0, 0, -1, err))
1091
 
                        return NULL;
1092
 
                break;
1093
 
        case BT_IO_L2CAP:
1094
 
                sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
1095
 
                if (sock < 0) {
1096
 
                        ERROR_FAILED(err, "socket(SEQPACKET, L2CAP)", errno);
1097
 
                        return NULL;
1098
 
                }
1099
 
                if (l2cap_bind(sock, &opts->src, server ? opts->psm : 0) < 0) {
1100
 
                        ERROR_FAILED(err, "l2cap_bind", errno);
1101
 
                        return NULL;
1102
 
                }
1103
 
                if (!l2cap_set(sock, opts->sec_level, opts->imtu, opts->omtu,
1104
 
                                                        opts->master, err))
1105
 
                        return NULL;
1106
 
                break;
1107
 
        case BT_IO_RFCOMM:
1108
 
                sock = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
1109
 
                if (sock < 0) {
1110
 
                        ERROR_FAILED(err, "socket(STREAM, RFCOMM)", errno);
1111
 
                        return NULL;
1112
 
                }
1113
 
                if (rfcomm_bind(sock, &opts->src,
1114
 
                                        server ? opts->channel : 0) < 0) {
1115
 
                        ERROR_FAILED(err, "rfcomm_bind", errno);
1116
 
                        return NULL;
1117
 
                }
1118
 
                if (!rfcomm_set(sock, opts->sec_level, opts->master, err))
1119
 
                        return NULL;
1120
 
                break;
1121
 
        case BT_IO_SCO:
1122
 
                sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO);
1123
 
                if (sock < 0) {
1124
 
                        ERROR_FAILED(err, "socket(SEQPACKET, SCO)", errno);
1125
 
                        return NULL;
1126
 
                }
1127
 
                if (sco_bind(sock, &opts->src) < 0) {
1128
 
                        ERROR_FAILED(err, "sco_bind", errno);
1129
 
                        return NULL;
1130
 
                }
1131
 
                if (!sco_set(sock, opts->mtu, err))
1132
 
                        return NULL;
1133
 
                break;
1134
 
        default:
1135
 
                g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1136
 
                                "Unknown BtIO type %d", type);
1137
 
                return NULL;
1138
 
        }
1139
 
 
1140
 
        io = g_io_channel_unix_new(sock);
1141
 
 
1142
 
        g_io_channel_set_close_on_unref(io, TRUE);
1143
 
        g_io_channel_set_flags(io, G_IO_FLAG_NONBLOCK, NULL);
1144
 
 
1145
 
        return io;
1146
 
}
1147
 
 
1148
 
GIOChannel *bt_io_connect(BtIOType type, BtIOConnect connect,
1149
 
                                gpointer user_data, GDestroyNotify destroy,
1150
 
                                GError **gerr, BtIOOption opt1, ...)
1151
 
{
1152
 
        GIOChannel *io;
1153
 
        va_list args;
1154
 
        struct set_opts opts;
1155
 
        int err, sock;
1156
 
        gboolean ret;
1157
 
 
1158
 
        va_start(args, opt1);
1159
 
        ret = parse_set_opts(&opts, gerr, opt1, args);
1160
 
        va_end(args);
1161
 
 
1162
 
        if (ret == FALSE)
1163
 
                return NULL;
1164
 
 
1165
 
        io = create_io(type, FALSE, &opts, gerr);
1166
 
        if (io == NULL)
1167
 
                return NULL;
1168
 
 
1169
 
        sock = g_io_channel_unix_get_fd(io);
1170
 
 
1171
 
        switch (type) {
1172
 
        case BT_IO_L2RAW:
1173
 
                err = l2cap_connect(sock, &opts.dst, 0);
1174
 
                break;
1175
 
        case BT_IO_L2CAP:
1176
 
                err = l2cap_connect(sock, &opts.dst, opts.psm);
1177
 
                break;
1178
 
        case BT_IO_RFCOMM:
1179
 
                err = rfcomm_connect(sock, &opts.dst, opts.channel);
1180
 
                break;
1181
 
        case BT_IO_SCO:
1182
 
                err = sco_connect(sock, &opts.dst);
1183
 
                break;
1184
 
        default:
1185
 
                g_set_error(gerr, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1186
 
                                                "Unknown BtIO type %d", type);
1187
 
                return NULL;
1188
 
        }
1189
 
 
1190
 
        if (err < 0) {
1191
 
                g_set_error(gerr, BT_IO_ERROR, BT_IO_ERROR_CONNECT_FAILED,
1192
 
                                "connect: %s (%d)", strerror(-err), -err);
1193
 
                g_io_channel_unref(io);
1194
 
                return NULL;
1195
 
        }
1196
 
 
1197
 
        connect_add(io, connect, user_data, destroy);
1198
 
 
1199
 
        return io;
1200
 
}
1201
 
 
1202
 
GIOChannel *bt_io_listen(BtIOType type, BtIOConnect connect,
1203
 
                                BtIOConfirm confirm, gpointer user_data,
1204
 
                                GDestroyNotify destroy, GError **err,
1205
 
                                BtIOOption opt1, ...)
1206
 
{
1207
 
        GIOChannel *io;
1208
 
        va_list args;
1209
 
        struct set_opts opts;
1210
 
        int sock;
1211
 
        gboolean ret;
1212
 
 
1213
 
        if (type == BT_IO_L2RAW) {
1214
 
                g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1215
 
                                "Server L2CAP RAW sockets not supported");
1216
 
                return NULL;
1217
 
        }
1218
 
 
1219
 
        va_start(args, opt1);
1220
 
        ret = parse_set_opts(&opts, err, opt1, args);
1221
 
        va_end(args);
1222
 
 
1223
 
        if (ret == FALSE)
1224
 
                return NULL;
1225
 
 
1226
 
        io = create_io(type, TRUE, &opts, err);
1227
 
        if (io == NULL)
1228
 
                return NULL;
1229
 
 
1230
 
        sock = g_io_channel_unix_get_fd(io);
1231
 
 
1232
 
        if (confirm)
1233
 
                setsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP, &opts.defer,
1234
 
                                                        sizeof(opts.defer));
1235
 
 
1236
 
        if (listen(sock, 5) < 0) {
1237
 
                ERROR_FAILED(err, "listen", errno);
1238
 
                g_io_channel_unref(io);
1239
 
                return NULL;
1240
 
        }
1241
 
 
1242
 
        server_add(io, connect, confirm, user_data, destroy);
1243
 
 
1244
 
        return io;
1245
 
}
1246
 
 
1247
 
GQuark bt_io_error_quark(void)
1248
 
{
1249
 
        return g_quark_from_static_string("bt-io-error-quark");
1250
 
}
1251