#if __BYTE_ORDER == __LITTLE_ENDIAN
-struct avdtp_header {
+struct avdtp_common_header {
uint8_t message_type:2;
uint8_t packet_type:2;
uint8_t transaction:4;
+} __attribute__ ((packed));
+
+struct avdtp_single_header {
+ uint8_t message_type:2;
+ uint8_t packet_type:2;
+ uint8_t transaction:4;
+ uint8_t signal_id:6;
+ uint8_t rfa0:2;
+} __attribute__ ((packed));
+
+struct avdtp_start_header {
+ uint8_t message_type:2;
+ uint8_t packet_type:2;
+ uint8_t transaction:4;
+ uint8_t no_of_packets;
uint8_t signal_id:6;
uint8_t rfa0:2;
} __attribute__ ((packed));
+struct avdtp_continue_header {
+ uint8_t message_type:2;
+ uint8_t packet_type:2;
+ uint8_t transaction:4;
+} __attribute__ ((packed));
+
struct seid_info {
uint8_t rfa0:1;
uint8_t inuse:1;
#elif __BYTE_ORDER == __BIG_ENDIAN
-struct avdtp_header {
+struct avdtp_common_header {
+ uint8_t transaction:4;
+ uint8_t packet_type:2;
+ uint8_t message_type:2;
+} __attribute__ ((packed));
+
+struct avdtp_single_header {
+ uint8_t transaction:4;
+ uint8_t packet_type:2;
+ uint8_t message_type:2;
+ uint8_t rfa0:2;
+ uint8_t signal_id:6;
+} __attribute__ ((packed));
+
+struct avdtp_start_header {
uint8_t transaction:4;
uint8_t packet_type:2;
uint8_t message_type:2;
+ uint8_t no_of_packets;
uint8_t rfa0:2;
uint8_t signal_id:6;
} __attribute__ ((packed));
+struct avdtp_continue_header {
+ uint8_t transaction:4;
+ uint8_t packet_type:2;
+ uint8_t message_type:2;
+} __attribute__ ((packed));
+
struct seid_info {
uint8_t seid:6;
uint8_t inuse:1;
/* packets */
-struct gen_req {
- struct avdtp_header header;
-} __attribute__ ((packed));
-
-struct gen_resp {
- struct avdtp_header header;
-} __attribute__ ((packed));
-
struct discover_resp {
- struct avdtp_header header;
struct seid_info seps[0];
} __attribute__ ((packed));
struct getcap_resp {
- struct avdtp_header header;
uint8_t caps[0];
} __attribute__ ((packed));
struct start_req {
- struct avdtp_header header;
struct seid first_seid;
struct seid other_seids[0];
} __attribute__ ((packed));
struct suspend_req {
- struct avdtp_header header;
struct seid first_seid;
struct seid other_seids[0];
} __attribute__ ((packed));
struct seid_rej {
- struct avdtp_header header;
uint8_t error;
} __attribute__ ((packed));
struct conf_rej {
- struct avdtp_header header;
uint8_t category;
uint8_t error;
} __attribute__ ((packed));
#if __BYTE_ORDER == __LITTLE_ENDIAN
struct seid_req {
- struct avdtp_header header;
uint8_t rfa0:2;
uint8_t acp_seid:6;
} __attribute__ ((packed));
struct setconf_req {
- struct avdtp_header header;
-
uint8_t rfa0:2;
uint8_t acp_seid:6;
uint8_t rfa1:2;
} __attribute__ ((packed));
struct stream_rej {
- struct avdtp_header header;
uint8_t rfa0:2;
uint8_t acp_seid:6;
uint8_t error;
} __attribute__ ((packed));
struct reconf_req {
- struct avdtp_header header;
-
uint8_t rfa0:2;
uint8_t acp_seid:6;
uint8_t caps[0];
} __attribute__ ((packed));
-struct avdtp_general_rej {
- uint8_t message_type:2;
- uint8_t packet_type:2;
- uint8_t transaction:4;
- uint8_t rfa0;
-} __attribute__ ((packed));
-
#elif __BYTE_ORDER == __BIG_ENDIAN
struct seid_req {
- struct avdtp_header header;
uint8_t acp_seid:6;
uint8_t rfa0:2;
} __attribute__ ((packed));
struct setconf_req {
- struct avdtp_header header;
-
uint8_t acp_seid:6;
uint8_t rfa0:2;
uint8_t int_seid:6;
} __attribute__ ((packed));
struct stream_rej {
- struct avdtp_header header;
uint8_t acp_seid:6;
uint8_t rfa0:2;
uint8_t error;
} __attribute__ ((packed));
struct reconf_req {
- struct avdtp_header header;
-
uint8_t acp_seid:6;
uint8_t rfa0:2;
uint8_t caps[0];
} __attribute__ ((packed));
-struct avdtp_general_rej {
- uint8_t transaction:4;
- uint8_t packet_type:2;
- uint8_t message_type:2;
- uint8_t rfa0;
-} __attribute__ ((packed));
-
#else
#error "Unknown byte order"
#endif
+struct in_buf {
+ gboolean active;
+ int no_of_packets;
+ uint8_t transaction;
+ uint8_t message_type;
+ uint8_t signal_id;
+ uint8_t buf[1024];
+ uint8_t data_size;
+};
+
struct pending_req {
- struct avdtp_header *msg;
- int msg_size;
+ uint8_t transaction;
+ uint8_t signal_id;
+ void *data;
+ size_t data_size;
struct avdtp_stream *stream; /* Set if the request targeted a stream */
guint timeout;
};
struct avdtp_stream *pending_open;
- uint16_t mtu;
+ uint16_t imtu;
+ uint16_t omtu;
+
+ struct in_buf in;
+
char *buf;
avdtp_discover_cb_t discov_cb;
static GSList *sessions = NULL;
static int send_request(struct avdtp *session, gboolean priority,
- struct avdtp_stream *stream, void *buffer, int size);
+ struct avdtp_stream *stream, uint8_t signal_id,
+ void *buffer, size_t size);
static gboolean avdtp_parse_resp(struct avdtp *session,
struct avdtp_stream *stream,
- struct avdtp_header *header, int size);
+ uint8_t transaction, uint8_t signal_id,
+ void *buf, int size);
static gboolean avdtp_parse_rej(struct avdtp *session,
- struct avdtp_stream *stream,
- struct avdtp_header *header, int size);
+ struct avdtp_stream *stream,
+ uint8_t transaction, uint8_t signal_id,
+ void *buf, int size);
static int process_queue(struct avdtp *session);
static void connection_lost(struct avdtp *session, int err);
static void avdtp_sep_set_state(struct avdtp *session,
}
}
-static gboolean avdtp_send(struct avdtp *session, void *data, int len)
+static gboolean try_send(int sk, void *data, int len)
{
- int ret;
-
- if (session->sock < 0) {
- error("avdtp_send: session is closed");
- return FALSE;
- }
+ gboolean ret;
- ret = send(session->sock, data, len, 0);
+ ret = send(sk, data, len, 0);
if (ret < 0)
ret = -errno;
ret = -EIO;
if (ret < 0) {
- error("avdtp_send: %s (%d)", strerror(-ret), -ret);
+ error("try_send: %s (%d)", strerror(-ret), -ret);
return FALSE;
}
return TRUE;
}
+static gboolean avdtp_send(struct avdtp *session, uint8_t transaction,
+ uint8_t message_type, uint8_t signal_id,
+ void *data, size_t len)
+{
+ int cont_fragments, sent;
+ struct avdtp_start_header start;
+ struct avdtp_continue_header cont;
+
+ if (session->sock < 0) {
+ error("avdtp_send: session is closed");
+ return FALSE;
+ }
+
+ /* Single packet - no fragmentation */
+ if (sizeof(struct avdtp_single_header) + len <= session->omtu) {
+ struct avdtp_single_header single;
+
+ memset(&single, 0, sizeof(single));
+
+ single.transaction = transaction;
+ single.packet_type = AVDTP_PKT_TYPE_SINGLE;
+ single.message_type = message_type;
+ single.signal_id = signal_id;
+
+ memcpy(session->buf, &single, sizeof(single));
+ memcpy(session->buf + sizeof(single), data, len);
+
+ return try_send(session->sock, session->buf,
+ sizeof(single) + len);
+ }
+
+ /* Count the number of needed fragments */
+ cont_fragments = (len - (session->omtu - sizeof(start))) /
+ (session->omtu - sizeof(cont)) + 1;
+
+ debug("avdtp_send: %u bytes split into %d fragments", len,
+ cont_fragments + 1);
+
+ /* Send the start packet */
+ memset(&start, 0, sizeof(start));
+ start.transaction = transaction;
+ start.packet_type = AVDTP_PKT_TYPE_START;
+ start.message_type = message_type;
+ start.no_of_packets = cont_fragments + 1;
+ start.signal_id = signal_id;
+
+ memcpy(session->buf, &start, sizeof(start));
+ memcpy(session->buf + sizeof(start), data,
+ session->omtu - sizeof(start));
+
+ if (!try_send(session->sock, session->buf, session->omtu))
+ return FALSE;
+
+ debug("avdtp_send: first packet with %d bytes sent",
+ session->omtu - sizeof(start));
+
+ sent = session->omtu - sizeof(start);
+
+ /* Send the continue fragments and the end packet */
+ while (sent < len) {
+ int left, to_copy;
+
+ left = len - sent;
+ if (left + sizeof(cont) > session->omtu) {
+ cont.packet_type = AVDTP_PKT_TYPE_CONTINUE;
+ to_copy = session->omtu - sizeof(cont);
+ debug("avdtp_send: sending continue with %d bytes",
+ to_copy);
+ } else {
+ cont.packet_type = AVDTP_PKT_TYPE_END;
+ to_copy = left;
+ debug("avdtp_send: sending end with %d bytes",
+ to_copy);
+ }
+
+ cont.transaction = transaction;
+ cont.message_type = message_type;
+
+ memcpy(session->buf, &cont, sizeof(cont));
+ memcpy(session->buf + sizeof(cont), data + sent, to_copy);
+
+ if (!try_send(session->sock, session->buf,
+ to_copy + sizeof(cont)))
+ return FALSE;
+
+ sent += to_copy;
+ }
+
+ return TRUE;
+}
+
static void pending_req_free(struct pending_req *req)
{
if (req->timeout)
g_source_remove(req->timeout);
- g_free(req->msg);
+ g_free(req->data);
g_free(req);
}
GIOChannel *channel;
session->pending_open = NULL;
+ if (!g_slist_find(session->streams, stream)) {
+ debug("handle_transport_connect: stream got removed");
+ return;
+ }
if (stream->timer) {
g_source_remove(stream->timer);
channel = g_io_channel_unix_new(stream->sock);
+ if (stream->io)
+ g_source_remove(stream->io);
stream->io = g_io_add_watch(channel, G_IO_ERR | G_IO_HUP | G_IO_NVAL,
(GIOFunc) transport_cb, stream);
g_io_channel_unref(channel);
sep->state = state;
if (stream) {
- GSList *l;
- for (l = stream->callbacks; l != NULL; l = g_slist_next(l)) {
+ GSList *l = stream->callbacks;
+ while (l != NULL) {
struct stream_callback *cb = l->data;
+ GSList *next = g_slist_next(l);
cb->cb(stream, old_state, state, err_ptr,
cb->user_data);
+ l = next;
}
}
}
break;
case AVDTP_STATE_IDLE:
- if (stream->idle_timer) {
- g_source_remove(stream->idle_timer);
- stream->idle_timer = 0;
+ if (g_slist_find(session->streams, stream)) {
+ if (stream->idle_timer) {
+ g_source_remove(stream->idle_timer);
+ stream->idle_timer = 0;
+ }
+ session->streams = g_slist_remove(session->streams, stream);
+ if (session->pending_open == stream)
+ handle_transport_connect(session, -1, 0, 0);
+ if (session->req && session->req->stream == stream)
+ session->req->stream = NULL;
+ stream_free(stream);
+ if (session->ref == 1 && !session->streams)
+ set_disconnect_timer(session);
}
- session->streams = g_slist_remove(session->streams, stream);
- if (session->pending_open == stream)
- handle_transport_connect(session, -1, 0, 0);
- if (session->req && session->req->stream == stream)
- session->req->stream = NULL;
- stream_free(stream);
- if (session->ref == 1 && !session->streams)
- set_disconnect_timer(session);
break;
default:
break;
if (session->dc_timer)
remove_disconnect_timer(session);
+ if (session->io)
+ g_source_remove(session->io);
sessions = g_slist_remove(sessions, session);
return caps;
}
-static void init_response(struct avdtp_header *rsp, struct avdtp_header *req,
- gboolean accept)
-{
- rsp->packet_type = AVDTP_PKT_TYPE_SINGLE;
- rsp->message_type = accept ? AVDTP_MSG_TYPE_ACCEPT :
- AVDTP_MSG_TYPE_REJECT;
- rsp->transaction = req->transaction;
- rsp->signal_id = req->signal_id;
- rsp->rfa0 = 0;
-}
-
-static gboolean avdtp_unknown_cmd(struct avdtp *session,
- struct avdtp_header *req, int size)
+static gboolean avdtp_unknown_cmd(struct avdtp *session, uint8_t transaction,
+ void *buf, int size)
{
- struct avdtp_general_rej rej;
-
- memset(&rej, 0, sizeof(rej));
-
- rej.packet_type = AVDTP_PKT_TYPE_SINGLE;
- rej.message_type = AVDTP_MSG_TYPE_REJECT;
- rej.transaction = req->transaction;
-
- return avdtp_send(session, &rej, sizeof(rej));
+ return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
+ 0, NULL, 0);
}
-static gboolean avdtp_discover_cmd(struct avdtp *session,
- struct gen_req *req, int size)
+static gboolean avdtp_discover_cmd(struct avdtp *session, uint8_t transaction,
+ void *buf, int size)
{
GSList *l;
- struct discover_resp *rsp = (struct discover_resp *) session->buf;
- struct seid_info *info;
- int rsp_size;
+ int rsp_size, sep_count, i;
+ struct seid_info *seps;
- init_response(&rsp->header, &req->header, TRUE);
- rsp_size = sizeof(struct discover_resp);
- info = rsp->seps;
+ sep_count = g_slist_length(local_seps);
+ rsp_size = sep_count * sizeof(struct seid_info);
- for (l = local_seps; l != NULL; l = l->next) {
- struct avdtp_local_sep *sep = l->data;
+ seps = g_new0(struct seid_info, sep_count);
- if (rsp_size + sizeof(struct seid_info) > session->mtu)
- break;
+ for (l = local_seps, i = 0; l != NULL; l = l->next, i++) {
+ struct avdtp_local_sep *sep = l->data;
- memcpy(info, &sep->info, sizeof(struct seid_info));
- rsp_size += sizeof(struct seid_info);
- info++;
+ memcpy(&seps[i], &sep->info, sizeof(struct seid_info));
}
- return avdtp_send(session, session->buf, rsp_size);
+ return avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
+ AVDTP_DISCOVER, seps, rsp_size);
}
-static gboolean avdtp_getcap_cmd(struct avdtp *session,
+static gboolean avdtp_getcap_cmd(struct avdtp *session, uint8_t transaction,
struct seid_req *req, int size)
{
GSList *l, *caps;
struct avdtp_local_sep *sep = NULL;
- struct seid_rej rej;
- struct getcap_resp *rsp = (struct getcap_resp *) session->buf;
int rsp_size;
- unsigned char *ptr;
- uint8_t err;
+ uint8_t err, buf[1024], *ptr = buf;
if (size < sizeof(struct seid_req)) {
error("Too short getcap request");
sep->user_data))
goto failed;
- init_response(&rsp->header, &req->header, TRUE);
- rsp_size = sizeof(struct getcap_resp);
- ptr = rsp->caps;
-
- for (l = caps; l != NULL; l = g_slist_next(l)) {
+ for (l = caps, rsp_size = 0; l != NULL; l = g_slist_next(l)) {
struct avdtp_service_capability *cap = l->data;
- if (rsp_size + cap->length + 2 > session->mtu)
+ if (rsp_size + cap->length + 2 > sizeof(buf))
break;
memcpy(ptr, cap, cap->length + 2);
g_slist_free(caps);
- return avdtp_send(session, session->buf, rsp_size);
+ return avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
+ AVDTP_GET_CAPABILITIES, buf, rsp_size);
failed:
- init_response(&rej.header, &req->header, FALSE);
- rej.error = AVDTP_BAD_ACP_SEID;
- return avdtp_send(session, &rej, sizeof(rej));
+ return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
+ AVDTP_GET_CAPABILITIES, &err, sizeof(err));
}
-static gboolean avdtp_setconf_cmd(struct avdtp *session,
+static gboolean avdtp_setconf_cmd(struct avdtp *session, uint8_t transaction,
struct setconf_req *req, int size)
{
struct conf_rej rej;
- struct gen_resp *rsp = (struct gen_resp *) session->buf;
struct avdtp_local_sep *sep;
struct avdtp_stream *stream;
uint8_t err, category = 0x00;
}
}
- init_response(&rsp->header, &req->header, TRUE);
-
- if (!avdtp_send(session, rsp, sizeof(struct setconf_req))) {
+ if (!avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
+ AVDTP_SET_CONFIGURATION, NULL, 0)) {
stream_free(stream);
return FALSE;
}
return TRUE;
failed:
- init_response(&rej.header, &req->header, FALSE);
rej.error = err;
rej.category = category;
- return avdtp_send(session, &rej, sizeof(rej));
+ return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
+ AVDTP_SET_CONFIGURATION, &rej, sizeof(rej));
}
-static gboolean avdtp_getconf_cmd(struct avdtp *session, struct seid_req *req,
- int size)
+static gboolean avdtp_getconf_cmd(struct avdtp *session, uint8_t transaction,
+ struct seid_req *req, int size)
{
- return avdtp_unknown_cmd(session, (void *) req, size);
+ return avdtp_unknown_cmd(session, transaction, (void *) req, size);
}
-static gboolean avdtp_reconf_cmd(struct avdtp *session, struct seid_req *req,
- int size)
+static gboolean avdtp_reconf_cmd(struct avdtp *session, uint8_t transaction,
+ struct seid_req *req, int size)
{
- return avdtp_unknown_cmd(session, (void *) req, size);
+ return avdtp_unknown_cmd(session, transaction, (void *) req, size);
}
-static gboolean avdtp_open_cmd(struct avdtp *session, struct seid_req *req,
- int size)
+static gboolean avdtp_open_cmd(struct avdtp *session, uint8_t transaction,
+ struct seid_req *req, int size)
{
struct avdtp_local_sep *sep;
struct avdtp_stream *stream;
- struct gen_resp *rsp = (struct gen_resp *) session->buf;
- struct seid_rej rej;
uint8_t err;
if (size < sizeof(struct seid_req)) {
goto failed;
}
- init_response(&rsp->header, &req->header, TRUE);
-
- if (!avdtp_send(session, rsp, sizeof(struct gen_resp)))
+ if (!avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
+ AVDTP_OPEN, NULL, 0))
return FALSE;
stream->open_acp = TRUE;
session->pending_open = stream;
- stream->timer = g_timeout_add(REQ_TIMEOUT, stream_open_timeout,
- stream);
+ if (stream->timer)
+ g_source_remove(stream->timer);
+ stream->timer = g_timeout_add(REQ_TIMEOUT,
+ stream_open_timeout,
+ stream);
return TRUE;
failed:
- init_response(&rej.header, &req->header, FALSE);
- rej.error = err;
- return avdtp_send(session, &rej, sizeof(rej));
+ return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
+ AVDTP_OPEN, &err, sizeof(err));
+
}
-static gboolean avdtp_start_cmd(struct avdtp *session, struct start_req *req,
- int size)
+static gboolean avdtp_start_cmd(struct avdtp *session, uint8_t transaction,
+ struct start_req *req, int size)
{
struct avdtp_local_sep *sep;
struct avdtp_stream *stream;
- struct gen_resp *rsp = (struct gen_resp *) session->buf;
struct stream_rej rej;
struct seid *seid;
uint8_t err, failed_seid;
avdtp_sep_set_state(session, sep, AVDTP_STATE_STREAMING);
}
- init_response(&rsp->header, &req->header, TRUE);
-
- return avdtp_send(session, rsp, sizeof(struct gen_resp));
+ return avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
+ AVDTP_START, NULL, 0);
failed:
memset(&rej, 0, sizeof(rej));
- init_response(&rej.header, &req->header, FALSE);
rej.acp_seid = failed_seid;
rej.error = err;
- return avdtp_send(session, &rej, sizeof(rej));
+ return avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
+ AVDTP_START, &rej, sizeof(rej));
}
-static gboolean avdtp_close_cmd(struct avdtp *session, struct seid_req *req,
- int size)
+static gboolean avdtp_close_cmd(struct avdtp *session, uint8_t transaction,
+ struct seid_req *req, int size)
{
struct avdtp_local_sep *sep;
struct avdtp_stream *stream;
- struct gen_resp *rsp = (struct gen_resp *) session->buf;
- struct seid_rej rej;
uint8_t err;
if (size < sizeof(struct seid_req)) {
avdtp_sep_set_state(session, sep, AVDTP_STATE_CLOSING);
- init_response(&rsp->header, &req->header, TRUE);
-
- if (!avdtp_send(session, rsp, sizeof(struct gen_resp)))
+ if (!avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
+ AVDTP_CLOSE, NULL, 0))
return FALSE;
- stream->timer = g_timeout_add(REQ_TIMEOUT, stream_close_timeout,
+ if (stream->timer)
+ g_source_remove(stream->timer);
+ stream->timer = g_timeout_add_seconds(REQ_TIMEOUT,
+ stream_close_timeout,
stream);
return TRUE;
failed:
- init_response(&rej.header, &req->header, FALSE);
- rej.error = err;
- return avdtp_send(session, &rej, sizeof(rej));
+ return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
+ AVDTP_CLOSE, &err, sizeof(err));
}
-static gboolean avdtp_suspend_cmd(struct avdtp *session,
+static gboolean avdtp_suspend_cmd(struct avdtp *session, uint8_t transaction,
struct suspend_req *req, int size)
{
struct avdtp_local_sep *sep;
struct avdtp_stream *stream;
- struct gen_resp *rsp = (struct gen_resp *) session->buf;
struct stream_rej rej;
struct seid *seid;
uint8_t err, failed_seid;
avdtp_sep_set_state(session, sep, AVDTP_STATE_OPEN);
}
- init_response(&rsp->header, &req->header, TRUE);
-
- return avdtp_send(session, rsp, sizeof(struct gen_resp));
+ return avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
+ AVDTP_SUSPEND, NULL, 0);
failed:
memset(&rej, 0, sizeof(rej));
- init_response(&rej.header, &req->header, FALSE);
rej.acp_seid = failed_seid;
rej.error = err;
- return avdtp_send(session, &rej, sizeof(rej));
+ return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
+ AVDTP_SUSPEND, &rej, sizeof(rej));
}
-static gboolean avdtp_abort_cmd(struct avdtp *session, struct seid_req *req,
- int size)
+static gboolean avdtp_abort_cmd(struct avdtp *session, uint8_t transaction,
+ struct seid_req *req, int size)
{
struct avdtp_local_sep *sep;
- struct gen_resp *rsp = (struct gen_resp *) session->buf;
- struct seid_rej rej;
uint8_t err;
gboolean ret;
goto failed;
}
- init_response(&rsp->header, &req->header, TRUE);
- ret = avdtp_send(session, rsp, sizeof(struct gen_resp));
-
+ ret = avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
+ AVDTP_ABORT, NULL, 0);
if (ret)
avdtp_sep_set_state(session, sep, AVDTP_STATE_ABORTING);
return ret;
failed:
- init_response(&rej.header, &req->header, FALSE);
- rej.error = err;
- return avdtp_send(session, &rej, sizeof(rej));
+ return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
+ AVDTP_ABORT, &err, sizeof(err));
}
-static gboolean avdtp_secctl_cmd(struct avdtp *session, struct seid_req *req,
- int size)
+static gboolean avdtp_secctl_cmd(struct avdtp *session, uint8_t transaction,
+ struct seid_req *req, int size)
{
- return avdtp_unknown_cmd(session, (void *) req, size);
+ return avdtp_unknown_cmd(session, transaction, (void *) req, size);
}
-static gboolean avdtp_parse_cmd(struct avdtp *session,
- struct avdtp_header *header, int size)
+static gboolean avdtp_parse_cmd(struct avdtp *session, uint8_t transaction,
+ uint8_t signal_id, void *buf, int size)
{
- switch (header->signal_id) {
+ switch (signal_id) {
case AVDTP_DISCOVER:
debug("Received DISCOVER_CMD");
- return avdtp_discover_cmd(session, (void *) header, size);
+ return avdtp_discover_cmd(session, transaction, buf, size);
case AVDTP_GET_CAPABILITIES:
debug("Received GET_CAPABILITIES_CMD");
- return avdtp_getcap_cmd(session, (void *) header, size);
+ return avdtp_getcap_cmd(session, transaction, buf, size);
case AVDTP_SET_CONFIGURATION:
debug("Received SET_CONFIGURATION_CMD");
- return avdtp_setconf_cmd(session, (void *) header, size);
+ return avdtp_setconf_cmd(session, transaction, buf, size);
case AVDTP_GET_CONFIGURATION:
debug("Received GET_CONFIGURATION_CMD");
- return avdtp_getconf_cmd(session, (void *) header, size);
+ return avdtp_getconf_cmd(session, transaction, buf, size);
case AVDTP_RECONFIGURE:
debug("Received RECONFIGURE_CMD");
- return avdtp_reconf_cmd(session, (void *) header, size);
+ return avdtp_reconf_cmd(session, transaction, buf, size);
case AVDTP_OPEN:
debug("Received OPEN_CMD");
- return avdtp_open_cmd(session, (void *) header, size);
+ return avdtp_open_cmd(session, transaction, buf, size);
case AVDTP_START:
debug("Received START_CMD");
- return avdtp_start_cmd(session, (void *) header, size);
+ return avdtp_start_cmd(session, transaction, buf, size);
case AVDTP_CLOSE:
debug("Received CLOSE_CMD");
- return avdtp_close_cmd(session, (void *) header, size);
+ return avdtp_close_cmd(session, transaction, buf, size);
case AVDTP_SUSPEND:
debug("Received SUSPEND_CMD");
- return avdtp_suspend_cmd(session, (void *) header, size);
+ return avdtp_suspend_cmd(session, transaction, buf, size);
case AVDTP_ABORT:
debug("Received ABORT_CMD");
- return avdtp_abort_cmd(session, (void *) header, size);
+ return avdtp_abort_cmd(session, transaction, buf, size);
case AVDTP_SECURITY_CONTROL:
debug("Received SECURITY_CONTROL_CMD");
- return avdtp_secctl_cmd(session, (void *) header, size);
+ return avdtp_secctl_cmd(session, transaction, buf, size);
default:
- debug("Received unknown request id %u", header->signal_id);
- return avdtp_unknown_cmd(session, (void *) header, size);
+ debug("Received unknown request id %u", signal_id);
+ return avdtp_unknown_cmd(session, transaction, buf, size);
}
}
-static void init_request(struct avdtp_header *header, int request_id)
+enum avdtp_parse_result { PARSE_ERROR, PARSE_FRAGMENT, PARSE_SUCCESS };
+
+static enum avdtp_parse_result avdtp_parse_data(struct avdtp *session,
+ void *buf, size_t size)
{
- static int transaction = 0;
+ struct avdtp_common_header *header = buf;
+ struct avdtp_single_header *single = (void *) session->buf;
+ struct avdtp_start_header *start = (void *) session->buf;
+ void *payload;
+ gsize payload_size;
+
+ switch (header->packet_type) {
+ case AVDTP_PKT_TYPE_SINGLE:
+ if (size < sizeof(*single)) {
+ error("Received too small single packet (%d bytes)", size);
+ return PARSE_ERROR;
+ }
+ if (session->in.active) {
+ error("SINGLE: Invalid AVDTP packet fragmentation");
+ return PARSE_ERROR;
+ }
+
+ payload = session->buf + sizeof(*single);
+ payload_size = size - sizeof(*single);
+
+ session->in.active = TRUE;
+ session->in.data_size = 0;
+ session->in.no_of_packets = 1;
+ session->in.transaction = header->transaction;
+ session->in.message_type = header->message_type;
+ session->in.signal_id = single->signal_id;
+
+ break;
+ case AVDTP_PKT_TYPE_START:
+ if (size < sizeof(*start)) {
+ error("Received too small start packet (%d bytes)", size);
+ return PARSE_ERROR;
+ }
+ if (session->in.active) {
+ error("START: Invalid AVDTP packet fragmentation");
+ return PARSE_ERROR;
+ }
+
+ session->in.active = TRUE;
+ session->in.data_size = 0;
+ session->in.transaction = header->transaction;
+ session->in.message_type = header->message_type;
+ session->in.no_of_packets = start->no_of_packets;
+ session->in.signal_id = start->signal_id;
- header->packet_type = AVDTP_PKT_TYPE_SINGLE;
- header->message_type = AVDTP_MSG_TYPE_COMMAND;
- header->transaction = transaction;
- header->signal_id = request_id;
+ payload = session->buf + sizeof(*start);
+ payload_size = size - sizeof(*start);
- /* clear rfa bits */
- header->rfa0 = 0;
+ break;
+ case AVDTP_PKT_TYPE_CONTINUE:
+ if (size < sizeof(struct avdtp_continue_header)) {
+ error("Received too small continue packet (%d bytes)",
+ size);
+ return PARSE_ERROR;
+ }
+ if (!session->in.active) {
+ error("CONTINUE: Invalid AVDTP packet fragmentation");
+ return PARSE_ERROR;
+ }
+ if (session->in.transaction != header->transaction) {
+ error("Continue transaction id doesn't match");
+ return PARSE_ERROR;
+ }
+ if (session->in.no_of_packets <= 1) {
+ error("Too few continue packets");
+ return PARSE_ERROR;
+ }
+
+ payload = session->buf + sizeof(struct avdtp_continue_header);
+ payload_size = size - sizeof(struct avdtp_continue_header);
+
+ break;
+ case AVDTP_PKT_TYPE_END:
+ if (size < sizeof(struct avdtp_continue_header)) {
+ error("Received too small end packet (%d bytes)", size);
+ return PARSE_ERROR;
+ }
+ if (!session->in.active) {
+ error("END: Invalid AVDTP packet fragmentation");
+ return PARSE_ERROR;
+ }
+ if (session->in.transaction != header->transaction) {
+ error("End transaction id doesn't match");
+ return PARSE_ERROR;
+ }
+ if (session->in.no_of_packets > 1) {
+ error("Got an end packet too early");
+ return PARSE_ERROR;
+ }
+
+ payload = session->buf + sizeof(struct avdtp_continue_header);
+ payload_size = size - sizeof(struct avdtp_continue_header);
- transaction = (transaction + 1) % 16;
+ break;
+ default:
+ error("Invalid AVDTP packet type 0x%02X", header->packet_type);
+ return PARSE_ERROR;
+ }
+
+ if (session->in.data_size + payload_size >
+ sizeof(session->in.buf)) {
+ error("Not enough incoming buffer space!");
+ return PARSE_ERROR;
+ }
+
+ memcpy(session->in.buf + session->in.data_size, payload, payload_size);
+ session->in.data_size += payload_size;
+
+ if (session->in.no_of_packets > 1) {
+ session->in.no_of_packets--;
+ debug("Received AVDTP fragment. %d to go",
+ session->in.no_of_packets);
+ return PARSE_FRAGMENT;
+ }
+
+ session->in.active = FALSE;
+
+ return PARSE_SUCCESS;
}
static gboolean session_cb(GIOChannel *chan, GIOCondition cond,
gpointer data)
{
struct avdtp *session = data;
- struct avdtp_header *header;
+ struct avdtp_common_header *header;
+ struct avdtp_stream *stream;
gsize size;
debug("session_cb");
- if (cond & G_IO_NVAL)
+ if (!g_slist_find(sessions, session)) {
+ error("session_cb called after session was freed");
+ return FALSE;
+ }
+
+ if (cond & G_IO_NVAL) {
+ session->io = 0;
return FALSE;
+ }
if (cond & (G_IO_HUP | G_IO_ERR))
goto failed;
- if (g_io_channel_read(chan, session->buf, session->mtu,
- &size) != G_IO_ERROR_NONE) {
+ if (g_io_channel_read(chan, session->buf, session->imtu, &size)
+ != G_IO_ERROR_NONE) {
error("IO Channel read error");
goto failed;
}
- if (size < sizeof(struct avdtp_header)) {
+ header = (void *) session->buf;
+ if (size < sizeof(struct avdtp_common_header)) {
error("Received too small packet (%d bytes)", size);
goto failed;
}
- header = (struct avdtp_header *) session->buf;
+ switch (avdtp_parse_data(session, session->buf, size)) {
+ case PARSE_ERROR:
+ goto failed;
+ case PARSE_FRAGMENT:
+ return TRUE;
+ case PARSE_SUCCESS:
+ break;
+ }
- if (header->message_type == AVDTP_MSG_TYPE_COMMAND) {
- if (!avdtp_parse_cmd(session, header, size)) {
+ if (session->in.message_type == AVDTP_MSG_TYPE_COMMAND) {
+ if (!avdtp_parse_cmd(session, session->in.transaction,
+ session->in.signal_id,
+ session->in.buf,
+ session->in.data_size)) {
error("Unable to handle command. Disconnecting");
goto failed;
}
}
if (session->req == NULL) {
- error("No pending request, rejecting message");
+ error("No pending request, ignoring message");
return TRUE;
}
- if (header->transaction != session->req->msg->transaction) {
+ if (header->transaction != session->req->transaction) {
error("Transaction label doesn't match");
return TRUE;
}
- if (header->signal_id != session->req->msg->signal_id) {
+ if (session->in.signal_id != session->req->signal_id) {
error("Reponse signal doesn't match");
return TRUE;
}
g_source_remove(session->req->timeout);
session->req->timeout = 0;
- switch(header->message_type) {
+ stream = session->req->stream;
+ if (!g_slist_find(session->streams, stream))
+ stream = NULL;
+
+ switch (header->message_type) {
case AVDTP_MSG_TYPE_ACCEPT:
- if (!avdtp_parse_resp(session, session->req->stream,
- header, size)) {
+ if (!avdtp_parse_resp(session, stream,
+ session->in.transaction,
+ session->in.signal_id,
+ session->in.buf,
+ session->in.data_size)) {
error("Unable to parse accept response");
goto failed;
}
break;
case AVDTP_MSG_TYPE_REJECT:
- if (!avdtp_parse_rej(session, session->req->stream,
- header, size)) {
+ if (!avdtp_parse_rej(session, stream,
+ session->in.transaction,
+ session->in.signal_id,
+ session->in.buf,
+ session->in.data_size)) {
error("Unable to parse reject response");
goto failed;
}
break;
default:
- error("Unknown message type");
+ error("Unknown message type 0x%02X", header->message_type);
break;
}
if (session->state == AVDTP_SESSION_STATE_CONNECTING) {
struct audio_device *dev;
- session->mtu = l2o.imtu;
- session->buf = g_malloc0(session->mtu);
+ session->imtu = l2o.imtu;
+ session->omtu = l2o.omtu;
+
+ debug("AVDTP imtu=%u, omtu=%u", session->imtu, session->omtu);
+
+ session->buf = g_malloc0(session->imtu);
session->state = AVDTP_SESSION_STATE_CONNECTED;
+ if (session->io)
+ g_source_remove(session->io);
session->io = g_io_add_watch(chan,
G_IO_IN | G_IO_ERR | G_IO_HUP
| G_IO_NVAL,
struct avdtp *session = user_data;
struct pending_req *req;
struct seid_req sreq;
- struct avdtp_local_sep *lsep;
- struct avdtp_stream *stream;
- uint8_t seid;
+ struct avdtp_local_sep *lsep = NULL;
+ struct avdtp_stream *stream = NULL;
+ uint8_t seid = 0;
+ uint8_t signal_id;
struct avdtp_error err;
+ if (!g_slist_find(sessions, session)) {
+ error("request_timeout called after session was freed");
+ return FALSE;
+ }
+
req = session->req;
session->req = NULL;
avdtp_error_init(&err, AVDTP_ERROR_ERRNO, ETIMEDOUT);
- seid = ((struct seid_req *) (req->msg))->acp_seid;
-
- stream = find_stream_by_rseid(session, seid);
-
- if (stream)
- lsep = stream->lsep;
- else
- lsep = NULL;
+ if (req->data) {
+ seid = ((struct seid_req *) (req->data))->acp_seid;
+ stream = find_stream_by_rseid(session, seid);
+ if (stream)
+ lsep = stream->lsep;
+ }
+ signal_id = req->signal_id;
+ pending_req_free(req);
- switch (req->msg->signal_id) {
+ switch (signal_id) {
case AVDTP_RECONFIGURE:
error("Reconfigure request timed out");
if (lsep && lsep->cfm && lsep->cfm->reconfigure)
}
memset(&sreq, 0, sizeof(sreq));
- init_request(&sreq.header, AVDTP_ABORT);
sreq.acp_seid = seid;
- if (send_request(session, TRUE, stream, &sreq, sizeof(sreq)) < 0) {
+ if (send_request(session, TRUE, stream, AVDTP_ABORT,
+ &sreq, sizeof(sreq)) < 0) {
error("Unable to send abort request");
goto failed;
}
- goto done;
+ return FALSE;
failed:
connection_lost(session, -ETIMEDOUT);
-done:
- pending_req_free(req);
return FALSE;
}
static int send_req(struct avdtp *session, gboolean priority,
struct pending_req *req)
{
+ static int transaction = 0;
int err;
if (session->state == AVDTP_SESSION_STATE_DISCONNECTED) {
return 0;
}
+ req->transaction = transaction++;
+ transaction %= 16;
+
/* FIXME: Should we retry to send if the buffer
was not totally sent or in case of EINTR? */
- if (!avdtp_send(session, req->msg, req->msg_size)) {
+ if (!avdtp_send(session, req->transaction, AVDTP_MSG_TYPE_COMMAND,
+ req->signal_id, req->data, req->data_size)) {
err = -EIO;
goto failed;
}
session->req = req;
+ if (req->timeout)
+ g_source_remove(req->timeout);
req->timeout = g_timeout_add(REQ_TIMEOUT, request_timeout,
session);
return 0;
failed:
- g_free(req->msg);
+ g_free(req->data);
g_free(req);
return err;
}
static int send_request(struct avdtp *session, gboolean priority,
- struct avdtp_stream *stream, void *buffer, int size)
+ struct avdtp_stream *stream, uint8_t signal_id,
+ void *buffer, size_t size)
{
struct pending_req *req;
req = g_new0(struct pending_req, 1);
- req->msg = g_malloc(size);
- memcpy(req->msg, buffer, size);
- req->msg_size = size;
+ req->signal_id = signal_id;
+ req->data = g_malloc(size);
+ memcpy(req->data, buffer, size);
+ req->data_size = size;
req->stream = stream;
return send_req(session, priority, req);
static gboolean avdtp_discover_resp(struct avdtp *session,
struct discover_resp *resp, int size)
{
- int sep_count, i, isize = sizeof(struct seid_info);
+ int sep_count, i;
- sep_count = (size - sizeof(struct avdtp_header)) / isize;
+ sep_count = size / sizeof(struct seid_info);
for (i = 0; i < sep_count; i++) {
struct avdtp_remote_sep *sep;
sep->media_type = resp->seps[i].media_type;
memset(&req, 0, sizeof(req));
- init_request(&req.header, AVDTP_GET_CAPABILITIES);
req.acp_seid = sep->seid;
- ret = send_request(session, TRUE, NULL, &req, sizeof(req));
+ ret = send_request(session, TRUE, NULL,
+ AVDTP_GET_CAPABILITIES,
+ &req, sizeof(req));
if (ret < 0) {
finalize_discovery(session, ret);
break;
return FALSE;
}
- seid = ((struct seid_req *) session->req->msg)->acp_seid;
+ seid = ((struct seid_req *) session->req->data)->acp_seid;
sep = find_remote_sep(session->seps, seid);
sep->caps = caps_to_list(resp->caps, size - sizeof(struct getcap_resp),
&sep->codec);
-
return TRUE;
}
static gboolean avdtp_set_configuration_resp(struct avdtp *session,
struct avdtp_stream *stream,
- struct avdtp_header *resp,
+ struct avdtp_single_header *resp,
int size)
{
struct avdtp_local_sep *sep = stream->lsep;
static gboolean avdtp_reconfigure_resp(struct avdtp *session,
struct avdtp_stream *stream,
- struct avdtp_header *resp, int size)
+ struct avdtp_single_header *resp, int size)
{
return TRUE;
}
static gboolean avdtp_suspend_resp(struct avdtp *session,
struct avdtp_stream *stream,
- struct gen_resp *resp,
- int size)
+ void *data, int size)
{
struct avdtp_local_sep *sep = stream->lsep;
avdtp_sep_set_state(session, sep, AVDTP_STATE_OPEN);
+ if (stream->idle_timer)
+ g_source_remove(stream->idle_timer);
stream->idle_timer = g_timeout_add(STREAM_TIMEOUT,
(GSourceFunc) stream_timeout, stream);
static gboolean avdtp_parse_resp(struct avdtp *session,
struct avdtp_stream *stream,
- struct avdtp_header *header, int size)
+ uint8_t transaction, uint8_t signal_id,
+ void *buf, int size)
{
- struct avdtp_header *next;
+ struct pending_req *next;
if (session->prio_queue)
- next = ((struct pending_req *)
- (session->prio_queue->data))->msg;
+ next = session->prio_queue->data;
else if (session->req_queue)
- next = ((struct pending_req *)
- (session->req_queue->data))->msg;
+ next = session->req_queue->data;
else
next = NULL;
- switch (header->signal_id) {
+ switch (signal_id) {
case AVDTP_DISCOVER:
debug("DISCOVER request succeeded");
- return avdtp_discover_resp(session, (void *) header, size);
+ return avdtp_discover_resp(session, buf, size);
case AVDTP_GET_CAPABILITIES:
debug("GET_CAPABILITIES request succeeded");
- if (!avdtp_get_capabilities_resp(session,
- (void *) header, size))
+ if (!avdtp_get_capabilities_resp(session, buf, size))
return FALSE;
if (!(next && next->signal_id == AVDTP_GET_CAPABILITIES))
finalize_discovery(session, 0);
case AVDTP_SET_CONFIGURATION:
debug("SET_CONFIGURATION request succeeded");
return avdtp_set_configuration_resp(session, stream,
- (void *) header, size);
+ buf, size);
case AVDTP_RECONFIGURE:
debug("RECONFIGURE request succeeded");
- return avdtp_reconfigure_resp(session, stream,
- (void *) header, size);
+ return avdtp_reconfigure_resp(session, stream, buf, size);
case AVDTP_OPEN:
debug("OPEN request succeeded");
- return avdtp_open_resp(session, stream, (void *) header, size);
+ return avdtp_open_resp(session, stream, buf, size);
case AVDTP_SUSPEND:
debug("SUSPEND request succeeded");
- return avdtp_suspend_resp(session, stream,
- (void *) header, size);
+ return avdtp_suspend_resp(session, stream, buf, size);
case AVDTP_START:
debug("START request succeeded");
- return avdtp_start_resp(session, stream, (void *) header, size);
+ return avdtp_start_resp(session, stream, buf, size);
case AVDTP_CLOSE:
debug("CLOSE request succeeded");
- return avdtp_close_resp(session, stream, (void *) header, size);
+ return avdtp_close_resp(session, stream, buf, size);
case AVDTP_ABORT:
debug("ABORT request succeeded");
- return avdtp_abort_resp(session, stream, (void *) header, size);
+ return avdtp_abort_resp(session, stream, buf, size);
}
- error("Unknown signal id in accept response: %u", header->signal_id);
-
+ error("Unknown signal id in accept response: %u", signal_id);
return TRUE;
}
}
static gboolean avdtp_parse_rej(struct avdtp *session,
- struct avdtp_stream *stream,
- struct avdtp_header *header, int size)
+ struct avdtp_stream *stream,
+ uint8_t transaction, uint8_t signal_id,
+ void *buf, int size)
{
struct avdtp_error err;
uint8_t acp_seid, category;
struct avdtp_local_sep *sep = stream ? stream->lsep : NULL;
- switch (header->signal_id) {
+ switch (signal_id) {
case AVDTP_DISCOVER:
- if (!seid_rej_to_err((void *) header, size, &err))
+ if (!seid_rej_to_err(buf, size, &err))
return FALSE;
error("DISCOVER request rejected: %s (%d)",
avdtp_strerror(&err), err.err.error_code);
return TRUE;
case AVDTP_GET_CAPABILITIES:
- if (!seid_rej_to_err((void *) header, size, &err))
+ if (!seid_rej_to_err(buf, size, &err))
return FALSE;
error("GET_CAPABILITIES request rejected: %s (%d)",
avdtp_strerror(&err), err.err.error_code);
return TRUE;
case AVDTP_OPEN:
- if (!seid_rej_to_err((void *) header, size, &err))
+ if (!seid_rej_to_err(buf, size, &err))
return FALSE;
error("OPEN request rejected: %s (%d)",
avdtp_strerror(&err), err.err.error_code);
sep->user_data);
return TRUE;
case AVDTP_SET_CONFIGURATION:
- if (!conf_rej_to_err((void *) header, size, &err, &category))
+ if (!conf_rej_to_err(buf, size, &err, &category))
return FALSE;
error("SET_CONFIGURATION request rejected: %s (%d)",
avdtp_strerror(&err), err.err.error_code);
&err, sep->user_data);
return TRUE;
case AVDTP_RECONFIGURE:
- if (!conf_rej_to_err((void *) header, size, &err, &category))
+ if (!conf_rej_to_err(buf, size, &err, &category))
return FALSE;
error("RECONFIGURE request rejected: %s (%d)",
avdtp_strerror(&err), err.err.error_code);
sep->user_data);
return TRUE;
case AVDTP_START:
- if (!stream_rej_to_err((void *) header, size, &err, &acp_seid))
+ if (!stream_rej_to_err(buf, size, &err, &acp_seid))
return FALSE;
error("START request rejected: %s (%d)",
avdtp_strerror(&err), err.err.error_code);
sep->user_data);
return TRUE;
case AVDTP_SUSPEND:
- if (!stream_rej_to_err((void *) header, size, &err, &acp_seid))
+ if (!stream_rej_to_err(buf, size, &err, &acp_seid))
return FALSE;
error("SUSPEND request rejected: %s (%d)",
avdtp_strerror(&err), err.err.error_code);
sep->user_data);
return TRUE;
case AVDTP_CLOSE:
- if (!stream_rej_to_err((void *) header, size, &err, &acp_seid))
+ if (!stream_rej_to_err(buf, size, &err, &acp_seid))
return FALSE;
error("CLOSE request rejected: %s (%d)",
avdtp_strerror(&err), err.err.error_code);
sep->user_data);
return TRUE;
case AVDTP_ABORT:
- if (!stream_rej_to_err((void *) header, size, &err, &acp_seid))
+ if (!stream_rej_to_err(buf, size, &err, &acp_seid))
return FALSE;
error("ABORT request rejected: %s (%d)",
avdtp_strerror(&err), err.err.error_code);
sep->user_data);
return TRUE;
default:
- error("Unknown reject response signal id: %u",
- header->signal_id);
+ error("Unknown reject response signal id: %u", signal_id);
return TRUE;
}
}
int avdtp_discover(struct avdtp *session, avdtp_discover_cb_t cb,
void *user_data)
{
- struct gen_req req;
int ret;
if (session->discov_cb)
return 0;
}
- memset(&req, 0, sizeof(req));
- init_request(&req.header, AVDTP_DISCOVER);
-
- ret = send_request(session, FALSE, NULL, &req, sizeof(req));
+ ret = send_request(session, FALSE, NULL, AVDTP_DISCOVER, NULL, 0);
if (ret == 0) {
session->discov_cb = cb;
session->user_data = user_data;
return -EINVAL;
memset(&req, 0, sizeof(req));
- init_request(&req.header, AVDTP_GET_CONFIGURATION);
req.acp_seid = stream->rseid;
- return send_request(session, FALSE, stream, &req, sizeof(req));
+ return send_request(session, FALSE, stream, AVDTP_GET_CONFIGURATION,
+ &req, sizeof(req));
}
static void copy_capabilities(gpointer data, gpointer user_data)
req = g_malloc0(sizeof(struct setconf_req) + caps_len);
- init_request(&req->header, AVDTP_SET_CONFIGURATION);
req->int_seid = lsep->info.seid;
req->acp_seid = rsep->seid;
ptr += cap->length + 2;
}
- ret = send_request(session, FALSE, new_stream, req,
+ ret = send_request(session, FALSE, new_stream,
+ AVDTP_SET_CONFIGURATION, req,
sizeof(struct setconf_req) + caps_len);
if (ret < 0)
stream_free(new_stream);
{
struct reconf_req *req;
unsigned char *ptr;
- int caps_len;
+ int caps_len, err;
GSList *l;
struct avdtp_service_capability *cap;
req = g_malloc0(sizeof(struct reconf_req) + caps_len);
- init_request(&req->header, AVDTP_RECONFIGURE);
req->acp_seid = stream->rseid;
/* Copy the capabilities into the request */
ptr += cap->length + 2;
}
- return send_request(session, FALSE, stream, req, sizeof(*req)
- + caps_len);
+ err = send_request(session, FALSE, stream, AVDTP_RECONFIGURE, req,
+ sizeof(*req) + caps_len);
+ g_free(req);
+
+ return err;
}
int avdtp_open(struct avdtp *session, struct avdtp_stream *stream)
return -EINVAL;
memset(&req, 0, sizeof(req));
- init_request(&req.header, AVDTP_OPEN);
req.acp_seid = stream->rseid;
- return send_request(session, FALSE, stream, &req, sizeof(req));
+ return send_request(session, FALSE, stream, AVDTP_OPEN,
+ &req, sizeof(req));
}
int avdtp_start(struct avdtp *session, struct avdtp_stream *stream)
return -EINVAL;
memset(&req, 0, sizeof(req));
- init_request(&req.header, AVDTP_START);
req.first_seid.seid = stream->rseid;
- return send_request(session, FALSE, stream, &req, sizeof(req));
+ return send_request(session, FALSE, stream, AVDTP_START,
+ &req, sizeof(req));
}
int avdtp_close(struct avdtp *session, struct avdtp_stream *stream)
return -EINVAL;
memset(&req, 0, sizeof(req));
- init_request(&req.header, AVDTP_CLOSE);
req.acp_seid = stream->rseid;
- ret = send_request(session, FALSE, stream, &req, sizeof(req));
+ ret = send_request(session, FALSE, stream, AVDTP_CLOSE,
+ &req, sizeof(req));
if (ret == 0)
stream->close_int = TRUE;
return -EINVAL;
memset(&req, 0, sizeof(req));
- init_request(&req.header, AVDTP_SUSPEND);
req.acp_seid = stream->rseid;
- return send_request(session, FALSE, stream, &req, sizeof(req));
+ return send_request(session, FALSE, stream, AVDTP_SUSPEND,
+ &req, sizeof(req));
}
int avdtp_abort(struct avdtp *session, struct avdtp_stream *stream)
return -EINVAL;
memset(&req, 0, sizeof(req));
- init_request(&req.header, AVDTP_ABORT);
req.acp_seid = stream->rseid;
- ret = send_request(session, FALSE, stream, &req, sizeof(req));
+ ret = send_request(session, FALSE, stream, AVDTP_ABORT,
+ &req, sizeof(req));
if (ret == 0)
avdtp_sep_set_state(session, stream->lsep,
AVDTP_STATE_ABORTING);
return;
}
- session->buf = g_malloc0(session->mtu);
+ session->buf = g_malloc0(session->imtu);
session->stream_setup = TRUE;
set_disconnect_timer(session);
if (dev && dev->control)
device_set_control_timer(dev);
- g_source_remove(session->io);
+ if (session->io)
+ g_source_remove(session->io);
io = g_io_channel_unix_new(session->sock);
session->io = g_io_add_watch(io,
goto drop;
}
- session->mtu = l2o.imtu;
+ session->imtu = l2o.imtu;
+ session->omtu = l2o.omtu;
session->sock = sk;
+ debug("AVDTP imtu=%u, omtu=%u", session->imtu, session->omtu);
+
+ if (session->io)
+ g_source_remove(session->io);
session->io = g_io_add_watch(chan, G_IO_ERR | G_IO_HUP | G_IO_NVAL,
(GIOFunc) session_cb, session);
OSDN Git Service
