« back to all changes in this revision
Viewing changes to audio/avdtp.c
- browse files at revision 1.2.2
- compare with another revision
- download diff
- download tarball
- view history from revision 1.2.2
- Committer: Bazaar Package Importer
- Author(s): Nobuhiro Iwamatsu
- Date: 2010-12-02 12:17:48 UTC
- mfrom: (1.3.7 upstream)
- mto: (1.1.23 upstream) (6.2.2 experimental)
- mto: This revision was merged to the branch mainline in revision 51.
- Revision ID: james.westby@ubuntu.com-20101202121748-9y64u4vc3vmk1wvl
Import upstream version 4.81
- files added:
- Makefile.tools
- attrib
- btio
- health
- tracer
- files removed:
- audio/Makefile.am
- client
- common
- include
- rfcomm
- files modified:
- AUTHORS
added
removed
audio/avdtp.c
2
2
*
3
3
* BlueZ - Bluetooth protocol stack for Linux
4
4
*
5
* Copyright (C) 2006-2007 Nokia Corporation
6
* Copyright (C) 2004-2009 Marcel Holtmann <marcel@holtmann.org>
5
* Copyright (C) 2006-2010 Nokia Corporation
6
* Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org>
7
7
*
8
8
*
9
9
* This program is free software; you can redistribute it and/or modify
26
26
#include <config.h>
27
27
#endif
28
28
29
#include <stdlib.h>
29
30
#include <stdio.h>
30
31
#include <stdint.h>
31
32
#include <errno.h>
36
37
37
38
#include <bluetooth/bluetooth.h>
38
39
#include <bluetooth/sdp.h>
40
#include <bluetooth/sdp_lib.h>
39
41
40
42
#include <glib.h>
41
43
#include <dbus/dbus.h>
42
44
43
#include "logging.h"
45
#include "log.h"
44
46
47
#include "../src/manager.h"
45
48
#include "../src/adapter.h"
46
49
#include "../src/device.h"
47
50
52
55
#include "glib-helper.h"
53
56
#include "btio.h"
54
57
#include "sink.h"
55
56
#include <bluetooth/l2cap.h>
58
#include "source.h"
57
59
58
60
#define AVDTP_PSM 25
59
61
70
72
#define AVDTP_SUSPEND 0x09
71
73
#define AVDTP_ABORT 0x0A
72
74
#define AVDTP_SECURITY_CONTROL 0x0B
75
#define AVDTP_GET_ALL_CAPABILITIES 0x0C
76
#define AVDTP_DELAY_REPORT 0x0D
73
77
74
78
#define AVDTP_PKT_TYPE_SINGLE 0x00
75
79
#define AVDTP_PKT_TYPE_START 0x01
77
81
#define AVDTP_PKT_TYPE_END 0x03
78
82
79
83
#define AVDTP_MSG_TYPE_COMMAND 0x00
84
#define AVDTP_MSG_TYPE_GEN_REJECT 0x01
80
85
#define AVDTP_MSG_TYPE_ACCEPT 0x02
81
86
#define AVDTP_MSG_TYPE_REJECT 0x03
82
87
83
88
#define REQ_TIMEOUT 4
89
#define ABORT_TIMEOUT 2
84
90
#define DISCONNECT_TIMEOUT 1
85
91
#define STREAM_TIMEOUT 20
86
92
239
245
uint8_t caps[0];
240
246
} __attribute__ ((packed));
241
247
248
struct delay_req {
249
uint8_t rfa0:2;
250
uint8_t acp_seid:6;
251
uint16_t delay;
252
} __attribute__ ((packed));
253
242
254
#elif __BYTE_ORDER == __BIG_ENDIAN
243
255
244
256
struct seid_req {
271
283
uint8_t caps[0];
272
284
} __attribute__ ((packed));
273
285
286
struct delay_req {
287
uint8_t acp_seid:6;
288
uint8_t rfa0:2;
289
uint16_t delay;
290
} __attribute__ ((packed));
291
274
292
#else
275
293
#error "Unknown byte order"
276
294
#endif
299
317
uint8_t type;
300
318
uint8_t media_type;
301
319
struct avdtp_service_capability *codec;
320
gboolean delay_reporting;
302
321
GSList *caps; /* of type struct avdtp_service_capability */
303
322
struct avdtp_stream *stream;
304
323
};
305
324
306
325
struct avdtp_server {
307
326
bdaddr_t src;
327
uint16_t version;
308
328
GIOChannel *io;
309
329
GSList *seps;
330
GSList *sessions;
310
331
};
311
332
312
333
struct avdtp_local_sep {
314
335
struct avdtp_stream *stream;
315
336
struct seid_info info;
316
337
uint8_t codec;
338
gboolean delay_reporting;
317
339
GSList *caps;
318
340
struct avdtp_sep_ind *ind;
319
341
struct avdtp_sep_cfm *cfm;
345
367
struct avdtp_service_capability *codec;
346
368
guint io_id; /* Transport GSource ID */
347
369
guint timer; /* Waiting for other side to close or open
348
the transport channel */
370
* the transport channel */
349
371
gboolean open_acp; /* If we are in ACT role for Open */
350
372
gboolean close_int; /* If we are in INT role for Close */
373
gboolean abort_int; /* If we are in INT role for Abort */
351
374
guint idle_timer;
375
gboolean delay_reporting;
376
uint16_t delay; /* AVDTP 1.3 Delay Reporting feature */
352
377
};
353
378
354
379
/* Structure describing an AVDTP connection between two devices */
357
382
int ref;
358
383
int free_lock;
359
384
385
uint16_t version;
386
360
387
struct avdtp_server *server;
361
388
bdaddr_t dst;
362
389
365
392
/* True if the session should be automatically disconnected */
366
393
gboolean auto_dc;
367
394
395
/* True if the entire device is being disconnected */
396
gboolean device_disconnect;
397
368
398
GIOChannel *io;
369
399
guint io_id;
370
400
398
428
};
399
429
400
430
static GSList *servers = NULL;
401
static GSList *sessions = NULL;
402
431
403
432
static GSList *avdtp_callbacks = NULL;
404
433
420
449
static void avdtp_sep_set_state(struct avdtp *session,
421
450
struct avdtp_local_sep *sep,
422
451
avdtp_state_t state);
452
static void auth_cb(DBusError *derr, void *user_data);
423
453
424
454
static struct avdtp_server *find_server(GSList *list, const bdaddr_t *src)
425
455
{
457
487
458
488
static gboolean try_send(int sk, void *data, size_t len)
459
489
{
460
gboolean ret;
461
462
ret = send(sk, data, len, 0);
463
464
if (ret < 0)
465
ret = -errno;
466
else if ((size_t) ret != len)
467
ret = -EIO;
468
469
if (ret < 0) {
470
error("try_send: %s (%d)", strerror(-ret), -ret);
490
int err;
491
492
do {
493
err = send(sk, data, len, 0);
494
} while (err < 0 && errno == EINTR);
495
496
if (err < 0) {
497
error("send: %s (%d)", strerror(errno), errno);
498
return FALSE;
499
} else if ((size_t) err != len) {
500
error("try_send: complete buffer not sent (%d/%zu bytes)",
501
err, len);
471
502
return FALSE;
472
503
}
473
504
507
538
return try_send(sock, session->buf, sizeof(single) + len);
508
539
}
509
540
541
/* Check if there is enough space to start packet */
542
if (session->omtu < sizeof(start)) {
543
error("No enough space to fragment packet");
544
return FALSE;
545
}
546
510
547
/* Count the number of needed fragments */
511
548
cont_fragments = (len - (session->omtu - sizeof(start))) /
512
549
(session->omtu - sizeof(cont)) + 1;
513
550
514
debug("avdtp_send: %u bytes split into %d fragments", len,
515
cont_fragments + 1);
551
DBG("%zu bytes split into %d fragments", len, cont_fragments + 1);
516
552
517
553
/* Send the start packet */
518
554
memset(&start, 0, sizeof(start));
529
565
if (!try_send(sock, session->buf, session->omtu))
530
566
return FALSE;
531
567
532
debug("avdtp_send: first packet with %d bytes sent",
533
session->omtu - sizeof(start));
568
DBG("first packet with %zu bytes sent", session->omtu - sizeof(start));
534
569
535
570
sent = session->omtu - sizeof(start);
536
571
542
577
if (left + sizeof(cont) > session->omtu) {
543
578
cont.packet_type = AVDTP_PKT_TYPE_CONTINUE;
544
579
to_copy = session->omtu - sizeof(cont);
545
debug("avdtp_send: sending continue with %d bytes",
546
to_copy);
580
DBG("sending continue with %d bytes", to_copy);
547
581
} else {
548
582
cont.packet_type = AVDTP_PKT_TYPE_END;
549
583
to_copy = left;
550
debug("avdtp_send: sending end with %d bytes",
551
to_copy);
584
DBG("sending end with %d bytes", to_copy);
552
585
}
553
586
554
587
cont.transaction = transaction;
574
607
g_free(req);
575
608
}
576
609
610
static void close_stream(struct avdtp_stream *stream)
611
{
612
int sock;
613
614
if (stream->io == NULL)
615
return;
616
617
sock = g_io_channel_unix_get_fd(stream->io);
618
619
shutdown(sock, SHUT_RDWR);
620
621
g_io_channel_shutdown(stream->io, FALSE, NULL);
622
623
g_io_channel_unref(stream->io);
624
stream->io = NULL;
625
}
626
577
627
static gboolean stream_close_timeout(gpointer user_data)
578
628
{
579
629
struct avdtp_stream *stream = user_data;
580
630
581
debug("Timed out waiting for peer to close the transport channel");
631
DBG("Timed out waiting for peer to close the transport channel");
582
632
583
633
stream->timer = 0;
584
634
585
g_io_channel_shutdown(stream->io, FALSE, NULL);
635
close_stream(stream);
586
636
587
637
return FALSE;
588
638
}
591
641
{
592
642
struct avdtp_stream *stream = user_data;
593
643
594
debug("Timed out waiting for peer to open the transport channel");
644
DBG("Timed out waiting for peer to open the transport channel");
595
645
596
646
stream->timer = 0;
597
647
608
658
struct audio_device *dev;
609
659
gboolean stream_setup;
610
660
611
assert(session->ref == 1);
612
613
661
session->dc_timer = 0;
614
662
stream_setup = session->stream_setup;
615
663
session->stream_setup = FALSE;
616
664
617
dev = manager_get_device(&session->server->src, &session->dst);
665
dev = manager_get_device(&session->server->src, &session->dst, FALSE);
618
666
619
667
if (dev && dev->sink && stream_setup)
620
668
sink_setup_stream(dev->sink, session);
669
else if (dev && dev->source && stream_setup)
670
source_setup_stream(dev->source, session);
621
671
else
622
672
connection_lost(session, ETIMEDOUT);
623
673
636
686
if (session->dc_timer)
637
687
remove_disconnect_timer(session);
638
688
689
if (session->device_disconnect) {
690
g_idle_add(disconnect_timeout, session);
691
return;
692
}
693
639
694
session->dc_timer = g_timeout_add_seconds(DISCONNECT_TIMEOUT,
640
695
disconnect_timeout,
641
696
session);
642
697
}
643
698
644
void avdtp_error_init(struct avdtp_error *err, uint8_t type, int id)
699
void avdtp_error_init(struct avdtp_error *err, uint8_t category, int id)
645
700
{
646
err->type = type;
647
switch (type) {
648
case AVDTP_ERROR_ERRNO:
701
err->category = category;
702
703
if (category == AVDTP_ERRNO)
649
704
err->err.posix_errno = id;
650
break;
651
case AVDTP_ERROR_ERROR_CODE:
705
else
652
706
err->err.error_code = id;
653
break;
654
}
655
707
}
656
708
657
avdtp_error_type_t avdtp_error_type(struct avdtp_error *err)
709
uint8_t avdtp_error_category(struct avdtp_error *err)
658
710
{
659
return err->type;
711
return err->category;
660
712
}
661
713
662
714
int avdtp_error_error_code(struct avdtp_error *err)
663
715
{
664
assert(err->type == AVDTP_ERROR_ERROR_CODE);
716
assert(err->category != AVDTP_ERRNO);
665
717
return err->err.error_code;
666
718
}
667
719
668
720
int avdtp_error_posix_errno(struct avdtp_error *err)
669
721
{
670
assert(err->type == AVDTP_ERROR_ERRNO);
722
assert(err->category == AVDTP_ERRNO);
671
723
return err->err.posix_errno;
672
724
}
673
725
711
763
session->state = new_state;
712
764
713
765
avdtp_get_peers(session, &src, &dst);
714
dev = manager_get_device(&src, &dst);
766
dev = manager_get_device(&src, &dst, FALSE);
715
767
if (dev == NULL) {
716
768
error("avdtp_set_state(): no matching audio device");
717
769
return;
738
790
g_source_remove(stream->timer);
739
791
740
792
if (stream->io)
741
g_io_channel_unref(stream->io);
793
close_stream(stream);
742
794
743
795
if (stream->io_id)
744
796
g_source_remove(stream->io_id);
757
809
struct avdtp_stream *stream = user_data;
758
810
struct avdtp *session = stream->session;
759
811
760
avdtp_close(session, stream);
812
if (avdtp_close(session, stream, FALSE) < 0)
813
error("stream_timeout: closing AVDTP stream failed");
761
814
762
815
stream->idle_timer = 0;
763
816
775
828
sep->user_data);
776
829
777
830
if (!(cond & G_IO_NVAL))
778
g_io_channel_shutdown(stream->io, FALSE, NULL);
779
780
avdtp_sep_set_state(stream->session, sep, AVDTP_STATE_IDLE);
831
close_stream(stream);
832
833
stream->io_id = 0;
834
835
if (!stream->abort_int)
836
avdtp_sep_set_state(stream->session, sep, AVDTP_STATE_IDLE);
781
837
782
838
return FALSE;
783
839
}
798
854
if (io == NULL) {
799
855
if (!stream->open_acp && sep->cfm && sep->cfm->open) {
800
856
struct avdtp_error err;
801
avdtp_error_init(&err, AVDTP_ERROR_ERRNO, EIO);
857
avdtp_error_init(&err, AVDTP_ERRNO, EIO);
802
858
sep->cfm->open(session, sep, NULL, &err,
803
859
sep->user_data);
804
860
}
849
905
}
850
906
}
851
907
908
static void handle_unanswered_req(struct avdtp *session,
909
struct avdtp_stream *stream)
910
{
911
struct pending_req *req;
912
struct avdtp_local_sep *lsep;
913
struct avdtp_error err;
914
915
if (session->req->signal_id == AVDTP_ABORT) {
916
/* Avoid freeing the Abort request here */
917
DBG("handle_unanswered_req: Abort req, returning");
918
session->req->stream = NULL;
919
return;
920
}
921
922
req = session->req;
923
session->req = NULL;
924
925
avdtp_error_init(&err, AVDTP_ERRNO, EIO);
926
927
lsep = stream->lsep;
928
929
switch (req->signal_id) {
930
case AVDTP_RECONFIGURE:
931
error("No reply to Reconfigure request");
932
if (lsep && lsep->cfm && lsep->cfm->reconfigure)
933
lsep->cfm->reconfigure(session, lsep, stream, &err,
934
lsep->user_data);
935
break;
936
case AVDTP_OPEN:
937
error("No reply to Open request");
938
if (lsep && lsep->cfm && lsep->cfm->open)
939
lsep->cfm->open(session, lsep, stream, &err,
940
lsep->user_data);
941
break;
942
case AVDTP_START:
943
error("No reply to Start request");
944
if (lsep && lsep->cfm && lsep->cfm->start)
945
lsep->cfm->start(session, lsep, stream, &err,
946
lsep->user_data);
947
break;
948
case AVDTP_SUSPEND:
949
error("No reply to Suspend request");
950
if (lsep && lsep->cfm && lsep->cfm->suspend)
951
lsep->cfm->suspend(session, lsep, stream, &err,
952
lsep->user_data);
953
break;
954
case AVDTP_CLOSE:
955
error("No reply to Close request");
956
if (lsep && lsep->cfm && lsep->cfm->close)
957
lsep->cfm->close(session, lsep, stream, &err,
958
lsep->user_data);
959
break;
960
case AVDTP_SET_CONFIGURATION:
961
error("No reply to SetConfiguration request");
962
if (lsep && lsep->cfm && lsep->cfm->set_configuration)
963
lsep->cfm->set_configuration(session, lsep, stream,
964
&err, lsep->user_data);
965
}
966
967
pending_req_free(req);
968
}
969
852
970
static void avdtp_sep_set_state(struct avdtp *session,
853
971
struct avdtp_local_sep *sep,
854
972
avdtp_state_t state)
856
974
struct avdtp_stream *stream = sep->stream;
857
975
avdtp_state_t old_state;
858
976
struct avdtp_error err, *err_ptr = NULL;
977
GSList *l;
978
979
if (!stream) {
980
error("Error changing sep state: stream not available");
981
return;
982
}
859
983
860
984
if (sep->state == state) {
861
avdtp_error_init(&err, AVDTP_ERROR_ERRNO, EIO);
862
debug("stream state change failed: %s", avdtp_strerror(&err));
985
avdtp_error_init(&err, AVDTP_ERRNO, EIO);
986
DBG("stream state change failed: %s", avdtp_strerror(&err));
863
987
err_ptr = &err;
864
988
} else {
865
989
err_ptr = NULL;
866
debug("stream state changed: %s -> %s",
990
DBG("stream state changed: %s -> %s",
867
991
avdtp_statestr(sep->state),
868
992
avdtp_statestr(state));
869
993
}
871
995
old_state = sep->state;
872
996
sep->state = state;
873
997
874
if (stream) {
875
GSList *l;
876
for (l = stream->callbacks; l != NULL; l = g_slist_next(l)) {
877
struct stream_callback *cb = l->data;
878
cb->cb(stream, old_state, state, err_ptr,
879
cb->user_data);
880
}
998
for (l = stream->callbacks; l != NULL; l = g_slist_next(l)) {
999
struct stream_callback *cb = l->data;
1000
cb->cb(stream, old_state, state, err_ptr, cb->user_data);
881
1001
}
882
1002
883
1003
switch (state) {
1004
case AVDTP_STATE_CONFIGURED:
1005
if (sep->info.type == AVDTP_SEP_TYPE_SINK)
1006
avdtp_delay_report(session, stream, stream->delay);
1007
break;
884
1008
case AVDTP_STATE_OPEN:
885
1009
if (old_state > AVDTP_STATE_OPEN && session->auto_dc)
886
1010
stream->idle_timer = g_timeout_add_seconds(STREAM_TIMEOUT,
904
1028
if (session->pending_open == stream)
905
1029
handle_transport_connect(session, NULL, 0, 0);
906
1030
if (session->req && session->req->stream == stream)
907
session->req->stream = NULL;
1031
handle_unanswered_req(session, stream);
908
1032
/* Remove pending commands for this stream from the queue */
909
1033
cleanup_queue(session, stream);
910
1034
stream_free(stream);
911
if (session->ref == 1 && !session->streams)
912
set_disconnect_timer(session);
913
1035
break;
914
1036
default:
915
1037
break;
920
1042
{
921
1043
struct avdtp_error avdtp_err;
922
1044
923
avdtp_error_init(&avdtp_err, AVDTP_ERROR_ERRNO, err);
1045
avdtp_error_init(&avdtp_err, AVDTP_ERRNO, err);
924
1046
925
1047
if (!session->discov_cb)
926
1048
return;
937
1059
{
938
1060
struct avdtp_local_sep *sep = stream->lsep;
939
1061
940
if (sep->cfm && sep->cfm->abort)
1062
if (sep->cfm && sep->cfm->abort &&
1063
(sep->state != AVDTP_STATE_ABORTING ||
1064
stream->abort_int))
941
1065
sep->cfm->abort(session, sep, stream, NULL, sep->user_data);
942
1066
943
1067
avdtp_sep_set_state(session, sep, AVDTP_STATE_IDLE);
946
1070
static void connection_lost(struct avdtp *session, int err)
947
1071
{
948
1072
char address[18];
1073
struct audio_device *dev;
949
1074
950
1075
ba2str(&session->dst, address);
951
debug("Disconnected from %s", address);
952
953
if (session->state == AVDTP_SESSION_STATE_CONNECTING && err != EACCES)
954
btd_cancel_authorization(&session->server->src, &session->dst);
1076
DBG("Disconnected from %s", address);
1077
1078
dev = manager_get_device(&session->server->src, &session->dst, FALSE);
1079
1080
if (dev != NULL && session->state == AVDTP_SESSION_STATE_CONNECTING &&
1081
err != EACCES)
1082
audio_device_cancel_authorization(dev, auth_cb, session);
955
1083
956
1084
session->free_lock = 1;
957
1085
975
1103
session->io_id = 0;
976
1104
}
977
1105
1106
if (session->dc_timer)
1107
remove_disconnect_timer(session);
1108
1109
session->auto_dc = TRUE;
1110
978
1111
if (session->ref != 1)
979
1112
error("connection_lost: ref count not 1 after all callbacks");
980
1113
else
983
1116
984
1117
void avdtp_unref(struct avdtp *session)
985
1118
{
1119
struct avdtp_server *server;
1120
986
1121
if (!session)
987
1122
return;
988
1123
989
if (!g_slist_find(sessions, session)) {
990
error("avdtp_unref: trying to unref a unknown session");
991
return;
992
}
993
994
1124
session->ref--;
995
1125
996
debug("avdtp_unref(%p): ref=%d", session, session->ref);
1126
DBG("%p: ref=%d", session, session->ref);
997
1127
998
1128
if (session->ref == 1) {
999
1129
if (session->state == AVDTP_SESSION_STATE_CONNECTING &&
1000
1130
session->io) {
1131
struct audio_device *dev;
1132
dev = manager_get_device(&session->server->src,
1133
&session->dst, FALSE);
1134
audio_device_cancel_authorization(dev, auth_cb,
1135
session);
1001
1136
g_io_channel_shutdown(session->io, TRUE, NULL);
1002
1137
g_io_channel_unref(session->io);
1003
1138
session->io = NULL;
1139
avdtp_set_state(session,
1140
AVDTP_SESSION_STATE_DISCONNECTED);
1004
1141
}
1005
1142
1006
1143
if (session->io)
1013
1150
if (session->ref > 0)
1014
1151
return;
1015
1152
1016
debug("avdtp_unref(%p): freeing session and removing from list",
1017
session);
1153
server = session->server;
1154
1155
DBG("%p: freeing session and removing from list", session);
1018
1156
1019
1157
if (session->dc_timer)
1020
1158
remove_disconnect_timer(session);
1021
1159
1022
sessions = g_slist_remove(sessions, session);
1160
server->sessions = g_slist_remove(server->sessions, session);
1023
1161
1024
1162
if (session->req)
1025
1163
pending_req_free(session->req);
1035
1173
struct avdtp *avdtp_ref(struct avdtp *session)
1036
1174
{
1037
1175
session->ref++;
1038
debug("avdtp_ref(%p): ref=%d", session, session->ref);
1176
DBG("%p: ref=%d", session, session->ref);
1039
1177
if (session->dc_timer)
1040
1178
remove_disconnect_timer(session);
1041
1179
return session;
1056
1194
return NULL;
1057
1195
}
1058
1196
1059
static struct avdtp_local_sep *find_local_sep(struct avdtp_server *server,
1060
uint8_t type,
1061
uint8_t media_type,
1062
uint8_t codec)
1197
struct avdtp_remote_sep *avdtp_find_remote_sep(struct avdtp *session,
1198
struct avdtp_local_sep *lsep)
1063
1199
{
1064
1200
GSList *l;
1065
1201
1066
for (l = server->seps; l != NULL; l = g_slist_next(l)) {
1067
struct avdtp_local_sep *sep = l->data;
1068
1069
if (sep->info.inuse)
1070
continue;
1071
1072
if (sep->info.type == type &&
1073
sep->info.media_type == media_type &&
1074
sep->codec == codec)
1202
if (lsep->info.inuse)
1203
return NULL;
1204
1205
for (l = session->seps; l != NULL; l = g_slist_next(l)) {
1206
struct avdtp_remote_sep *sep = l->data;
1207
struct avdtp_service_capability *cap;
1208
struct avdtp_media_codec_capability *codec_data;
1209
1210
/* Type must be different: source <-> sink */
1211
if (sep->type == lsep->info.type)
1212
continue;
1213
1214
if (sep->media_type != lsep->info.media_type)
1215
continue;
1216
1217
if (!sep->codec)
1218
continue;
1219
1220
cap = sep->codec;
1221
codec_data = (void *) cap->data;
1222
1223
if (codec_data->media_codec_type != lsep->codec)
1224
continue;
1225
1226
if (sep->stream == NULL)
1075
1227
return sep;
1076
1228
}
1077
1229
1079
1231
}
1080
1232
1081
1233
static GSList *caps_to_list(uint8_t *data, int size,
1082
struct avdtp_service_capability **codec)
1234
struct avdtp_service_capability **codec,
1235
gboolean *delay_reporting)
1083
1236
{
1084
1237
GSList *caps;
1085
1238
int processed;
1086
1239
1087
for (processed = 0, caps = NULL; processed + 2 < size;) {
1240
if (delay_reporting)
1241
*delay_reporting = FALSE;
1242
1243
for (processed = 0, caps = NULL; processed + 2 <= size;) {
1088
1244
struct avdtp_service_capability *cap;
1089
1245
uint8_t length, category;
1090
1246
1109
1265
length >=
1110
1266
sizeof(struct avdtp_media_codec_capability))
1111
1267
*codec = cap;
1268
else if (category == AVDTP_DELAY_REPORTING && delay_reporting)
1269
*delay_reporting = TRUE;
1112
1270
}
1113
1271
1114
1272
return caps;
1115
1273
}
1116
1274
1117
1275
static gboolean avdtp_unknown_cmd(struct avdtp *session, uint8_t transaction,
1118
void *buf, int size)
1276
uint8_t signal_id)
1119
1277
{
1120
return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
1121
0, NULL, 0);
1278
return avdtp_send(session, transaction, AVDTP_MSG_TYPE_GEN_REJECT,
1279
signal_id, NULL, 0);
1122
1280
}
1123
1281
1124
1282
static gboolean avdtp_discover_cmd(struct avdtp *session, uint8_t transaction,
1130
1288
gboolean ret;
1131
1289
1132
1290
sep_count = g_slist_length(session->server->seps);
1291
1292
if (sep_count == 0) {
1293
uint8_t err = AVDTP_NOT_SUPPORTED_COMMAND;
1294
return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
1295
AVDTP_DISCOVER, &err, sizeof(err));
1296
}
1297
1133
1298
rsp_size = sep_count * sizeof(struct seid_info);
1134
1299
1135
1300
seps = g_new0(struct seid_info, sep_count);
1148
1313
}
1149
1314
1150
1315
static gboolean avdtp_getcap_cmd(struct avdtp *session, uint8_t transaction,
1151
struct seid_req *req, unsigned int size)
1316
struct seid_req *req, unsigned int size,
1317
gboolean get_all)
1152
1318
{
1153
1319
GSList *l, *caps;
1154
1320
struct avdtp_local_sep *sep = NULL;
1155
1321
unsigned int rsp_size;
1156
1322
uint8_t err, buf[1024], *ptr = buf;
1323
uint8_t cmd;
1324
1325
cmd = get_all ? AVDTP_GET_ALL_CAPABILITIES : AVDTP_GET_CAPABILITIES;
1157
1326
1158
1327
if (size < sizeof(struct seid_req)) {
1159
1328
err = AVDTP_BAD_LENGTH;
1166
1335
goto failed;
1167
1336
}
1168
1337
1169
if (!sep->ind->get_capability(session, sep, &caps, &err,
1170
sep->user_data))
1338
if (get_all && session->server->version < 0x0103)
1339
return avdtp_unknown_cmd(session, transaction, cmd);
1340
1341
if (!sep->ind->get_capability(session, sep, get_all, &caps,
1342
&err, sep->user_data))
1171
1343
goto failed;
1172
1344
1173
1345
for (l = caps, rsp_size = 0; l != NULL; l = g_slist_next(l)) {
1185
1357
1186
1358
g_slist_free(caps);
1187
1359
1188
return avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
1189
AVDTP_GET_CAPABILITIES, buf, rsp_size);
1360
return avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT, cmd,
1361
buf, rsp_size);
1190
1362
1191
1363
failed:
1192
return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
1193
AVDTP_GET_CAPABILITIES, &err, sizeof(err));
1364
return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT, cmd,
1365
&err, sizeof(err));
1366
}
1367
1368
static void setconf_cb(struct avdtp *session, struct avdtp_stream *stream,
1369
struct avdtp_error *err)
1370
{
1371
struct conf_rej rej;
1372
struct avdtp_local_sep *sep;
1373
1374
if (err != NULL) {
1375
rej.error = AVDTP_UNSUPPORTED_CONFIGURATION;
1376
rej.category = err->err.error_code;
1377
avdtp_send(session, session->in.transaction,
1378
AVDTP_MSG_TYPE_REJECT, AVDTP_SET_CONFIGURATION,
1379
&rej, sizeof(rej));
1380
return;
1381
}
1382
1383
if (!avdtp_send(session, session->in.transaction, AVDTP_MSG_TYPE_ACCEPT,
1384
AVDTP_SET_CONFIGURATION, NULL, 0)) {
1385
stream_free(stream);
1386
return;
1387
}
1388
1389
sep = stream->lsep;
1390
sep->stream = stream;
1391
sep->info.inuse = 1;
1392
session->streams = g_slist_append(session->streams, stream);
1393
1394
avdtp_sep_set_state(session, sep, AVDTP_STATE_CONFIGURED);
1194
1395
}
1195
1396
1196
1397
static gboolean avdtp_setconf_cmd(struct avdtp *session, uint8_t transaction,
1221
1422
}
1222
1423
1223
1424
avdtp_get_peers(session, &src, &dst);
1224
dev = manager_get_device(&src, &dst);
1425
dev = manager_get_device(&src, &dst, FALSE);
1225
1426
if (!dev) {
1226
1427
error("Unable to get a audio device object");
1428
err = AVDTP_BAD_STATE;
1227
1429
goto failed;
1228
1430
}
1229
1431
1233
1435
btd_device_add_uuid(dev->btd_dev, A2DP_SINK_UUID);
1234
1436
if (!dev->sink) {
1235
1437
error("Unable to get a audio sink object");
1438
err = AVDTP_BAD_STATE;
1236
1439
goto failed;
1237
1440
}
1238
1441
}
1239
1442
break;
1240
1443
case AVDTP_SEP_TYPE_SINK:
1241
/* Do source_init() here when it's implemented */
1444
if (!dev->source) {
1445
btd_device_add_uuid(dev->btd_dev, A2DP_SOURCE_UUID);
1446
if (!dev->sink) {
1447
error("Unable to get a audio source object");
1448
err = AVDTP_BAD_STATE;
1449
goto failed;
1450
}
1451
}
1242
1452
break;
1243
1453
}
1244
1454
1248
1458
stream->rseid = req->int_seid;
1249
1459
stream->caps = caps_to_list(req->caps,
1250
1460
size - sizeof(struct setconf_req),
1251
&stream->codec);
1461
&stream->codec,
1462
&stream->delay_reporting);
1252
1463
1253
1464
/* Verify that the Media Transport capability's length = 0. Reject otherwise */
1254
1465
for (l = stream->caps; l != NULL; l = g_slist_next(l)) {
1256
1467
1257
1468
if (cap->category == AVDTP_MEDIA_TRANSPORT && cap->length != 0) {
1258
1469
err = AVDTP_BAD_MEDIA_TRANSPORT_FORMAT;
1259
goto failed;
1470
goto failed_stream;
1260
1471
}
1261
1472
}
1262
1473
1474
if (stream->delay_reporting && session->version < 0x0103)
1475
session->version = 0x0103;
1476
1263
1477
if (sep->ind && sep->ind->set_configuration) {
1264
1478
if (!sep->ind->set_configuration(session, sep, stream,
1265
stream->caps, &err,
1266
&category,
1479
stream->caps,
1480
setconf_cb,
1267
1481
sep->user_data)) {
1482
err = AVDTP_UNSUPPORTED_CONFIGURATION;
1483
category = 0x00;
1484
goto failed_stream;
1485
}
1486
} else {
1487
if (!avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
1488
AVDTP_SET_CONFIGURATION, NULL, 0)) {
1268
1489
stream_free(stream);
1269
goto failed;
1490
return FALSE;
1270
1491
}
1271
}
1272
1273
if (!avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
1274
AVDTP_SET_CONFIGURATION, NULL, 0)) {
1275
stream_free(stream);
1276
return FALSE;
1277
}
1278
1279
sep->stream = stream;
1280
session->streams = g_slist_append(session->streams, stream);
1281
1282
avdtp_sep_set_state(session, sep, AVDTP_STATE_CONFIGURED);
1492
1493
sep->stream = stream;
1494
sep->info.inuse = 1;
1495
session->streams = g_slist_append(session->streams, stream);
1496
1497
avdtp_sep_set_state(session, sep, AVDTP_STATE_CONFIGURED);
1498
}
1283
1499
1284
1500
return TRUE;
1285
1501
1502
failed_stream:
1503
stream_free(stream);
1286
1504
failed:
1287
1505
rej.error = err;
1288
1506
rej.category = category;
1339
1557
static gboolean avdtp_reconf_cmd(struct avdtp *session, uint8_t transaction,
1340
1558
struct seid_req *req, int size)
1341
1559
{
1342
return avdtp_unknown_cmd(session, transaction, (void *) req, size);
1560
return avdtp_unknown_cmd(session, transaction, AVDTP_RECONFIGURE);
1343
1561
}
1344
1562
1345
1563
static gboolean avdtp_open_cmd(struct avdtp *session, uint8_t transaction,
1590
1808
static gboolean avdtp_secctl_cmd(struct avdtp *session, uint8_t transaction,
1591
1809
struct seid_req *req, int size)
1592
1810
{
1593
return avdtp_unknown_cmd(session, transaction, (void *) req, size);
1811
return avdtp_unknown_cmd(session, transaction, AVDTP_SECURITY_CONTROL);
1812
}
1813
1814
static gboolean avdtp_delayreport_cmd(struct avdtp *session,
1815
uint8_t transaction,
1816
struct delay_req *req,
1817
unsigned int size)
1818
{
1819
struct avdtp_local_sep *sep;
1820
struct avdtp_stream *stream;
1821
uint8_t err;
1822
1823
if (size < sizeof(struct delay_req)) {
1824
error("Too short delay report request");
1825
return FALSE;
1826
}
1827
1828
sep = find_local_sep_by_seid(session->server, req->acp_seid);
1829
if (!sep || !sep->stream) {
1830
err = AVDTP_BAD_ACP_SEID;
1831
goto failed;
1832
}
1833
1834
stream = sep->stream;
1835
1836
if (sep->state != AVDTP_STATE_CONFIGURED &&
1837
sep->state != AVDTP_STATE_STREAMING) {
1838
err = AVDTP_BAD_STATE;
1839
goto failed;
1840
}
1841
1842
stream->delay = ntohs(req->delay);
1843
1844
if (sep->ind && sep->ind->delayreport) {
1845
if (!sep->ind->delayreport(session, sep, stream->rseid,
1846
stream->delay, &err,
1847
sep->user_data))
1848
goto failed;
1849
}
1850
1851
return avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
1852
AVDTP_DELAY_REPORT, NULL, 0);
1853
1854
failed:
1855
return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
1856
AVDTP_DELAY_REPORT, &err, sizeof(err));
1594
1857
}
1595
1858
1596
1859
static gboolean avdtp_parse_cmd(struct avdtp *session, uint8_t transaction,
1598
1861
{
1599
1862
switch (signal_id) {
1600
1863
case AVDTP_DISCOVER:
1601
debug("Received DISCOVER_CMD");
1864
DBG("Received DISCOVER_CMD");
1602
1865
return avdtp_discover_cmd(session, transaction, buf, size);
1603
1866
case AVDTP_GET_CAPABILITIES:
1604
debug("Received GET_CAPABILITIES_CMD");
1605
return avdtp_getcap_cmd(session, transaction, buf, size);
1867
DBG("Received GET_CAPABILITIES_CMD");
1868
return avdtp_getcap_cmd(session, transaction, buf, size,
1869
FALSE);
1870
case AVDTP_GET_ALL_CAPABILITIES:
1871
DBG("Received GET_ALL_CAPABILITIES_CMD");
1872
return avdtp_getcap_cmd(session, transaction, buf, size, TRUE);
1606
1873
case AVDTP_SET_CONFIGURATION:
1607
debug("Received SET_CONFIGURATION_CMD");
1874
DBG("Received SET_CONFIGURATION_CMD");
1608
1875
return avdtp_setconf_cmd(session, transaction, buf, size);
1609
1876
case AVDTP_GET_CONFIGURATION:
1610
debug("Received GET_CONFIGURATION_CMD");
1877
DBG("Received GET_CONFIGURATION_CMD");
1611
1878
return avdtp_getconf_cmd(session, transaction, buf, size);
1612
1879
case AVDTP_RECONFIGURE:
1613
debug("Received RECONFIGURE_CMD");
1880
DBG("Received RECONFIGURE_CMD");
1614
1881
return avdtp_reconf_cmd(session, transaction, buf, size);
1615
1882
case AVDTP_OPEN:
1616
debug("Received OPEN_CMD");
1883
DBG("Received OPEN_CMD");
1617
1884
return avdtp_open_cmd(session, transaction, buf, size);
1618
1885
case AVDTP_START:
1619
debug("Received START_CMD");
1886
DBG("Received START_CMD");
1620
1887
return avdtp_start_cmd(session, transaction, buf, size);
1621
1888
case AVDTP_CLOSE:
1622
debug("Received CLOSE_CMD");
1889
DBG("Received CLOSE_CMD");
1623
1890
return avdtp_close_cmd(session, transaction, buf, size);
1624
1891
case AVDTP_SUSPEND:
1625
debug("Received SUSPEND_CMD");
1892
DBG("Received SUSPEND_CMD");
1626
1893
return avdtp_suspend_cmd(session, transaction, buf, size);
1627
1894
case AVDTP_ABORT:
1628
debug("Received ABORT_CMD");
1895
DBG("Received ABORT_CMD");
1629
1896
return avdtp_abort_cmd(session, transaction, buf, size);
1630
1897
case AVDTP_SECURITY_CONTROL:
1631
debug("Received SECURITY_CONTROL_CMD");
1898
DBG("Received SECURITY_CONTROL_CMD");
1632
1899
return avdtp_secctl_cmd(session, transaction, buf, size);
1900
case AVDTP_DELAY_REPORT:
1901
DBG("Received DELAY_REPORT_CMD");
1902
return avdtp_delayreport_cmd(session, transaction, buf, size);
1633
1903
default:
1634
debug("Received unknown request id %u", signal_id);
1635
return avdtp_unknown_cmd(session, transaction, buf, size);
1904
DBG("Received unknown request id %u", signal_id);
1905
return avdtp_unknown_cmd(session, transaction, signal_id);
1636
1906
}
1637
1907
}
1638
1908
1650
1920
switch (header->packet_type) {
1651
1921
case AVDTP_PKT_TYPE_SINGLE:
1652
1922
if (size < sizeof(*single)) {
1653
error("Received too small single packet (%d bytes)", size);
1923
error("Received too small single packet (%zu bytes)", size);
1654
1924
return PARSE_ERROR;
1655
1925
}
1656
1926
if (session->in.active) {
1671
1941
break;
1672
1942
case AVDTP_PKT_TYPE_START:
1673
1943
if (size < sizeof(*start)) {
1674
error("Received too small start packet (%d bytes)", size);
1944
error("Received too small start packet (%zu bytes)", size);
1675
1945
return PARSE_ERROR;
1676
1946
}
1677
1947
if (session->in.active) {
1692
1962
break;
1693
1963
case AVDTP_PKT_TYPE_CONTINUE:
1694
1964
if (size < sizeof(struct avdtp_continue_header)) {
1695
error("Received too small continue packet (%d bytes)",
1965
error("Received too small continue packet (%zu bytes)",
1696
1966
size);
1697
1967
return PARSE_ERROR;
1698
1968
}
1715
1985
break;
1716
1986
case AVDTP_PKT_TYPE_END:
1717
1987
if (size < sizeof(struct avdtp_continue_header)) {
1718
error("Received too small end packet (%d bytes)", size);
1988
error("Received too small end packet (%zu bytes)", size);
1719
1989
return PARSE_ERROR;
1720
1990
}
1721
1991
if (!session->in.active) {
1751
2021
1752
2022
if (session->in.no_of_packets > 1) {
1753
2023
session->in.no_of_packets--;
1754
debug("Received AVDTP fragment. %d to go",
2024
DBG("Received AVDTP fragment. %d to go",
1755
2025
session->in.no_of_packets);
1756
2026
return PARSE_FRAGMENT;
1757
2027
}
1768
2038
struct avdtp_common_header *header;
1769
2039
gsize size;
1770
2040
1771
debug("session_cb");
2041
DBG("");
1772
2042
1773
2043
if (cond & G_IO_NVAL)
1774
2044
return FALSE;
1785
2055
}
1786
2056
1787
2057
if (size < sizeof(struct avdtp_common_header)) {
1788
error("Received too small packet (%d bytes)", size);
2058
error("Received too small packet (%zu bytes)", size);
1789
2059
goto failed;
1790
2060
}
1791
2061
1807
2077
goto failed;
1808
2078
}
1809
2079
1810
if (session->ref == 1 && !session->streams)
2080
if (session->ref == 1 && !session->streams && !session->req)
1811
2081
set_disconnect_timer(session);
1812
2082
1813
2083
if (session->streams && session->dc_timer)
1855
2125
goto failed;
1856
2126
}
1857
2127
break;
2128
case AVDTP_MSG_TYPE_GEN_REJECT:
2129
error("Received a General Reject message");
2130
break;
1858
2131
default:
1859
2132
error("Unknown message type 0x%02X", header->message_type);
1860
2133
break;
1873
2146
return FALSE;
1874
2147
}
1875
2148
1876
static struct avdtp *find_session(const bdaddr_t *src, const bdaddr_t *dst)
2149
static struct avdtp *find_session(GSList *list, const bdaddr_t *dst)
1877
2150
{
1878
2151
GSList *l;
1879
2152
1880
for (l = sessions; l != NULL; l = g_slist_next(l)) {
2153
for (l = list; l != NULL; l = g_slist_next(l)) {
1881
2154
struct avdtp *s = l->data;
1882
2155
1883
if (bacmp(src, &s->server->src) || bacmp(dst, &s->dst))
2156
if (bacmp(dst, &s->dst))
1884
2157
continue;
1885
2158
1886
2159
return s;
1889
2162
return NULL;
1890
2163
}
1891
2164
2165
static uint16_t get_version(struct avdtp *session)
2166
{
2167
struct btd_adapter *adapter;
2168
struct btd_device *device;
2169
const sdp_record_t *rec;
2170
sdp_list_t *protos;
2171
sdp_data_t *proto_desc;
2172
char addr[18];
2173
uint16_t ver = 0x0100;
2174
2175
adapter = manager_find_adapter(&session->server->src);
2176
if (!adapter)
2177
goto done;
2178
2179
ba2str(&session->dst, addr);
2180
device = adapter_find_device(adapter, addr);
2181
if (!device)
2182
goto done;
2183
2184
rec = btd_device_get_record(device, A2DP_SINK_UUID);
2185
if (!rec)
2186
rec = btd_device_get_record(device, A2DP_SOURCE_UUID);
2187
2188
if (!rec)
2189
goto done;
2190
2191
if (sdp_get_access_protos(rec, &protos) < 0)
2192
goto done;
2193
2194
proto_desc = sdp_get_proto_desc(protos, AVDTP_UUID);
2195
if (proto_desc && proto_desc->dtd == SDP_UINT16)
2196
ver = proto_desc->val.uint16;
2197
2198
sdp_list_foreach(protos, (sdp_list_func_t) sdp_list_free, NULL);
2199
sdp_list_free(protos, NULL);
2200
2201
done:
2202
return ver;
2203
}
2204
1892
2205
static struct avdtp *avdtp_get_internal(const bdaddr_t *src, const bdaddr_t *dst)
1893
2206
{
2207
struct avdtp_server *server;
1894
2208
struct avdtp *session;
1895
2209
1896
2210
assert(src != NULL);
1897
2211
assert(dst != NULL);
1898
2212
1899
session = find_session(src, dst);
2213
server = find_server(servers, src);
2214
if (server == NULL)
2215
return NULL;
2216
2217
session = find_session(server->sessions, dst);
1900
2218
if (session) {
1901
2219
if (session->pending_auth)
1902
2220
return NULL;
1906
2224
1907
2225
session = g_new0(struct avdtp, 1);
1908
2226
1909
session->server = find_server(servers, src);
2227
session->server = server;
1910
2228
bacpy(&session->dst, dst);
1911
2229
session->ref = 1;
1912
2230
/* We don't use avdtp_set_state() here since this isn't a state change
1914
2232
session->state = AVDTP_SESSION_STATE_DISCONNECTED;
1915
2233
session->auto_dc = TRUE;
1916
2234
1917
sessions = g_slist_append(sessions, session);
2235
session->version = get_version(session);
2236
2237
server->sessions = g_slist_append(server->sessions, session);
1918
2238
1919
2239
return session;
1920
2240
}
1937
2257
char address[18];
1938
2258
GError *gerr = NULL;
1939
2259
1940
if (!g_slist_find(sessions, session)) {
1941
debug("avdtp_connect_cb: session got removed");
1942
return;
1943
}
1944
1945
2260
if (err) {
1946
2261
error("%s", err->message);
1947
2262
goto failed;
1961
2276
}
1962
2277
1963
2278
ba2str(&session->dst, address);
1964
debug("AVDTP: connected %s channel to %s",
2279
DBG("AVDTP: connected %s channel to %s",
1965
2280
session->pending_open ? "transport" : "signaling",
1966
2281
address);
1967
2282
1968
2283
if (session->state == AVDTP_SESSION_STATE_CONNECTING) {
1969
debug("AVDTP imtu=%u, omtu=%u", session->imtu, session->omtu);
2284
DBG("AVDTP imtu=%u, omtu=%u", session->imtu, session->omtu);
1970
2285
1971
2286
session->buf = g_malloc0(session->imtu);
1972
2287
avdtp_set_state(session, AVDTP_SESSION_STATE_CONNECTED);
2013
2328
AVDTP_STATE_IDLE);
2014
2329
} else
2015
2330
connection_lost(session, EIO);
2016
2017
return;
2018
2331
}
2019
2332
2020
2333
static void auth_cb(DBusError *derr, void *user_data)
2043
2356
2044
2357
static void avdtp_confirm_cb(GIOChannel *chan, gpointer data)
2045
2358
{
2046
int sk;
2047
2359
struct avdtp *session;
2048
2360
struct audio_device *dev;
2049
2361
char address[18];
2062
2374
goto drop;
2063
2375
}
2064
2376
2065
debug("AVDTP: incoming connect from %s", address);
2377
DBG("AVDTP: incoming connect from %s", address);
2066
2378
2067
2379
session = avdtp_get_internal(&src, &dst);
2380
if (!session)
2381
goto drop;
2068
2382
2069
sk = g_io_channel_unix_get_fd(chan);
2383
/* This state (ie, session is already *connecting*) happens when the
2384
* device initiates a connect (really a config'd L2CAP channel) even
2385
* though there is a connect we initiated in progress. In sink.c &
2386
* source.c, this state is referred to as XCASE connect:connect.
2387
* Abort the device's channel in favor of our own.
2388
*/
2389
if (session->state == AVDTP_SESSION_STATE_CONNECTING) {
2390
DBG("connect already in progress (XCASE connect:connect)");
2391
goto drop;
2392
}
2070
2393
2071
2394
if (session->pending_open && session->pending_open->open_acp) {
2072
2395
if (!bt_io_accept(chan, avdtp_connect_cb, session, NULL, NULL))
2079
2402
goto drop;
2080
2403
}
2081
2404
2082
dev = manager_get_device(&src, &dst);
2405
dev = manager_get_device(&src, &dst, FALSE);
2083
2406
if (!dev) {
2084
error("Unable to get audio device object for %s", address);
2085
goto drop;
2407
dev = manager_get_device(&src, &dst, TRUE);
2408
if (!dev) {
2409
error("Unable to get audio device object for %s",
2410
address);
2411
goto drop;
2412
}
2413
btd_device_add_uuid(dev->btd_dev, ADVANCED_AUDIO_UUID);
2086
2414
}
2087
2415
2088
2416
session->io = g_io_channel_ref(chan);
2090
2418
2091
2419
session->io_id = g_io_add_watch(chan, G_IO_ERR | G_IO_HUP | G_IO_NVAL,
2092
2420
(GIOFunc) session_cb, session);
2093
perr = btd_request_authorization(&src, &dst, ADVANCED_AUDIO_UUID,
2421
2422
perr = audio_device_request_authorization(dev, ADVANCED_AUDIO_UUID,
2094
2423
auth_cb, session);
2095
2424
if (perr < 0) {
2096
2425
avdtp_unref(session);
2105
2434
g_io_channel_shutdown(chan, TRUE, NULL);
2106
2435
}
2107
2436
2108
static int l2cap_connect(struct avdtp *session)
2437
static GIOChannel *l2cap_connect(struct avdtp *session)
2109
2438
{
2110
2439
GError *err = NULL;
2111
2440
GIOChannel *io;
2119
2448
if (!io) {
2120
2449
error("%s", err->message);
2121
2450
g_error_free(err);
2122
return -EIO;
2451
return NULL;
2123
2452
}
2124
2453
2125
g_io_channel_unref(io);
2126
2127
return 0;
2454
return io;
2128
2455
}
2129
2456
2130
2457
static void queue_request(struct avdtp *session, struct pending_req *req,
2136
2463
session->req_queue = g_slist_append(session->req_queue, req);
2137
2464
}
2138
2465
2139
static gboolean request_timeout(gpointer user_data)
2140
{
2141
struct avdtp *session = user_data;
2466
static uint8_t req_get_seid(struct pending_req *req)
2467
{
2468
if (req->signal_id == AVDTP_DISCOVER)
2469
return 0;
2470
2471
return ((struct seid_req *) (req->data))->acp_seid;
2472
}
2473
2474
static int cancel_request(struct avdtp *session, int err)
2475
{
2142
2476
struct pending_req *req;
2143
2477
struct seid_req sreq;
2144
2478
struct avdtp_local_sep *lsep;
2145
2479
struct avdtp_stream *stream;
2146
2480
uint8_t seid;
2147
struct avdtp_error err;
2481
struct avdtp_error averr;
2148
2482
2149
2483
req = session->req;
2150
2484
session->req = NULL;
2151
2485
2152
avdtp_error_init(&err, AVDTP_ERROR_ERRNO, ETIMEDOUT);
2153
2154
seid = ((struct seid_req *) (req->data))->acp_seid;
2155
2156
stream = find_stream_by_rseid(session, seid);
2157
2158
if (stream)
2486
avdtp_error_init(&averr, AVDTP_ERRNO, err);
2487
2488
seid = req_get_seid(req);
2489
if (seid)
2490
stream = find_stream_by_rseid(session, seid);
2491
else
2492
stream = NULL;
2493
2494
if (stream) {
2495
stream->abort_int = TRUE;
2159
2496
lsep = stream->lsep;
2160
else
2497
} else
2161
2498
lsep = NULL;
2162
2499
2163
2500
switch (req->signal_id) {
2164
2501
case AVDTP_RECONFIGURE:
2165
error("Reconfigure request timed out");
2502
error("Reconfigure: %s (%d)", strerror(err), err);
2166
2503
if (lsep && lsep->cfm && lsep->cfm->reconfigure)
2167
lsep->cfm->reconfigure(session, lsep, stream, &err,
2504
lsep->cfm->reconfigure(session, lsep, stream, &averr,
2168
2505
lsep->user_data);
2169
2506
break;
2170
2507
case AVDTP_OPEN:
2171
error("Open request timed out");
2508
error("Open: %s (%d)", strerror(err), err);
2172
2509
if (lsep && lsep->cfm && lsep->cfm->open)
2173
lsep->cfm->open(session, lsep, stream, &err,
2510
lsep->cfm->open(session, lsep, stream, &averr,
2174
2511
lsep->user_data);
2175
2512
break;
2176
2513
case AVDTP_START:
2177
error("Start request timed out");
2514
error("Start: %s (%d)", strerror(err), err);
2178
2515
if (lsep && lsep->cfm && lsep->cfm->start)
2179
lsep->cfm->start(session, lsep, stream, &err,
2516
lsep->cfm->start(session, lsep, stream, &averr,
2180
2517
lsep->user_data);
2181
2518
break;
2182
2519
case AVDTP_SUSPEND:
2183
error("Suspend request timed out");
2520
error("Suspend: %s (%d)", strerror(err), err);
2184
2521
if (lsep && lsep->cfm && lsep->cfm->suspend)
2185
lsep->cfm->suspend(session, lsep, stream, &err,
2522
lsep->cfm->suspend(session, lsep, stream, &averr,
2186
2523
lsep->user_data);
2187
2524
break;
2188
2525
case AVDTP_CLOSE:
2189
error("Close request timed out");
2190
if (lsep && lsep->cfm && lsep->cfm->close)
2191
lsep->cfm->close(session, lsep, stream, &err,
2526
error("Close: %s (%d)", strerror(err), err);
2527
if (lsep && lsep->cfm && lsep->cfm->close) {
2528
lsep->cfm->close(session, lsep, stream, &averr,
2192
2529
lsep->user_data);
2530
if (stream)
2531
stream->close_int = FALSE;
2532
}
2193
2533
break;
2194
2534
case AVDTP_SET_CONFIGURATION:
2195
error("SetConfiguration request timed out");
2535
error("SetConfiguration: %s (%d)", strerror(err), err);
2196
2536
if (lsep && lsep->cfm && lsep->cfm->set_configuration)
2197
2537
lsep->cfm->set_configuration(session, lsep, stream,
2198
&err, lsep->user_data);
2538
&averr, lsep->user_data);
2199
2539
goto failed;
2200
2540
case AVDTP_DISCOVER:
2201
error("Discover request timed out");
2541
error("Discover: %s (%d)", strerror(err), err);
2202
2542
goto failed;
2203
2543
case AVDTP_GET_CAPABILITIES:
2204
error("GetCapabilities request timed out");
2544
error("GetCapabilities: %s (%d)", strerror(err), err);
2205
2545
goto failed;
2206
2546
case AVDTP_ABORT:
2207
error("Abort request timed out");
2547
error("Abort: %s (%d)", strerror(err), err);
2208
2548
goto failed;
2209
2549
}
2210
2550
2551
if (!stream)
2552
goto failed;
2553
2211
2554
memset(&sreq, 0, sizeof(sreq));
2212
2555
sreq.acp_seid = seid;
2213
2556
2214
if (send_request(session, TRUE, stream, AVDTP_ABORT,
2215
&sreq, sizeof(sreq)) < 0) {
2557
err = send_request(session, TRUE, stream, AVDTP_ABORT, &sreq,
2558
sizeof(sreq));
2559
if (err < 0) {
2216
2560
error("Unable to send abort request");
2217
2561
goto failed;
2218
2562
}
2220
2564
goto done;
2221
2565
2222
2566
failed:
2223
connection_lost(session, ETIMEDOUT);
2567
connection_lost(session, err);
2224
2568
done:
2225
2569
pending_req_free(req);
2570
return err;
2571
}
2572
2573
static gboolean request_timeout(gpointer user_data)
2574
{
2575
struct avdtp *session = user_data;
2576
2577
cancel_request(session, ETIMEDOUT);
2578
2226
2579
return FALSE;
2227
2580
}
2228
2581
2233
2586
int err;
2234
2587
2235
2588
if (session->state == AVDTP_SESSION_STATE_DISCONNECTED) {
2236
err = l2cap_connect(session);
2237
if (err < 0)
2589
session->io = l2cap_connect(session);
2590
if (!session->io)
2238
2591
goto failed;
2239
2592
avdtp_set_state(session, AVDTP_SESSION_STATE_CONNECTING);
2240
2593
}
2259
2612
2260
2613
session->req = req;
2261
2614
2262
req->timeout = g_timeout_add_seconds(REQ_TIMEOUT,
2615
req->timeout = g_timeout_add_seconds(req->signal_id == AVDTP_ABORT ?
2616
ABORT_TIMEOUT : REQ_TIMEOUT,
2263
2617
request_timeout,
2264
2618
session);
2265
2619
return 0;
2276
2630
{
2277
2631
struct pending_req *req;
2278
2632
2633
if (stream && stream->abort_int && signal_id != AVDTP_ABORT) {
2634
DBG("Unable to send requests while aborting");
2635
return -EINVAL;
2636
}
2637
2279
2638
req = g_new0(struct pending_req, 1);
2280
2639
req->signal_id = signal_id;
2281
2640
req->data = g_malloc(size);
2290
2649
struct discover_resp *resp, int size)
2291
2650
{
2292
2651
int sep_count, i;
2652
uint8_t getcap_cmd;
2653
2654
if (session->version >= 0x0103 && session->server->version >= 0x0103)
2655
getcap_cmd = AVDTP_GET_ALL_CAPABILITIES;
2656
else
2657
getcap_cmd = AVDTP_GET_CAPABILITIES;
2293
2658
2294
2659
sep_count = size / sizeof(struct seid_info);
2295
2660
2299
2664
struct seid_req req;
2300
2665
int ret;
2301
2666
2302
debug("seid %d type %d media %d in use %d",
2667
DBG("seid %d type %d media %d in use %d",
2303
2668
resp->seps[i].seid, resp->seps[i].type,
2304
2669
resp->seps[i].media_type, resp->seps[i].inuse);
2305
2670
2321
2686
memset(&req, 0, sizeof(req));
2322
2687
req.acp_seid = sep->seid;
2323
2688
2324
ret = send_request(session, TRUE, NULL,
2325
AVDTP_GET_CAPABILITIES,
2326
&req, sizeof(req));
2689
ret = send_request(session, TRUE, NULL, getcap_cmd,
2690
&req, sizeof(req));
2327
2691
if (ret < 0) {
2328
2692
finalize_discovery(session, -ret);
2329
2693
break;
2356
2720
2357
2721
sep = find_remote_sep(session->seps, seid);
2358
2722
2359
debug("seid %d type %d media %d", sep->seid,
2723
DBG("seid %d type %d media %d", sep->seid,
2360
2724
sep->type, sep->media_type);
2361
2725
2362
2726
if (sep->caps) {
2364
2728
g_slist_free(sep->caps);
2365
2729
sep->caps = NULL;
2366
2730
sep->codec = NULL;
2731
sep->delay_reporting = FALSE;
2367
2732
}
2368
2733
2369
2734
sep->caps = caps_to_list(resp->caps, size - sizeof(struct getcap_resp),
2370
&sep->codec);
2735
&sep->codec, &sep->delay_reporting);
2371
2736
2372
2737
return TRUE;
2373
2738
}
2400
2765
{
2401
2766
struct avdtp_local_sep *sep = stream->lsep;
2402
2767
2403
if (l2cap_connect(session) < 0) {
2768
stream->io = l2cap_connect(session);
2769
if (!stream->io) {
2404
2770
avdtp_sep_set_state(session, sep, AVDTP_STATE_IDLE);
2405
2771
return FALSE;
2406
2772
}
2435
2801
2436
2802
avdtp_sep_set_state(session, sep, AVDTP_STATE_CLOSING);
2437
2803
2438
g_io_channel_shutdown(stream->io, TRUE, NULL);
2804
close_stream(stream);
2439
2805
2440
2806
return TRUE;
2441
2807
}
2460
2826
{
2461
2827
struct avdtp_local_sep *sep = stream->lsep;
2462
2828
2829
avdtp_sep_set_state(session, sep, AVDTP_STATE_ABORTING);
2830
2463
2831
if (sep->cfm && sep->cfm->abort)
2464
2832
sep->cfm->abort(session, sep, stream, NULL, sep->user_data);
2465
2833
2468
2836
return TRUE;
2469
2837
}
2470
2838
2839
static gboolean avdtp_delay_report_resp(struct avdtp *session,
2840
struct avdtp_stream *stream,
2841
void *data, int size)
2842
{
2843
struct avdtp_local_sep *sep = stream->lsep;
2844
2845
if (sep->cfm && sep->cfm->delay_report)
2846
sep->cfm->delay_report(session, sep, stream, NULL, sep->user_data);
2847
2848
return TRUE;
2849
}
2850
2471
2851
static gboolean avdtp_parse_resp(struct avdtp *session,
2472
2852
struct avdtp_stream *stream,
2473
2853
uint8_t transaction, uint8_t signal_id,
2474
2854
void *buf, int size)
2475
2855
{
2476
2856
struct pending_req *next;
2857
const char *get_all = "";
2477
2858
2478
2859
if (session->prio_queue)
2479
2860
next = session->prio_queue->data;
2484
2865
2485
2866
switch (signal_id) {
2486
2867
case AVDTP_DISCOVER:
2487
debug("DISCOVER request succeeded");
2868
DBG("DISCOVER request succeeded");
2488
2869
return avdtp_discover_resp(session, buf, size);
2870
case AVDTP_GET_ALL_CAPABILITIES:
2871
get_all = "ALL_";
2489
2872
case AVDTP_GET_CAPABILITIES:
2490
debug("GET_CAPABILITIES request succeeded");
2873
DBG("GET_%sCAPABILITIES request succeeded", get_all);
2491
2874
if (!avdtp_get_capabilities_resp(session, buf, size))
2492
2875
return FALSE;
2493
if (!(next && next->signal_id == AVDTP_GET_CAPABILITIES))
2876
if (!(next && (next->signal_id == AVDTP_GET_CAPABILITIES ||
2877
next->signal_id == AVDTP_GET_ALL_CAPABILITIES)))
2494
2878
finalize_discovery(session, 0);
2495
2879
return TRUE;
2880
}
2881
2882
/* The remaining commands require an existing stream so bail out
2883
* here if the stream got unexpectedly disconnected */
2884
if (!stream) {
2885
DBG("AVDTP: stream was closed while waiting for reply");
2886
return TRUE;
2887
}
2888
2889
switch (signal_id) {
2496
2890
case AVDTP_SET_CONFIGURATION:
2497
debug("SET_CONFIGURATION request succeeded");
2891
DBG("SET_CONFIGURATION request succeeded");
2498
2892
return avdtp_set_configuration_resp(session, stream,
2499
2893
buf, size);
2500
2894
case AVDTP_RECONFIGURE:
2501
debug("RECONFIGURE request succeeded");
2895
DBG("RECONFIGURE request succeeded");
2502
2896
return avdtp_reconfigure_resp(session, stream, buf, size);
2503
2897
case AVDTP_OPEN:
2504
debug("OPEN request succeeded");
2898
DBG("OPEN request succeeded");
2505
2899
return avdtp_open_resp(session, stream, buf, size);
2506
2900
case AVDTP_SUSPEND:
2507
debug("SUSPEND request succeeded");
2901
DBG("SUSPEND request succeeded");
2508
2902
return avdtp_suspend_resp(session, stream, buf, size);
2509
2903
case AVDTP_START:
2510
debug("START request succeeded");
2904
DBG("START request succeeded");
2511
2905
return avdtp_start_resp(session, stream, buf, size);
2512
2906
case AVDTP_CLOSE:
2513
debug("CLOSE request succeeded");
2907
DBG("CLOSE request succeeded");
2514
2908
return avdtp_close_resp(session, stream, buf, size);
2515
2909
case AVDTP_ABORT:
2516
debug("ABORT request succeeded");
2910
DBG("ABORT request succeeded");
2517
2911
return avdtp_abort_resp(session, stream, buf, size);
2912
case AVDTP_DELAY_REPORT:
2913
DBG("DELAY_REPORT request succeeded");
2914
return avdtp_delay_report_resp(session, stream, buf, size);
2518
2915
}
2519
2916
2520
2917
error("Unknown signal id in accept response: %u", signal_id);
2529
2926
return FALSE;
2530
2927
}
2531
2928
2532
avdtp_error_init(err, AVDTP_ERROR_ERROR_CODE, rej->error);
2929
avdtp_error_init(err, 0x00, rej->error);
2533
2930
2534
2931
return TRUE;
2535
2932
}
2536
2933
2537
2934
static gboolean conf_rej_to_err(struct conf_rej *rej, unsigned int size,
2538
struct avdtp_error *err, uint8_t *category)
2935
struct avdtp_error *err)
2539
2936
{
2540
2937
if (size < sizeof(struct conf_rej)) {
2541
2938
error("Too small packet for conf_rej");
2542
2939
return FALSE;
2543
2940
}
2544
2941
2545
avdtp_error_init(err, AVDTP_ERROR_ERROR_CODE, rej->error);
2546
2547
if (category)
2548
*category = rej->category;
2942
avdtp_error_init(err, rej->category, rej->error);
2549
2943
2550
2944
return TRUE;
2551
2945
}
2559
2953
return FALSE;
2560
2954
}
2561
2955
2562
avdtp_error_init(err, AVDTP_ERROR_ERROR_CODE, rej->error);
2956
avdtp_error_init(err, 0x00, rej->error);
2563
2957
2564
2958
if (acp_seid)
2565
2959
*acp_seid = rej->acp_seid;
2573
2967
void *buf, int size)
2574
2968
{
2575
2969
struct avdtp_error err;
2576
uint8_t acp_seid, category;
2970
uint8_t acp_seid;
2577
2971
struct avdtp_local_sep *sep = stream ? stream->lsep : NULL;
2578
2972
2579
2973
switch (signal_id) {
2584
2978
avdtp_strerror(&err), err.err.error_code);
2585
2979
return TRUE;
2586
2980
case AVDTP_GET_CAPABILITIES:
2981
case AVDTP_GET_ALL_CAPABILITIES:
2587
2982
if (!seid_rej_to_err(buf, size, &err))
2588
2983
return FALSE;
2589
2984
error("GET_CAPABILITIES request rejected: %s (%d)",
2599
2994
sep->user_data);
2600
2995
return TRUE;
2601
2996
case AVDTP_SET_CONFIGURATION:
2602
if (!conf_rej_to_err(buf, size, &err, &category))
2997
if (!conf_rej_to_err(buf, size, &err))
2603
2998
return FALSE;
2604
2999
error("SET_CONFIGURATION request rejected: %s (%d)",
2605
3000
avdtp_strerror(&err), err.err.error_code);
2608
3003
&err, sep->user_data);
2609
3004
return TRUE;
2610
3005
case AVDTP_RECONFIGURE:
2611
if (!conf_rej_to_err(buf, size, &err, &category))
3006
if (!conf_rej_to_err(buf, size, &err))
2612
3007
return FALSE;
2613
3008
error("RECONFIGURE request rejected: %s (%d)",
2614
3009
avdtp_strerror(&err), err.err.error_code);
2639
3034
return FALSE;
2640
3035
error("CLOSE request rejected: %s (%d)",
2641
3036
avdtp_strerror(&err), err.err.error_code);
2642
if (sep && sep->cfm && sep->cfm->close)
3037
if (sep && sep->cfm && sep->cfm->close) {
2643
3038
sep->cfm->close(session, sep, stream, &err,
2644
3039
sep->user_data);
3040
stream->close_int = FALSE;
3041
}
2645
3042
return TRUE;
2646
3043
case AVDTP_ABORT:
2647
3044
if (!stream_rej_to_err(buf, size, &err, &acp_seid))
2651
3048
if (sep && sep->cfm && sep->cfm->abort)
2652
3049
sep->cfm->abort(session, sep, stream, &err,
2653
3050
sep->user_data);
3051
return FALSE;
3052
case AVDTP_DELAY_REPORT:
3053
if (!stream_rej_to_err(buf, size, &err, &acp_seid))
3054
return FALSE;
3055
error("DELAY_REPORT request rejected: %s (%d)",
3056
avdtp_strerror(&err), err.err.error_code);
3057
if (sep && sep->cfm && sep->cfm->delay_report)
3058
sep->cfm->delay_report(session, sep, stream, &err,
3059
sep->user_data);
2654
3060
return TRUE;
2655
3061
default:
2656
3062
error("Unknown reject response signal id: %u", signal_id);
2660
3066
2661
3067
gboolean avdtp_is_connected(const bdaddr_t *src, const bdaddr_t *dst)
2662
3068
{
3069
struct avdtp_server *server;
2663
3070
struct avdtp *session;
2664
3071
2665
session = find_session(src, dst);
3072
server = find_server(servers, src);
3073
if (!server)
3074
return FALSE;
2666
3075
3076
session = find_session(server->sessions, dst);
2667
3077
if (!session)
2668
3078
return FALSE;
2669
3079
2799
3209
return sep->codec;
2800
3210
}
2801
3211
3212
gboolean avdtp_get_delay_reporting(struct avdtp_remote_sep *sep)
3213
{
3214
return sep->delay_reporting;
3215
}
3216
2802
3217
struct avdtp_stream *avdtp_get_stream(struct avdtp_remote_sep *sep)
2803
3218
{
2804
3219
return sep->stream;
2809
3224
{
2810
3225
struct avdtp_service_capability *cap;
2811
3226
2812
if (category < AVDTP_MEDIA_TRANSPORT || category > AVDTP_MEDIA_CODEC)
3227
if (category < AVDTP_MEDIA_TRANSPORT || category > AVDTP_DELAY_REPORTING)
2813
3228
return NULL;
2814
3229
2815
3230
cap = g_malloc(sizeof(struct avdtp_service_capability) + length);
2832
3247
int avdtp_discover(struct avdtp *session, avdtp_discover_cb_t cb,
2833
3248
void *user_data)
2834
3249
{
2835
int ret;
3250
int err;
2836
3251
2837
3252
if (session->discov_cb)
2838
3253
return -EBUSY;
2844
3259
return 0;
2845
3260
}
2846
3261
2847
ret = send_request(session, FALSE, NULL, AVDTP_DISCOVER, NULL, 0);
2848
if (ret == 0) {
3262
err = send_request(session, FALSE, NULL, AVDTP_DISCOVER, NULL, 0);
3263
if (err == 0) {
2849
3264
session->discov_cb = cb;
2850
3265
session->user_data = user_data;
2851
3266
}
2852
3267
2853
return ret;
2854
}
2855
2856
int avdtp_get_seps(struct avdtp *session, uint8_t acp_type, uint8_t media_type,
2857
uint8_t codec, struct avdtp_local_sep **lsep,
2858
struct avdtp_remote_sep **rsep)
2859
{
2860
GSList *l;
2861
uint8_t int_type;
2862
2863
int_type = acp_type == AVDTP_SEP_TYPE_SINK ?
2864
AVDTP_SEP_TYPE_SOURCE : AVDTP_SEP_TYPE_SINK;
2865
2866
*lsep = find_local_sep(session->server, int_type, media_type, codec);
2867
if (!*lsep)
2868
return -EINVAL;
2869
2870
for (l = session->seps; l != NULL; l = g_slist_next(l)) {
2871
struct avdtp_remote_sep *sep = l->data;
2872
struct avdtp_service_capability *cap;
2873
struct avdtp_media_codec_capability *codec_data;
2874
2875
if (sep->type != acp_type)
2876
continue;
2877
2878
if (sep->media_type != media_type)
2879
continue;
2880
2881
if (!sep->codec)
2882
continue;
2883
2884
cap = sep->codec;
2885
codec_data = (void *) cap->data;
2886
2887
if (codec_data->media_codec_type != codec)
2888
continue;
2889
2890
if (!sep->stream) {
2891
*rsep = sep;
2892
return 0;
2893
}
2894
}
2895
2896
return -EINVAL;
3268
return err;
2897
3269
}
2898
3270
2899
3271
gboolean avdtp_stream_remove_cb(struct avdtp *session,
2975
3347
struct setconf_req *req;
2976
3348
struct avdtp_stream *new_stream;
2977
3349
unsigned char *ptr;
2978
int ret, caps_len;
3350
int err, caps_len;
2979
3351
struct avdtp_service_capability *cap;
2980
3352
GSList *l;
2981
3353
2985
3357
if (!(lsep && rsep))
2986
3358
return -EINVAL;
2987
3359
2988
debug("avdtp_set_configuration(%p): int_seid=%u, acp_seid=%u",
2989
session, lsep->info.seid, rsep->seid);
3360
DBG("%p: int_seid=%u, acp_seid=%u", session,
3361
lsep->info.seid, rsep->seid);
2990
3362
2991
3363
new_stream = g_new0(struct avdtp_stream, 1);
2992
3364
new_stream->session = session;
2993
3365
new_stream->lsep = lsep;
2994
3366
new_stream->rseid = rsep->seid;
2995
3367
3368
if (rsep->delay_reporting && lsep->delay_reporting) {
3369
struct avdtp_service_capability *delay_reporting;
3370
3371
delay_reporting = avdtp_service_cap_new(AVDTP_DELAY_REPORTING,
3372
NULL, 0);
3373
caps = g_slist_append(caps, delay_reporting);
3374
new_stream->delay_reporting = TRUE;
3375
}
3376
2996
3377
g_slist_foreach(caps, copy_capabilities, &new_stream->caps);
2997
3378
2998
3379
/* Calculate total size of request */
3013
3394
ptr += cap->length + 2;
3014
3395
}
3015
3396
3016
ret = send_request(session, FALSE, new_stream,
3397
err = send_request(session, FALSE, new_stream,
3017
3398
AVDTP_SET_CONFIGURATION, req,
3018
3399
sizeof(struct setconf_req) + caps_len);
3019
if (ret < 0)
3400
if (err < 0)
3020
3401
stream_free(new_stream);
3021
3402
else {
3022
3403
lsep->info.inuse = 1;
3029
3410
3030
3411
g_free(req);
3031
3412
3032
return ret;
3413
return err;
3033
3414
}
3034
3415
3035
3416
int avdtp_reconfigure(struct avdtp *session, GSList *caps,
3098
3479
if (stream->lsep->state != AVDTP_STATE_OPEN)
3099
3480
return -EINVAL;
3100
3481
3482
if (stream->close_int == TRUE) {
3483
error("avdtp_start: rejecting start since close is initiated");
3484
return -EINVAL;
3485
}
3486
3101
3487
memset(&req, 0, sizeof(req));
3102
3488
req.first_seid.seid = stream->rseid;
3103
3489
3105
3491
&req, sizeof(req));
3106
3492
}
3107
3493
3108
int avdtp_close(struct avdtp *session, struct avdtp_stream *stream)
3494
int avdtp_close(struct avdtp *session, struct avdtp_stream *stream,
3495
gboolean immediate)
3109
3496
{
3110
3497
struct seid_req req;
3111
3498
int ret;
3116
3503
if (stream->lsep->state < AVDTP_STATE_OPEN)
3117
3504
return -EINVAL;
3118
3505
3506
if (stream->close_int == TRUE) {
3507
error("avdtp_close: rejecting since close is already initiated");
3508
return -EINVAL;
3509
}
3510
3511
if (immediate && session->req && stream == session->req->stream)
3512
return avdtp_abort(session, stream);
3513
3119
3514
memset(&req, 0, sizeof(req));
3120
3515
req.acp_seid = stream->rseid;
3121
3516
3134
3529
if (!g_slist_find(session->streams, stream))
3135
3530
return -EINVAL;
3136
3531
3137
if (stream->lsep->state <= AVDTP_STATE_OPEN)
3532
if (stream->lsep->state <= AVDTP_STATE_OPEN || stream->close_int)
3138
3533
return -EINVAL;
3139
3534
3140
3535
memset(&req, 0, sizeof(req));
3152
3547
if (!g_slist_find(session->streams, stream))
3153
3548
return -EINVAL;
3154
3549
3155
if (stream->lsep->state <= AVDTP_STATE_OPEN)
3550
if (stream->lsep->state == AVDTP_STATE_ABORTING)
3156
3551
return -EINVAL;
3157
3552
3553
if (session->req && stream == session->req->stream)
3554
return cancel_request(session, ECANCELED);
3555
3158
3556
memset(&req, 0, sizeof(req));
3159
3557
req.acp_seid = stream->rseid;
3160
3558
3161
3559
ret = send_request(session, TRUE, stream, AVDTP_ABORT,
3162
3560
&req, sizeof(req));
3163
3561
if (ret == 0)
3164
avdtp_sep_set_state(session, stream->lsep,
3165
AVDTP_STATE_ABORTING);
3562
stream->abort_int = TRUE;
3166
3563
3167
3564
return ret;
3168
3565
}
3169
3566
3567
int avdtp_delay_report(struct avdtp *session, struct avdtp_stream *stream,
3568
uint16_t delay)
3569
{
3570
struct delay_req req;
3571
3572
if (!g_slist_find(session->streams, stream))
3573
return -EINVAL;
3574
3575
if (stream->lsep->state != AVDTP_STATE_CONFIGURED &&
3576
stream->lsep->state != AVDTP_STATE_STREAMING)
3577
return -EINVAL;
3578
3579
if (!stream->delay_reporting || session->version < 0x0103 ||
3580
session->server->version < 0x0103)
3581
return -EINVAL;
3582
3583
stream->delay = delay;
3584
3585
memset(&req, 0, sizeof(req));
3586
req.acp_seid = stream->rseid;
3587
req.delay = htons(delay);
3588
3589
return send_request(session, TRUE, stream, AVDTP_DELAY_REPORT,
3590
&req, sizeof(req));
3591
}
3592
3170
3593
struct avdtp_local_sep *avdtp_register_sep(const bdaddr_t *src, uint8_t type,
3171
3594
uint8_t media_type,
3172
3595
uint8_t codec_type,
3596
gboolean delay_reporting,
3173
3597
struct avdtp_sep_ind *ind,
3174
3598
struct avdtp_sep_cfm *cfm,
3175
3599
void *user_data)
3195
3619
sep->cfm = cfm;
3196
3620
sep->user_data = user_data;
3197
3621
sep->server = server;
3622
sep->delay_reporting = TRUE;
3198
3623
3199
debug("SEP %p registered: type:%d codec:%d seid:%d", sep,
3624
DBG("SEP %p registered: type:%d codec:%d seid:%d", sep,
3200
3625
sep->info.type, sep->codec, sep->info.seid);
3201
3626
server->seps = g_slist_append(server->seps, sep);
3202
3627
3210
3635
if (!sep)
3211
3636
return -EINVAL;
3212
3637
3213
if (sep->info.inuse)
3214
return -EBUSY;
3215
3216
3638
server = sep->server;
3217
3639
server->seps = g_slist_remove(server->seps, sep);
3218
3640
3219
3641
if (sep->stream)
3220
avdtp_sep_set_state(sep->stream->session, sep,
3221
AVDTP_STATE_IDLE);
3642
release_stream(sep->stream, sep->stream->session);
3643
3644
DBG("SEP %p unregistered: type:%d codec:%d seid:%d", sep,
3645
sep->info.type, sep->codec, sep->info.seid);
3222
3646
3223
3647
g_free(sep);
3224
3648
3247
3671
3248
3672
const char *avdtp_strerror(struct avdtp_error *err)
3249
3673
{
3250
if (err->type == AVDTP_ERROR_ERRNO)
3674
if (err->category == AVDTP_ERRNO)
3251
3675
return strerror(err->err.posix_errno);
3252
3676
3253
3677
switch(err->err.error_code) {
3303
3727
bacpy(dst, &session->dst);
3304
3728
}
3305
3729
3306
int avdtp_init(const bdaddr_t *src, GKeyFile *config)
3730
int avdtp_init(const bdaddr_t *src, GKeyFile *config, uint16_t *version)
3307
3731
{
3308
3732
GError *err = NULL;
3309
3733
gboolean tmp, master = TRUE;
3310
3734
struct avdtp_server *server;
3311
3312
if (config) {
3313
tmp = g_key_file_get_boolean(config, "General",
3314
"Master", &err);
3315
if (err) {
3316
debug("audio.conf: %s", err->message);
3317
g_clear_error(&err);
3318
} else
3319
master = tmp;
3320
3321
tmp = g_key_file_get_boolean(config, "General", "AutoConnect",
3322
&err);
3323
if (err)
3324
g_clear_error(&err);
3325
else
3326
auto_connect = tmp;
3327
}
3328
3735
uint16_t ver = 0x0102;
3736
3737
if (!config)
3738
goto proceed;
3739
3740
tmp = g_key_file_get_boolean(config, "General",
3741
"Master", &err);
3742
if (err) {
3743
DBG("audio.conf: %s", err->message);
3744
g_clear_error(&err);
3745
} else
3746
master = tmp;
3747
3748
tmp = g_key_file_get_boolean(config, "General", "AutoConnect",
3749
&err);
3750
if (err)
3751
g_clear_error(&err);
3752
else
3753
auto_connect = tmp;
3754
3755
if (g_key_file_get_boolean(config, "A2DP", "DelayReporting", NULL))
3756
ver = 0x0103;
3757
3758
proceed:
3329
3759
server = g_new0(struct avdtp_server, 1);
3330
3760
if (!server)
3331
3761
return -ENOMEM;
3332
3762
3763
server->version = ver;
3764
3765
if (version)
3766
*version = server->version;
3767
3333
3768
server->io = avdtp_server_socket(src, master);
3334
3769
if (!server->io) {
3335
3770
g_free(server);
3346
3781
void avdtp_exit(const bdaddr_t *src)
3347
3782
{
3348
3783
struct avdtp_server *server;
3784
GSList *l;
3349
3785
3350
3786
server = find_server(servers, src);
3351
3787
if (!server)
3352
3788
return;
3353
3789
3790
for (l = server->sessions; l; l = l->next) {
3791
struct avdtp *session = l->data;
3792
3793
connection_lost(session, -ECONNABORTED);
3794
}
3795
3354
3796
servers = g_slist_remove(servers, server);
3355
3797
3356
3798
g_io_channel_shutdown(server->io, TRUE, NULL);
3373
3815
return session->stream_setup;
3374
3816
}
3375
3817
3818
void avdtp_set_device_disconnect(struct avdtp *session, gboolean dev_dc)
3819
{
3820
session->device_disconnect = dev_dc;
3821
}
3822
3376
3823
unsigned int avdtp_add_state_cb(avdtp_session_state_cb cb, void *user_data)
3377
3824
{
3378
3825
struct avdtp_state_callback *state_cb;
Loggerhead is a web-based interface for Breezy
Version: 2.0.1