g_variant_get(parameters, "(i&sn@ay)", &result, &address, &data_len, &var);
data = (char *)g_variant_get_data(var);
- BT_DBG("Address [%s]", address);
- BT_DBG("Data len [%d]", data_len);
+ if(data) {
+ BT_DBG("Address [%s]", address);
+ BT_DBG("Data len [%d]", data_len);
- /* DEBUG */
- for (k = 0; k < data_len ; k++)
- BT_DBG("Data[%d] [0x%x]", k, data[k]);
+ /* DEBUG */
+ for (k = 0; k < data_len ; k++)
+ BT_DBG("Data[%d] [0x%x]", k, data[k]);
- if (data_len == 0) {
- BT_ERR("No data");
- g_variant_unref(var);
- return;
- }
-
- info = g_malloc0(sizeof(bluetooth_tds_transport_data_info_t));
- info->data_length = data_len;
- info->data = g_memdup(data, data_len);
+ if (data_len == 0) {
+ BT_ERR("No data");
+ g_variant_unref(var);
+ return;
+ }
- _bt_convert_addr_string_to_type(info->device_address.addr,
- address);
+ info = g_malloc0(sizeof(bluetooth_tds_transport_data_info_t));
+ info->data_length = data_len;
+ info->data = g_memdup(data, data_len);
- _bt_common_event_cb(BLUETOOTH_EVENT_TDS_TRANSPORT_DATA_RECEIVED,
- result, info,
- event_info->cb, event_info->user_data);
+ _bt_convert_addr_string_to_type(info->device_address.addr,
+ address);
- if (info->data) {
- g_free(info->data);
- g_free(info);
- }
+ _bt_common_event_cb(BLUETOOTH_EVENT_TDS_TRANSPORT_DATA_RECEIVED,
+ result, info,
+ event_info->cb, event_info->user_data);
+ if (info->data) {
+ g_free(info->data);
+ g_free(info);
+ }
+ }
g_variant_unref(var);
} else if (strcasecmp(signal_name, BT_TDS_ACTIVATION_RESULT) == 0) {
BT_DBG("TDS Control point Activation result");
DBG("UUID string [%s]\n", uuid_str);
_bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
memcpy(uuids + i * HAL_UUID_LEN, uuid, HAL_UUID_LEN);
+ g_free(uuid_str);
}
size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_UUIDS,
(HAL_UUID_LEN * uuid_count),
ret = _bt_hal_is_adapter_powered(&powered);
if (BT_STATUS_FAIL == ret) {
INFO("Adapter is not powered");
+ g_free(adapter_path);
*state = 0;
return ret;
}
_bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
- memcpy(ev.name, name, strlen(name));
+ memcpy(ev.name, name, strlen(name)+1);
ev.class_of_dev = cod;
handle_stack_msg event_cb = _bt_hal_get_stack_message_handler();
_bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
- memcpy(ev.name, name, strlen(name));
+ memcpy(ev.name, name, strlen(name)+1);
ev.class_of_dev = cod;
ev.pairing_variant = variant;
ev.passkey = passkey;
int i;
char a, b;
- if (data1 == NULL || data2 == NULL || mask == NULL);
+ if (data1 == NULL || data2 == NULL || mask == NULL)
return -1;
+
for (i = 0; i < data_len; i++) {
a = data1[i] & mask[i];
b = data2[i] & mask[i];
BT_HAL_BLUEZ_NAME, object_path, BT_HAL_PROPERTIES_INTERFACE, NULL,
&err);
if(proxy == NULL) {
+ g_free(object_path);
ERR("proxy == NULL, return");
return BT_STATUS_FAIL;
}
if (temp_value)
g_variant_unref(temp_value);
- for (i = 0; uuid_value[i] != NULL; i++) {
- DBG("Remote uuids %s, searched uuid: %s",
- uuid_value[i], remote_uuid);
- if (strcasecmp(uuid_value[i], remote_uuid) == 0) {
- result = BT_STATUS_SUCCESS;
- goto done;
+ if(uuid_value) {
+ for (i = 0; uuid_value[i] != NULL; i++) {
+ DBG("Remote uuids %s, searched uuid: %s",
+ uuid_value[i], remote_uuid);
+ if (strcasecmp(uuid_value[i], remote_uuid) == 0) {
+ result = BT_STATUS_SUCCESS;
+ goto done;
+ }
}
}
}
conn = _bt_hal_get_system_gconn();
if (conn == NULL) {
+ g_free(device_path);
ERR("conn is NULL");
return BT_STATUS_FAIL;
}
DBG("UUID string [%s]\n", uuid_str);
_bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
memcpy(uuids + i * BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
+ g_free(uuid_str);
}
size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_UUIDS,
(BT_HAL_STACK_UUID_SIZE * uuid_count), uuids);
conn = _bt_hal_get_system_gconn();
if (!conn) {
+ g_free(device_path);
ERR("_bt_hal_get_system_gconn failed");
return BT_STATUS_FAIL;
}
const gchar *name = NULL;
unsigned int cod = 0;
gint rssi = 0;
- uint8_t trust;
- uint8_t paired;
+ uint8_t trust=0;
+ uint8_t paired=0;
int connected = 0;
GByteArray *manufacturer_data = NULL;
const gchar *key;
DBG("UUID string [%s]\n", uuid_str);
_bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
memcpy(uuids + i * BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
+ g_free(uuid_str);
}
size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_UUIDS,
(BT_HAL_STACK_UUID_SIZE * uuid_count), uuids);
conn = _bt_hal_get_system_gconn();
if (!conn) {
+ g_free(device_path);
ERR("_bt_hal_get_system_gconn failed");
return BT_STATUS_FAIL;
}
continue;
while (g_variant_iter_next(iter, "&s", &name) &&
- g_variant_iter_next(iter, "&s", &value)) {
- DBG("name = %s, Value = %s", name, value);
+ g_variant_iter_next(iter, "&s", &val)) {
+ DBG("name = %s, Value = %s", name, val);
g_variant_iter_loop(iter, "s", &val);
- if (FALSE == _bt_hal_update_le_feature_support(name, value))
- ERR("Failed to update LE feature (name = %s, value = %s)", name, value);
+ if (FALSE == _bt_hal_update_le_feature_support(name, val))
+ ERR("Failed to update LE feature (name = %s, value = %s)", name, val);
}
g_variant_iter_free(iter);
DBG("Device class [%d] Property num [%d]", class, ev->num_props);
} else if (strcasecmp(key, "name") == 0) {
char *name = g_variant_dup_string(val, &len);
- size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_NAME,
- strlen(name) + 1, name);
- ev->num_props++;
- DBG("Device Name [%s] Property num [%d]", name, ev->num_props);
+ if(name) {
+ size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_NAME,
+ strlen(name) + 1, name);
+ ev->num_props++;
+ DBG("Device Name [%s] Property num [%d]", name, ev->num_props);
+ }
} else if (strcasecmp(key, "Connected") == 0) {
unsigned int connected = g_variant_get_uint32(val);
} else {
/* Name */
tmp_value = g_variant_lookup_value(value, "Name", G_VARIANT_TYPE_STRING);
+ g_variant_get(tmp_value, "s", &name);
g_variant_unref(tmp_value);
+
size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_NAME,
strlen(name) + 1, name);
ev->num_props++;
g_variant_get(msg, "(b)", &connected);
INFO("Connected device address[%s] connnected[%d]", address, connected);
+ g_free(address);
} else if (strcasecmp(property, "Paired") == 0) {
gboolean paired = FALSE;
struct hal_ev_bond_state_changed ev;
while (g_variant_iter_loop(&iter, "{sv}", &property, &value)) {
DBG("Property = %s \n", property);
if ((strcasecmp(property, "Equalizer") == 0) ||
- (strcasecmp(property, "Equalizer") == 0) ||
(strcasecmp(property, "Repeat") == 0) ||
(strcasecmp(property, "Shuffle") == 0) ||
(strcasecmp(property, "Scan") == 0)) {
/* Add GATT Service to DBUS */
if (__bt_hal_add_service_to_dbus(app_path, server_if, srvc_id) != BT_STATUS_SUCCESS)
goto failed;
+
+ g_free(app_path);
}
INFO("Successfully added service");
return BT_STATUS_SUCCESS;
failed:
- if (app_id)
- g_free(app_id);
+
+ g_free(app_id);
+
if (app_path)
g_free(app_path);
INFO("Service addition failed!!");
ERR("failed to register: %s", error->message);
g_error_free(error);
g_free(path);
-
+ g_free(app_id);
return BT_STATUS_FAIL;
}
g_free(path);
g_strfreev(line_argv);
g_free(serv_path);
-
+ g_free(app_id);
return BT_STATUS_FAIL;
}
return BT_STATUS_FAIL;
}
+ g_free(serv_path);
line_argv = g_strsplit_set(char_path, "/", 0);
serv_path = g_strdup_printf("/%s/%s/%s", line_argv[1], line_argv[2], line_argv[3]);
ev.channel_id = conn_info->channel_id;
ev.data_fd = conn_info->fd;
ev.channel_state = state;
- if (!event_cb)
+ if (!event_cb) {
ERR("HDP dbus handler callback not registered");
+ g_free(conn_info);
+ }
else
event_cb(HAL_EV_HDP_CONN_STATE, (void *)&ev, sizeof(ev));
dev_path = g_strdup_printf("%s/dev_%s", adapter_path, address);
if (!dev_path) {
ERR("Failed to create dev_path");
+ g_free(adapter_path);
return NULL;
}
memcpy(info.dsc_list, ev->descr, info.dl_len);
if (bt_hal_hid_cbacks->hid_info_cb)
- bt_hal_hid_cbacks->hid_info_cb((bt_bdaddr_t *) ev->bdaddr, info);
+ bt_hal_hid_cbacks->hid_info_cb((bt_bdaddr_t *) ev->bdaddr, &info);
}
static void __bt_hal_handle_proto_mode(void *buf, uint16_t len)
return BT_STATUS_UNSUPPORTED;
}
-static bt_status_t hidhost_set_info(bt_bdaddr_t *bd_addr, bthh_hid_info_t hid_info)
+static bt_status_t hidhost_set_info(bt_bdaddr_t *bd_addr, bthh_hid_info_t *hid_info)
{
DBG("");
return BT_STATUS_UNSUPPORTED;
static gboolean app_event_cb(GIOChannel *io, GIOCondition cond, gpointer data)
{
gsize len;
- unsigned int sent;
+ int sent;
rfcomm_cb_data_t *info = data;
rfcomm_conn_info_t *conn_info;
unsigned char buff[BT_HAL_RFCOMM_MAX_BUFFER_SIZE];
static gboolean stack_event_cb(GIOChannel *io, GIOCondition cond, gpointer data)
{
unsigned int len;
- unsigned int sent;
+ int sent;
rfcomm_cb_data_t *info = data;
rfcomm_conn_info_t *conn_info;
unsigned char buff[BT_HAL_RFCOMM_MAX_BUFFER_SIZE];
object_id = _bt_hal_register_new_gdbus_object(path, __new_connection);
if (object_id < 0) {
ERR("_bt_hal_register_new_gdbus_object failed");
+ g_free(path);
__rfcomm_delete_id(id);
return NULL;
}
rfcomm_cb_data_t *cb_data;
rfcomm_conn_info_t *conn;
char remote_addr[BT_HAL_ADDRESS_STRING_SIZE];
- char remote_uuid[BT_HAL_UUID_SIZE];
+ char remote_uuid[BT_HAL_UUID_STRING_LEN];
if (!addr) {
ERR("remote_addr is NULL");
DBG("Connecting to %s, uuid %s", remote_addr, remote_uuid);
conn = __rfcomm_create_conn_info(remote_addr, sock);
if (!conn) {
- __rfcomm_cb_data_remove(cb_data);
+ __bt_free_cb_data(cb_data);
return BT_STATUS_FAIL;
}
object_id = _bt_hal_register_new_gdbus_object(path, __new_server_connection);
if (object_id < 0) {
ERR("_bt_hal_register_new_gdbus_object failed");
+ g_free(path);
__rfcomm_delete_id(id);
return NULL;
}
int is_bt;
if (!uuid)
- return strcpy(buf, "NULL");
+ return strncpy(buf, "NULL", strlen("NULL"));
is_bt = !memcmp(&uuid[4], &BT_BASE_UUID[4], HAL_UUID_LEN - 4);
buf[i * 2 + shift] = '-';
shift++;
}
- sprintf(buf + i * 2 + shift, "%02x", uuid[i]);
+ snprintf(buf + i * 2 + shift, (HAL_UUID_LEN -(i * 2 + shift)), "%02x", uuid[i]);
}
return buf;
const uint8_t *p;
if (!bd_addr)
- return strcpy(buf, "NULL");
+ return strncpy(buf, "NULL", strlen("NULL"));
p = bd_addr->address;
int count = prop_len / sizeof(bt_bdaddr_t);
bt_bdaddr_t *addr = prop;
- strcat(str, "{");
+ strncat(str, "{", strlen("{"));
while (count--) {
- strcat(str, bdaddr2str(addr));
+ strncat(str, bdaddr2str(addr), MAX_ADDR_STR_LEN);
if (count)
- strcat(str, ", ");
+ strncat(str, ", ", strlen(", "));
addr++;
}
- strcat(str, "}");
+ strncat(str, "}", strlen("}"));
}
static void uuids2string(char *str, void *prop, int prop_len)
int count = prop_len / sizeof(bt_uuid_t);
bt_uuid_t *uuid = prop;
- strcat(str, "{");
+ strncat(str, "{", strlen("{"));
while (count--) {
- strcat(str, btuuid2str(uuid->uu));
+ strncat(str, btuuid2str(uuid->uu), MAX_UUID_STR_LEN);
if (count)
- strcat(str, ", ");
+ strncat(str, ", ", strlen(", "));
uuid++;
}
- strcat(str, "}");
+ strncat(str, "}", strlen("}"));
}
const char* bt_property_type_t2str(bt_property_type_t prop_type)
}
-static void local_le_feat2string(char *str, const bt_local_le_features_t *f)
+static void local_le_feat2string(char *str, const bt_local_le_features_t *f, int buf_len)
{
uint16_t scan_num;
+ int ret;
- str += sprintf(str, "{\n");
+ ret = snprintf(str, buf_len, "{\n");
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ return;
+ }
+ str += ret;
+ buf_len -= ret;
- str += sprintf(str, "Privacy supported: %s,\n",
+ ret = snprintf(str, buf_len, "Privacy supported: %s,\n",
f->local_privacy_enabled ? "TRUE" : "FALSE");
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ return;
+ }
+ str += ret;
+ buf_len -= ret;
- str += sprintf(str, "Num of advertising instances: %u,\n",
+ ret = snprintf(str, buf_len, "Num of advertising instances: %u,\n",
f->max_adv_instance);
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ return;
+ }
+ str += ret;
+ buf_len -= ret;
- str += sprintf(str, "PRA offloading support: %s,\n",
+ ret = snprintf(str, buf_len, "PRA offloading support: %s,\n",
f->rpa_offload_supported ? "TRUE" : "FALSE");
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ return;
+ }
+ str += ret;
+ buf_len -= ret;
- str += sprintf(str, "Num of offloaded IRKs: %u,\n",
+ ret = snprintf(str, buf_len, "Num of offloaded IRKs: %u,\n",
f->max_irk_list_size);
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ return;
+ }
+ str += ret;
+ buf_len -= ret;
- str += sprintf(str, "Num of offloaded scan filters: %u,\n",
+ ret = snprintf(str, buf_len, "Num of offloaded scan filters: %u,\n",
f->max_adv_filter_supported);
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ return;
+ }
+ str += ret;
+ buf_len -= ret;
scan_num = (f->scan_result_storage_size_hibyte << 8) +
f->scan_result_storage_size_lobyte;
- str += sprintf(str, "Num of offloaded scan results: %u,\n", scan_num);
+ ret = snprintf(str, buf_len, "Num of offloaded scan results: %u,\n", scan_num);
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ return;
+ }
+ str += ret;
+ buf_len -= ret;
- str += sprintf(str, "Activity & energy report support: %s\n",
+ ret = snprintf(str, buf_len, "Activity & energy report support: %s\n",
f->activity_energy_info_supported ? "TRUE" : "FALSE");
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ return;
+ }
+ str += ret;
+ buf_len -= ret;
- sprintf(str, "}");
+ ret = snprintf(str, buf_len, "}");
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ return;
+ }
}
const char *btproperty2str(const bt_property_t *property)
{
bt_service_record_t *rec;
static char buf[4096];
+ int buf_len = 4096;
+ int ret;
char *p;
- p = buf + sprintf(buf, "type=%s len=%d val=",
+ memset(buf, 0x00, 4096);
+ ret = snprintf(buf, buf_len, "type=%s len=%d val=",
bt_property_type_t2str(property->type),
property->len);
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ goto failed;
+ }
+ p = buf + ret;
+ buf_len -= ret;
switch (property->type) {
case BT_PROPERTY_BDNAME:
case BT_PROPERTY_REMOTE_FRIENDLY_NAME:
- snprintf(p, property->len + 1, "%s",
+ ret = snprintf(p, buf_len, "%s",
((bt_bdname_t *) property->val)->name);
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ goto failed;
+ }
+ buf_len -= ret;
break;
case BT_PROPERTY_BDADDR:
- sprintf(p, "%s", bdaddr2str((bt_bdaddr_t *) property->val));
+ ret = snprintf(p, buf_len, "%s", bdaddr2str((bt_bdaddr_t *) property->val));
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ goto failed;
+ }
+ buf_len -= ret;
break;
case BT_PROPERTY_CLASS_OF_DEVICE:
- sprintf(p, "%06x", *((unsigned int *) property->val));
+ ret = snprintf(p, buf_len, "%06x", *((unsigned int *) property->val));
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ goto failed;
+ }
+ buf_len -= ret;
break;
case BT_PROPERTY_TYPE_OF_DEVICE:
- sprintf(p, "%s", bt_device_type_t2str(
+ ret = snprintf(p, buf_len, "%s", bt_device_type_t2str(
*((bt_device_type_t *) property->val)));
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ goto failed;
+ }
+ buf_len -= ret;
break;
case BT_PROPERTY_REMOTE_RSSI:
- sprintf(p, "%d", *((char *) property->val));
+ ret = snprintf(p, buf_len, "%d", *((char *) property->val));
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ goto failed;
+ }
+ buf_len -= ret;
break;
case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT:
- sprintf(p, "%d", *((unsigned int *) property->val));
+ ret = snprintf(p, buf_len, "%d", *((unsigned int *) property->val));
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ goto failed;
+ }
+ buf_len -= ret;
break;
case BT_PROPERTY_ADAPTER_SCAN_MODE:
- sprintf(p, "%s",
+ ret = snprintf(p, buf_len, "%s",
bt_scan_mode_t2str(*((bt_scan_mode_t *) property->val)));
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ goto failed;
+ }
+ buf_len -= ret;
break;
case BT_PROPERTY_ADAPTER_BONDED_DEVICES:
bonded_devices2string(p, property->val, property->len);
break;
case BT_PROPERTY_SERVICE_RECORD:
rec = property->val;
- sprintf(p, "{%s, %d, %s}", btuuid2str(rec->uuid.uu),
+ ret = snprintf(p, "{%s, %d, %s}", btuuid2str(rec->uuid.uu),
rec->channel, rec->name);
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ goto failed;
+ }
+ buf_len -= ret;
break;
case BT_PROPERTY_LOCAL_LE_FEATURES:
- local_le_feat2string(p, property->val);
+ local_le_feat2string(p, property->val, buf_len);
break;
case BT_PROPERTY_REMOTE_VERSION_INFO:
case BT_PROPERTY_REMOTE_DEVICE_TIMESTAMP:
default:
- sprintf(p, "%p", property->val);
+ ret = snprintf(p, buf_len, "%p", property->val);
+ if (0 > ret) {
+ ERR("snprintf failed with %d", ret);
+ goto failed;
+ }
+ buf_len -= ret;
break;
}
+failed:
return buf;
}
const char* status2string(bt_status_t status)
{
- if (status >= BT_STATUS_SUCCESS && status <= BT_STATUS_RMT_DEV_DOWN)
+ if (status <= BT_STATUS_RMT_DEV_DOWN)
return status_str[status];
else {
BT_ERR("Invalid BT status from stack");
const uint8_t *p;
if (!bd_addr)
- return strcpy(buf, "NULL");
+ return strncpy(buf, "NULL", sizeof("NULL"));
p = bd_addr->address;
snprintf(buf, 18, "%02x:%02x:%02x:%02x:%02x:%02x",
static char buf[4096];
char *p;
- p = buf + sprintf(buf, "type=%s len=%d val=",
+ p = buf + snprintf(buf, 4096, "type=%s len=%d val=",
convert_property_type_2_str(property->type),
property->len);
{
uint16_t scan_num;
- str += sprintf(str, "{\n");
+ str += snprintf(str, strlen(str), "{\n");
str += sprintf(str, "Privacy supported: %s,\n",
f->local_privacy_enabled ? "TRUE" : "FALSE");
/** Callback for get hid info
* hid_info will contain attr_mask, sub_class, app_id, vendor_id, product_id, version, ctry_code, len
*/
-typedef void (* bthh_hid_info_callback)(bt_bdaddr_t *bd_addr, bthh_hid_info_t hid_info);
+typedef void (* bthh_hid_info_callback)(bt_bdaddr_t *bd_addr, bthh_hid_info_t *hid_info);
/** Callback for get protocol api.
* the protocol mode is one of the value from bthh_protocol_mode_t
bt_status_t (*virtual_unplug)(bt_bdaddr_t *bd_addr);
/** Set the HID device descriptor for the specified HID device. */
- bt_status_t (*set_info)(bt_bdaddr_t *bd_addr, bthh_hid_info_t hid_info );
+ bt_status_t (*set_info)(bt_bdaddr_t *bd_addr, bthh_hid_info_t *hid_info );
/** Get the HID proto mode. */
bt_status_t (*get_protocol) (bt_bdaddr_t *bd_addr, bthh_protocol_mode_t protocolMode);
break;
default:
event = OAL_EVENT_END;
+ g_free(event_data);
break;
}
event_data, sizeof(avrcp_ct_pass_cmd_t));
} else {
BT_ERR("Invalid pass through command key code");
+ g_free(event_data);
}
}
}
break;
case BTRC_MEDIA_ATTR_ID_PLAYING_TIME:
- if (p_attrs[idx].text != NULL) {
track_info->playing_time = g_ascii_strtoll(
(const gchar *)p_attrs[idx].text, NULL, 10);
- event_data->playing_time = track_info->playing_time;
- } else {
- BT_WARN("string is null!!!!!!!");
- }
+ event_data->playing_time = (uint64_t) track_info->playing_time;
break;
default:
break;
break;
default:
BT_ERR("Invalid Type [%d]", type);
+ g_free(event_data);
return OAL_STATUS_INVALID_PARAM;
}
MEDIA_ATTIRBUTE_STRING_LENGTH);
g_strlcpy((char *)event_data->artist_info, (const char *)track_info->artist_info,
MEDIA_ATTIRBUTE_STRING_LENGTH);
- event_data->playing_time = track_info->playing_time;
+ event_data->playing_time = (uint64_t)track_info->playing_time;
event_data->total_track = track_info->total_track;
event_data->track_number = track_info->track_number;
int ret;
btrc_register_notification_t response;
+ memset(&response, 0x00, sizeof(btrc_register_notification_t));
+
track_info.cur_track = meta_data->number;
/* Send Track Change notification */
- memcpy(&response.track, &track_info.cur_track, BTRC_UID_SIZE);
+ memcpy(&response.track, &track_info.cur_track, sizeof(uint32_t));
ret = avrcp_api->register_notification_rsp(
BTRC_EVT_TRACK_CHANGE, BTRC_NOTIFICATION_TYPE_CHANGED, &response);
if (ret != BT_STATUS_SUCCESS)
BT_ERR("AVRCP Not Enabled");
return ;
}
+ memset(&response, 0x00, sizeof(btrc_register_notification_t));
switch (event_id) {
case BTRC_EVT_PLAY_STATUS_CHANGED:
break;
case BTRC_EVT_TRACK_CHANGE:
registered_notifications.track_change = 1;
- memcpy(response.track, &track_info.cur_track, BTRC_UID_SIZE);
+ memcpy(response.track, &track_info.cur_track, sizeof(uint32_t));
ret = avrcp_api->register_notification_rsp(
BTRC_EVT_TRACK_CHANGE, BTRC_NOTIFICATION_TYPE_INTERIM, &response);
break;
BT_WARN("Server ID:%d recevied server Id:%d\n", gatt_servers[instance_id - 1].server_id, server_if);
}
}
- if (event->server_inst > 0) {
+ if ((event->server_inst > 0)&&(event->server_inst <= 10)) {
prev_state[event->server_inst - 1] = cur_adv_state[event->server_inst - 1];
new_state = (status == BT_STATUS_SUCCESS) ? !(prev_state[event->server_inst - 1]) : (prev_state[event->server_inst - 1]);
cur_adv_state[event->server_inst - 1] = new_state;
if (bd_addr == NULL) {
BT_ERR("Address is NULL");
+ if(event_data) {
+ g_free(event_data);
+ }
return;
}
}
default: {
BT_INFO("Invalid state");
+ if(event_data) {
+ g_free(event_data);
+ }
return;
}
}
if (bd_addr == NULL) {
BT_ERR("Address is NULL");
+ if(event_data) {
+ g_free(event_data);
+ }
return;
}
BT_INFO("HFP Audio state = [%d], BT Address = [%s]", state, bdt_bd2str((bt_address_t*)bd_addr, &bdstr));
}
default: {
BT_INFO("Invalid state");
+ if(event_data) {
+ g_free(event_data);
+ }
return;
}
}
} while (0)
static void connection_state_callback(bt_bdaddr_t *bd_addr, bthh_connection_state_t state);
-static void hid_info_callback(bt_bdaddr_t *bd_addr, bthh_hid_info_t hid_info);
+static void hid_info_callback(bt_bdaddr_t *bd_addr, bthh_hid_info_t *hid_info);
static void get_protocol_mode_callback(bt_bdaddr_t *bd_addr, bthh_status_t hh_status, bthh_protocol_mode_t mode);
static void idle_time_callback(bt_bdaddr_t *bd_addr, bthh_status_t hh_status, int idle_rate);
static void get_report_callback(bt_bdaddr_t *bd_addr, bthh_status_t hh_status, uint8_t* rpt_data, int rpt_size);
break;
case BTHH_CONN_STATE_CONNECTING:
case BTHH_CONN_STATE_DISCONNECTING:
+ if(event) {
+ g_free(event);
+ }
return;
case BTHH_CONN_STATE_FAILED_MOUSE_FROM_HOST:
event_type = OAL_EVENT_HID_DISCONNECTED;
case BTHH_CONN_STATE_UNKNOWN:
default:
BT_ERR("Unhandled Connection state %d", state);
+ if(event) {
+ g_free(event);
+ }
return;
}
send_event_bda_trace(event_type, event, sizeof(event_hid_conn_t), (bt_address_t*)bd_addr);
}
-static void hid_info_callback(bt_bdaddr_t *bd_addr, bthh_hid_info_t hid_info)
+static void hid_info_callback(bt_bdaddr_t *bd_addr, bthh_hid_info_t *hid_info)
{
BT_INFO("");
}
if (sock_fd < 0) {
BT_ERR("Bluetooth socket connect failed");
+ g_free(p_oal_client_info);
return sock_fd;
}
{
int adv_handle;
GSList *l;
- char *uuid_string = g_malloc0(BLUETOOTH_UUID_STRING_MAX);
+ char uuid_string[BLUETOOTH_UUID_STRING_MAX];
bluetooth_advertising_data_t adv;
bluetooth_scan_resp_data_t scan_rsp;
int result = BLUETOOTH_ERROR_NONE;
if (adapter_le_discovery_state == LE_DISCOVERY_STARTED ||
adapter_le_discovery_state == LE_DISCOVERY_STARTING) {
/*TODO Stop Discovery*/
- if (result != OAL_STATUS_SUCCESS)
- BT_ERR("Discover stop failed: %d", result);
__bt_le_update_discovery_status(FALSE);
}
result = le_disable(); //change
if (adapter_le_discovery_state == LE_DISCOVERY_STARTED ||
adapter_le_discovery_state == LE_DISCOVERY_STARTING) {
/*TODO Stop Discovery*/
- if (result != OAL_STATUS_SUCCESS)
- BT_ERR("Discover stop failed: %d", result);
__bt_le_update_discovery_status(FALSE);
}
result = le_disable();
if (adapter_discovery_state == ADAPTER_DISCOVERY_STARTED ||
adapter_discovery_state == ADAPTER_DISCOVERY_STARTING) {
/*TODO Stop Discovery*/
- if (result != OAL_STATUS_SUCCESS)
- BT_ERR("Discover stop failed: %d", result);
__bt_adapter_update_discovery_status(FALSE);
}
result = adapter_disable();
if (adapter_discovery_state == ADAPTER_DISCOVERY_STARTED ||
adapter_discovery_state == ADAPTER_DISCOVERY_STARTING) {
/*TODO Stop Discovery*/
- if (result != OAL_STATUS_SUCCESS)
- BT_ERR("Discover stop failed: %d", result);
__bt_adapter_update_discovery_status(FALSE);
}
result = adapter_disable();
int instance_id;
char *app;
- memset(¶m, 0x00, sizeof(bluetooth_gatt_server_response_params_t));
+ memset(¶m, 0x00, sizeof(bluetooth_gatt_server_update_value_t));
app = (char*)g_dbus_method_invocation_get_sender(context);
switch (event_type) {
case OAL_EVENT_ADAPTER_ENABLED:
case OAL_EVENT_ADAPTER_DISABLED:
- if (audio_event_cb) {
- BT_INFO("Event [%d] Audio callback registered, call it...", event_type);
+ if (audio_event_cb)
audio_event_cb(event_type, event_data);
- }
+ if (adapter_cb)
+ adapter_cb(event_type, event_data);
+ break;
case OAL_EVENT_OAL_INITIALISED_SUCCESS:
case OAL_EVENT_OAL_INITIALISED_FAILED:
case OAL_EVENT_ADAPTER_PROPERTY_ADDRESS:
BT_INFO("Bonding is ongoing, try update properties");
if (!trigger_bond_info->dev_info ||
(!trigger_bond_info->dev_info->name &&
- !incoming_bond_info->dev_info->alias) ||
+ !trigger_bond_info->dev_info->alias) ||
!trigger_bond_info->dev_info->address ||
trigger_bond_info->dev_info->uuid_count == 0) {
BT_INFO("Complete data is not present, Assigning rem_info");
BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
g_variant_new("(isi)", BLUETOOTH_ERROR_NONE,
address, ev->trust_val));
+ break;
}
case OAL_EVENT_RSSI_MONITORING_ENABLED: {
event_dev_rssi_info_t *ev = event_data;
if (g_strcmp0(pin_info->address, address) == 0) {
pin_info_list = g_slist_remove(pin_info_list, pin_info);
- g_free(pin_info->pin_code);
+ g_free(pin_info->address);
g_free(pin_info->pin_code);
g_free(pin_info);
break;
static void __bt_handle_gatt_server_service_added(event_gatts_srvc_prm_t *event)
{
int result = BLUETOOTH_ERROR_NONE;
- int svc_handle;
+ int svc_handle = 0;
int *handle;
int count;
bt_service_app_info_t *info = NULL;
len = strlen(address);
ret_if(len != BT_ADDRESS_STRING_SIZE - 1);
- strncpy(addr, address, len);
+ g_strlcpy(addr, address, BT_ADDRESS_STRING_SIZE);
addr[len-1] = 'X';
addr[len-2] = 'X';
param);
g_free(address);
} else if (strcasecmp(member, "ProfileStateChanged") == 0) {
- int state = 0;
- char *profile_uuid = NULL;
- bluetooth_device_address_t bd_addr;
+ int state = 0;
+ char *profile_uuid = NULL;
+ bluetooth_device_address_t bd_addr;
- g_variant_get(msg, "(si)", &profile_uuid, &state);
+ g_variant_get(msg, "(si)", &profile_uuid, &state);
- address = g_malloc0(BT_ADDRESS_STRING_SIZE);
+ address = g_malloc0(BT_ADDRESS_STRING_SIZE);
- _bt_convert_device_path_to_address(path, address);
- _bt_convert_addr_string_to_type(bd_addr.addr, address);
+ _bt_convert_device_path_to_address(path, address);
+ _bt_convert_addr_string_to_type(bd_addr.addr, address);
- _bt_convert_addr_string_to_secure_string(secure_address, address);
- BT_DBG("Address: %s", secure_address);
- BT_DBG("Profile UUID: %s", profile_uuid);
- BT_DBG("State: %d", state);
- }
+ _bt_convert_addr_string_to_secure_string(secure_address, address);
+ BT_DBG("Address: %s", secure_address);
+ BT_DBG("Profile UUID: %s", profile_uuid);
+ BT_DBG("State: %d", state);
+ g_free(address);
+ }
}
static gboolean __bt_parse_device_properties(GVariant *item,
bt_remote_dev_info_t *dev_info)
projects / platform / core / connectivity / bluetooth-frwk.git / commitdiff