| /* |
| * |
| * BlueZ - Bluetooth protocol stack for Linux |
| * |
| * Copyright (C) 2010 Nokia Corporation |
| * Copyright (C) 2010 Marcel Holtmann <marcel@holtmann.org> |
| * |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| * |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include <stdio.h> |
| #include <stdint.h> |
| #include <stdbool.h> |
| #include <string.h> |
| |
| #include <glib.h> |
| |
| #include "lib/bluetooth.h" |
| |
| #include "btio/btio.h" |
| #include "src/log.h" |
| #include "src/shared/util.h" |
| #include "src/shared/att.h" |
| #include "src/shared/queue.h" |
| #include "attrib/gattrib.h" |
| |
| struct _GAttrib { |
| int ref_count; |
| struct bt_att *att; |
| GIOChannel *io; |
| GDestroyNotify destroy; |
| gpointer destroy_user_data; |
| struct queue *callbacks; |
| uint8_t *buf; |
| int buflen; |
| struct queue *track_ids; |
| }; |
| |
| struct id_pair { |
| unsigned int org_id; |
| unsigned int pend_id; |
| }; |
| |
| struct attrib_callbacks { |
| struct id_pair *id; |
| GAttribResultFunc result_func; |
| GAttribNotifyFunc notify_func; |
| GDestroyNotify destroy_func; |
| gpointer user_data; |
| GAttrib *parent; |
| uint16_t notify_handle; |
| }; |
| |
| static bool find_with_org_id(const void *data, const void *user_data) |
| { |
| const struct id_pair *p = data; |
| unsigned int orig_id = PTR_TO_UINT(user_data); |
| |
| return (p->org_id == orig_id); |
| } |
| |
| static struct id_pair *store_id(GAttrib *attrib, unsigned int org_id, |
| unsigned int pend_id) |
| { |
| struct id_pair *t; |
| |
| t = new0(struct id_pair, 1); |
| if (!t) |
| return NULL; |
| |
| t->org_id = org_id; |
| t->pend_id = pend_id; |
| |
| if (queue_push_tail(attrib->track_ids, t)) |
| return t; |
| |
| return NULL; |
| } |
| |
| GAttrib *g_attrib_new(GIOChannel *io, guint16 mtu, bool ext_signed) |
| { |
| gint fd; |
| GAttrib *attr; |
| |
| if (!io) |
| return NULL; |
| |
| fd = g_io_channel_unix_get_fd(io); |
| attr = new0(GAttrib, 1); |
| if (!attr) |
| return NULL; |
| |
| g_io_channel_ref(io); |
| attr->io = io; |
| |
| attr->att = bt_att_new(fd, ext_signed); |
| if (!attr->att) |
| goto fail; |
| |
| bt_att_set_close_on_unref(attr->att, true); |
| g_io_channel_set_close_on_unref(io, FALSE); |
| |
| if (!bt_att_set_mtu(attr->att, mtu)) |
| goto fail; |
| |
| attr->buf = malloc0(mtu); |
| attr->buflen = mtu; |
| if (!attr->buf) |
| goto fail; |
| |
| attr->callbacks = queue_new(); |
| if (!attr->callbacks) |
| goto fail; |
| |
| attr->track_ids = queue_new(); |
| if (!attr->track_ids) |
| goto fail; |
| |
| return g_attrib_ref(attr); |
| |
| fail: |
| free(attr->buf); |
| bt_att_unref(attr->att); |
| g_io_channel_unref(io); |
| free(attr); |
| return NULL; |
| } |
| |
| GAttrib *g_attrib_ref(GAttrib *attrib) |
| { |
| if (!attrib) |
| return NULL; |
| |
| __sync_fetch_and_add(&attrib->ref_count, 1); |
| |
| // suppress very common debug message |
| if (attrib->ref_count == 1 || attrib->ref_count > 20) |
| DBG("%p: g_attrib_ref=%d ", attrib, attrib->ref_count); |
| |
| return attrib; |
| } |
| |
| static void attrib_callbacks_destroy(void *data) |
| { |
| struct attrib_callbacks *cb = data; |
| |
| if (cb->destroy_func) |
| cb->destroy_func(cb->user_data); |
| |
| if (queue_remove(cb->parent->track_ids, cb->id)) |
| free(cb->id); |
| |
| free(data); |
| } |
| |
| static void attrib_callbacks_remove(void *data) |
| { |
| struct attrib_callbacks *cb = data; |
| |
| if (!data || !queue_remove(cb->parent->callbacks, data)) |
| return; |
| |
| attrib_callbacks_destroy(data); |
| } |
| |
| void g_attrib_unref(GAttrib *attrib) |
| { |
| if (!attrib) |
| return; |
| |
| // suppress very common debug message |
| if (attrib->ref_count - 1 == 0 || attrib->ref_count - 1 > 20) |
| DBG("%p: g_attrib_unref=%d ", attrib, attrib->ref_count - 1); |
| |
| if (__sync_sub_and_fetch(&attrib->ref_count, 1)) |
| return; |
| |
| if (attrib->destroy) |
| attrib->destroy(attrib->destroy_user_data); |
| |
| bt_att_unref(attrib->att); |
| |
| queue_destroy(attrib->callbacks, attrib_callbacks_destroy); |
| queue_destroy(attrib->track_ids, free); |
| |
| free(attrib->buf); |
| |
| g_io_channel_unref(attrib->io); |
| |
| free(attrib); |
| } |
| |
| GIOChannel *g_attrib_get_channel(GAttrib *attrib) |
| { |
| if (!attrib) |
| return NULL; |
| |
| return attrib->io; |
| } |
| |
| struct bt_att *g_attrib_get_att(GAttrib *attrib) |
| { |
| if (!attrib) |
| return NULL; |
| |
| return attrib->att; |
| } |
| |
| gboolean g_attrib_set_destroy_function(GAttrib *attrib, GDestroyNotify destroy, |
| gpointer user_data) |
| { |
| if (!attrib) |
| return FALSE; |
| |
| attrib->destroy = destroy; |
| attrib->destroy_user_data = user_data; |
| |
| return TRUE; |
| } |
| |
| |
| static uint8_t *construct_full_pdu(uint8_t opcode, const void *pdu, |
| uint16_t length) |
| { |
| uint8_t *buf = malloc0(length + 1); |
| |
| if (!buf) |
| return NULL; |
| |
| buf[0] = opcode; |
| memcpy(buf + 1, pdu, length); |
| |
| return buf; |
| } |
| |
| static void attrib_callback_result(uint8_t opcode, const void *pdu, |
| uint16_t length, void *user_data) |
| { |
| uint8_t *buf; |
| struct attrib_callbacks *cb = user_data; |
| guint8 status = 0; |
| |
| if (!cb) |
| return; |
| |
| buf = construct_full_pdu(opcode, pdu, length); |
| if (!buf) |
| return; |
| |
| if (opcode == BT_ATT_OP_ERROR_RSP) { |
| /* Error code is the third byte of the PDU data */ |
| if (length < 4) |
| status = BT_ATT_ERROR_UNLIKELY; |
| else |
| status = ((guint8 *)pdu)[3]; |
| } |
| |
| if (cb->result_func) |
| cb->result_func(status, buf, length + 1, cb->user_data); |
| |
| free(buf); |
| } |
| |
| static void attrib_callback_notify(uint8_t opcode, const void *pdu, |
| uint16_t length, void *user_data) |
| { |
| uint8_t *buf; |
| struct attrib_callbacks *cb = user_data; |
| |
| if (!cb || !cb->notify_func) |
| return; |
| |
| if (cb->notify_handle != GATTRIB_ALL_HANDLES && length < 2) |
| return; |
| |
| if (cb->notify_handle != GATTRIB_ALL_HANDLES && |
| cb->notify_handle != get_le16(pdu)) |
| return; |
| |
| buf = construct_full_pdu(opcode, pdu, length); |
| if (!buf) |
| return; |
| |
| cb->notify_func(buf, length + 1, cb->user_data); |
| |
| free(buf); |
| } |
| |
| guint g_attrib_send(GAttrib *attrib, guint id, const guint8 *pdu, guint16 len, |
| GAttribResultFunc func, gpointer user_data, |
| GDestroyNotify notify) |
| { |
| struct attrib_callbacks *cb = NULL; |
| bt_att_response_func_t response_cb = NULL; |
| bt_att_destroy_func_t destroy_cb = NULL; |
| unsigned int pend_id; |
| |
| if (!attrib) |
| return 0; |
| |
| if (!pdu || !len) |
| return 0; |
| |
| if (func || notify) { |
| cb = new0(struct attrib_callbacks, 1); |
| if (!cb) |
| return 0; |
| cb->result_func = func; |
| cb->user_data = user_data; |
| cb->destroy_func = notify; |
| cb->parent = attrib; |
| queue_push_head(attrib->callbacks, cb); |
| response_cb = attrib_callback_result; |
| destroy_cb = attrib_callbacks_remove; |
| |
| } |
| |
| pend_id = bt_att_send(attrib->att, pdu[0], (void *) pdu + 1, len - 1, |
| response_cb, cb, destroy_cb); |
| |
| /* |
| * We store here pair as it is easier to handle it in response and in |
| * case where user request us to use specific id request - see below. |
| */ |
| if (id == 0) |
| id = pend_id; |
| |
| /* |
| * If user what us to use given id, lets keep track on that so we give |
| * user a possibility to cancel ongoing request. |
| */ |
| if (cb) |
| cb->id = store_id(attrib, id, pend_id); |
| |
| return id; |
| } |
| |
| gboolean g_attrib_cancel(GAttrib *attrib, guint id) |
| { |
| struct id_pair *p; |
| |
| if (!attrib) |
| return FALSE; |
| |
| /* |
| * If request belongs to gattrib and is not yet done it has to be on |
| * the tracking id queue |
| * |
| * FIXME: It can happen that on the queue there is id_pair with |
| * given id which was provided by the user. In the same time it might |
| * happen that other attrib user got dynamic allocated req_id with same |
| * value as the one provided by the other user. |
| * In such case there are two clients having same request id and in |
| * this point of time we don't know which one calls cancel. For |
| * now we cancel request in which id was specified by the user. |
| */ |
| p = queue_remove_if(attrib->track_ids, find_with_org_id, |
| UINT_TO_PTR(id)); |
| if (!p) |
| return FALSE; |
| |
| id = p->pend_id; |
| free(p); |
| |
| return bt_att_cancel(attrib->att, id); |
| } |
| |
| static void cancel_request(void *data, void *user_data) |
| { |
| struct id_pair *p = data; |
| GAttrib *attrib = user_data; |
| |
| bt_att_cancel(attrib->att, p->pend_id); |
| } |
| |
| gboolean g_attrib_cancel_all(GAttrib *attrib) |
| { |
| if (!attrib) |
| return FALSE; |
| |
| /* Cancel only request which belongs to gattrib */ |
| queue_foreach(attrib->track_ids, cancel_request, attrib); |
| queue_remove_all(attrib->track_ids, NULL, NULL, free); |
| |
| return TRUE; |
| } |
| |
| guint g_attrib_register(GAttrib *attrib, guint8 opcode, guint16 handle, |
| GAttribNotifyFunc func, gpointer user_data, |
| GDestroyNotify notify) |
| { |
| struct attrib_callbacks *cb = NULL; |
| |
| if (!attrib) |
| return 0; |
| |
| if (func || notify) { |
| cb = new0(struct attrib_callbacks, 1); |
| if (!cb) |
| return 0; |
| cb->notify_func = func; |
| cb->notify_handle = handle; |
| cb->user_data = user_data; |
| cb->destroy_func = notify; |
| cb->parent = attrib; |
| queue_push_head(attrib->callbacks, cb); |
| } |
| |
| if (opcode == GATTRIB_ALL_REQS) |
| opcode = BT_ATT_ALL_REQUESTS; |
| |
| return bt_att_register(attrib->att, opcode, attrib_callback_notify, |
| cb, attrib_callbacks_remove); |
| } |
| |
| uint8_t *g_attrib_get_buffer(GAttrib *attrib, size_t *len) |
| { |
| uint16_t mtu; |
| |
| if (!attrib || !len) |
| return NULL; |
| |
| mtu = bt_att_get_mtu(attrib->att); |
| |
| /* |
| * Clients of this expect a buffer to use. |
| * |
| * Pdu encoding in shared/att verifies if whole buffer fits the mtu, |
| * thus we should set the buflen also when mtu is reduced. But we |
| * need to reallocate the buffer only if mtu is larger. |
| */ |
| if (mtu > attrib->buflen) |
| attrib->buf = g_realloc(attrib->buf, mtu); |
| |
| attrib->buflen = mtu; |
| *len = attrib->buflen; |
| return attrib->buf; |
| } |
| |
| int g_attrib_get_mtu(GAttrib *attrib) |
| { |
| if (!attrib) |
| return -1; |
| |
| return bt_att_get_mtu(attrib->att); |
| } |
| |
| gboolean g_attrib_set_mtu(GAttrib *attrib, int mtu) |
| { |
| if (!attrib) |
| return FALSE; |
| |
| /* |
| * Clients of this expect a buffer to use. |
| * |
| * Pdu encoding in sharred/att verifies if whole buffer fits the mtu, |
| * thus we should set the buflen also when mtu is reduced. But we |
| * need to reallocate the buffer only if mtu is larger. |
| */ |
| if (mtu > attrib->buflen) |
| attrib->buf = g_realloc(attrib->buf, mtu); |
| |
| attrib->buflen = mtu; |
| |
| return bt_att_set_mtu(attrib->att, mtu); |
| } |
| |
| gboolean g_attrib_unregister(GAttrib *attrib, guint id) |
| { |
| if (!attrib) |
| return FALSE; |
| |
| return bt_att_unregister(attrib->att, id); |
| } |
| |
| gboolean g_attrib_unregister_all(GAttrib *attrib) |
| { |
| if (!attrib) |
| return false; |
| |
| return bt_att_unregister_all(attrib->att); |
| } |