3 * BlueZ - Bluetooth protocol stack for Linux
5 * Copyright (C) 2006-2010 Nokia Corporation
6 * Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
41 #include <bluetooth/bluetooth.h>
42 #include <bluetooth/sdp.h>
43 #include <bluetooth/sdp_lib.h>
44 #include <bluetooth/uuid.h>
47 #include "glib-helper.h"
55 static inline int create_filename(char *buf, size_t size,
56 const bdaddr_t *bdaddr, const char *name)
62 return create_name(buf, size, STORAGEDIR, addr, name);
65 int read_device_alias(const char *src, const char *dst, char *alias, size_t size)
67 char filename[PATH_MAX + 1], *tmp;
70 create_name(filename, PATH_MAX, STORAGEDIR, src, "aliases");
72 tmp = textfile_get(filename, dst);
76 err = snprintf(alias, size, "%s", tmp);
80 return err < 0 ? -EIO : 0;
83 int write_device_alias(const char *src, const char *dst, const char *alias)
85 char filename[PATH_MAX + 1];
87 create_name(filename, PATH_MAX, STORAGEDIR, src, "aliases");
89 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
91 return textfile_put(filename, dst, alias);
94 int write_discoverable_timeout(bdaddr_t *bdaddr, int timeout)
96 char filename[PATH_MAX + 1], str[32];
98 snprintf(str, sizeof(str), "%d", timeout);
100 create_filename(filename, PATH_MAX, bdaddr, "config");
102 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
104 return textfile_put(filename, "discovto", str);
107 int read_discoverable_timeout(const char *src, int *timeout)
109 char filename[PATH_MAX + 1], *str;
111 create_name(filename, PATH_MAX, STORAGEDIR, src, "config");
113 str = textfile_get(filename, "discovto");
117 if (sscanf(str, "%d", timeout) != 1) {
127 int write_pairable_timeout(bdaddr_t *bdaddr, int timeout)
129 char filename[PATH_MAX + 1], str[32];
131 snprintf(str, sizeof(str), "%d", timeout);
133 create_filename(filename, PATH_MAX, bdaddr, "config");
135 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
137 return textfile_put(filename, "pairto", str);
140 int read_pairable_timeout(const char *src, int *timeout)
142 char filename[PATH_MAX + 1], *str;
144 create_name(filename, PATH_MAX, STORAGEDIR, src, "config");
146 str = textfile_get(filename, "pairto");
150 if (sscanf(str, "%d", timeout) != 1) {
160 int write_device_mode(bdaddr_t *bdaddr, const char *mode)
162 char filename[PATH_MAX + 1];
164 create_filename(filename, PATH_MAX, bdaddr, "config");
166 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
168 if (strcmp(mode, "off") != 0)
169 textfile_put(filename, "onmode", mode);
171 return textfile_put(filename, "mode", mode);
174 int read_device_mode(const char *src, char *mode, int length)
176 char filename[PATH_MAX + 1], *str;
178 create_name(filename, PATH_MAX, STORAGEDIR, src, "config");
180 str = textfile_get(filename, "mode");
184 strncpy(mode, str, length);
185 mode[length - 1] = '\0';
192 int read_on_mode(const char *src, char *mode, int length)
194 char filename[PATH_MAX + 1], *str;
196 create_name(filename, PATH_MAX, STORAGEDIR, src, "config");
198 str = textfile_get(filename, "onmode");
202 strncpy(mode, str, length);
203 mode[length - 1] = '\0';
210 int write_local_name(bdaddr_t *bdaddr, const char *name)
212 char filename[PATH_MAX + 1], str[249];
215 memset(str, 0, sizeof(str));
216 for (i = 0; i < 248 && name[i]; i++)
217 if ((unsigned char) name[i] < 32 || name[i] == 127)
222 create_filename(filename, PATH_MAX, bdaddr, "config");
224 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
226 return textfile_put(filename, "name", str);
229 int read_local_name(bdaddr_t *bdaddr, char *name)
231 char filename[PATH_MAX + 1], *str;
234 create_filename(filename, PATH_MAX, bdaddr, "config");
236 str = textfile_get(filename, "name");
241 if (len > HCI_MAX_NAME_LENGTH)
242 str[HCI_MAX_NAME_LENGTH] = '\0';
250 int write_local_class(bdaddr_t *bdaddr, uint8_t *class)
252 char filename[PATH_MAX + 1], str[9];
254 sprintf(str, "0x%2.2x%2.2x%2.2x", class[2], class[1], class[0]);
256 create_filename(filename, PATH_MAX, bdaddr, "config");
258 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
260 return textfile_put(filename, "class", str);
263 int read_local_class(bdaddr_t *bdaddr, uint8_t *class)
265 char filename[PATH_MAX + 1], tmp[3], *str;
268 create_filename(filename, PATH_MAX, bdaddr, "config");
270 str = textfile_get(filename, "class");
274 memset(tmp, 0, sizeof(tmp));
275 for (i = 0; i < 3; i++) {
276 memcpy(tmp, str + (i * 2) + 2, 2);
277 class[2 - i] = (uint8_t) strtol(tmp, NULL, 16);
285 int read_remote_appearance(bdaddr_t *local, bdaddr_t *peer, uint8_t bdaddr_type,
286 uint16_t *appearance)
288 char filename[PATH_MAX + 1], key[20], *str;
290 create_filename(filename, PATH_MAX, local, "appearances");
293 sprintf(&key[17], "#%hhu", bdaddr_type);
295 str = textfile_get(filename, key);
299 if (sscanf(str, "%hx", appearance) != 1) {
309 int write_remote_appearance(bdaddr_t *local, bdaddr_t *peer,
310 uint8_t bdaddr_type, uint16_t appearance)
312 char filename[PATH_MAX + 1], key[20], str[7];
314 create_filename(filename, PATH_MAX, local, "appearances");
316 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
319 sprintf(&key[17], "#%hhu", bdaddr_type);
321 sprintf(str, "0x%4.4x", appearance);
323 return textfile_put(filename, key, str);
326 int write_remote_class(bdaddr_t *local, bdaddr_t *peer, uint32_t class)
328 char filename[PATH_MAX + 1], addr[18], str[9];
330 create_filename(filename, PATH_MAX, local, "classes");
332 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
335 sprintf(str, "0x%6.6x", class);
337 return textfile_put(filename, addr, str);
340 int read_remote_class(bdaddr_t *local, bdaddr_t *peer, uint32_t *class)
342 char filename[PATH_MAX + 1], addr[18], *str;
344 create_filename(filename, PATH_MAX, local, "classes");
348 str = textfile_get(filename, addr);
352 if (sscanf(str, "%x", class) != 1) {
362 int write_device_name(bdaddr_t *local, bdaddr_t *peer, char *name)
364 char filename[PATH_MAX + 1], addr[18], str[HCI_MAX_NAME_LENGTH + 1];
367 memset(str, 0, sizeof(str));
368 for (i = 0; i < HCI_MAX_NAME_LENGTH && name[i]; i++)
369 if ((unsigned char) name[i] < 32 || name[i] == 127)
374 create_filename(filename, PATH_MAX, local, "names");
376 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
379 return textfile_put(filename, addr, str);
382 int read_device_name(const char *src, const char *dst, char *name)
384 char filename[PATH_MAX + 1], *str;
387 create_name(filename, PATH_MAX, STORAGEDIR, src, "names");
389 str = textfile_get(filename, dst);
394 if (len > HCI_MAX_NAME_LENGTH)
395 str[HCI_MAX_NAME_LENGTH] = '\0';
403 int write_remote_eir(bdaddr_t *local, bdaddr_t *peer, uint8_t *data,
406 char filename[PATH_MAX + 1], addr[18], str[481];
409 memset(str, 0, sizeof(str));
410 for (i = 0; i < data_len; i++)
411 sprintf(str + (i * 2), "%2.2X", data[i]);
413 create_filename(filename, PATH_MAX, local, "eir");
415 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
418 return textfile_put(filename, addr, str);
421 int read_remote_eir(bdaddr_t *local, bdaddr_t *peer, uint8_t *data)
423 char filename[PATH_MAX + 1], addr[18], *str;
426 create_filename(filename, PATH_MAX, local, "eir");
430 str = textfile_get(filename, addr);
439 if (strlen(str) < 480) {
444 for (i = 0; i < HCI_MAX_EIR_LENGTH; i++)
445 sscanf(str + (i * 2), "%02hhX", &data[i]);
452 int write_version_info(bdaddr_t *local, bdaddr_t *peer, uint16_t manufacturer,
453 uint8_t lmp_ver, uint16_t lmp_subver)
455 char filename[PATH_MAX + 1], addr[18], str[16];
457 memset(str, 0, sizeof(str));
458 sprintf(str, "%d %d %d", manufacturer, lmp_ver, lmp_subver);
460 create_filename(filename, PATH_MAX, local, "manufacturers");
462 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
465 return textfile_put(filename, addr, str);
468 int write_features_info(bdaddr_t *local, bdaddr_t *peer,
469 unsigned char *page1, unsigned char *page2)
471 char filename[PATH_MAX + 1], addr[18];
472 char str[] = "0000000000000000 0000000000000000";
478 create_filename(filename, PATH_MAX, local, "features");
479 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
481 old_value = textfile_get(filename, addr);
484 for (i = 0; i < 8; i++)
485 sprintf(str + (i * 2), "%2.2X", page1[i]);
486 else if (old_value && strlen(old_value) >= 16)
487 strncpy(str, old_value, 16);
490 for (i = 0; i < 8; i++)
491 sprintf(str + 17 + (i * 2), "%2.2X", page2[i]);
492 else if (old_value && strlen(old_value) >= 33)
493 strncpy(str + 17, old_value + 17, 16);
497 return textfile_put(filename, addr, str);
500 static int decode_bytes(const char *str, unsigned char *bytes, size_t len)
504 for (i = 0; i < len; i++) {
505 if (sscanf(str + (i * 2), "%02hhX", &bytes[i]) != 1)
512 int read_remote_features(bdaddr_t *local, bdaddr_t *peer,
513 unsigned char *page1, unsigned char *page2)
515 char filename[PATH_MAX + 1], addr[18], *str;
519 if (page1 == NULL && page2 == NULL)
522 create_filename(filename, PATH_MAX, local, "features");
526 str = textfile_get(filename, addr);
534 if (page1 && len >= 16)
535 err = decode_bytes(str, page1, 8);
537 if (page2 && len >= 33)
538 err = decode_bytes(str + 17, page2, 8);
545 int write_lastseen_info(bdaddr_t *local, bdaddr_t *peer, struct tm *tm)
547 char filename[PATH_MAX + 1], addr[18], str[24];
549 memset(str, 0, sizeof(str));
550 strftime(str, sizeof(str), "%Y-%m-%d %H:%M:%S %Z", tm);
552 create_filename(filename, PATH_MAX, local, "lastseen");
554 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
557 return textfile_put(filename, addr, str);
560 int write_lastused_info(bdaddr_t *local, bdaddr_t *peer, struct tm *tm)
562 char filename[PATH_MAX + 1], addr[18], str[24];
564 memset(str, 0, sizeof(str));
565 strftime(str, sizeof(str), "%Y-%m-%d %H:%M:%S %Z", tm);
567 create_filename(filename, PATH_MAX, local, "lastused");
569 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
572 return textfile_put(filename, addr, str);
575 int write_link_key(bdaddr_t *local, bdaddr_t *peer, unsigned char *key, uint8_t type, int length)
577 char filename[PATH_MAX + 1], addr[18], str[38];
580 memset(str, 0, sizeof(str));
581 for (i = 0; i < 16; i++)
582 sprintf(str + (i * 2), "%2.2X", key[i]);
583 sprintf(str + 32, " %d %d", type, length);
585 create_filename(filename, PATH_MAX, local, "linkkeys");
587 create_file(filename, S_IRUSR | S_IWUSR);
592 char *tmp = textfile_get(filename, addr);
594 if (strlen(tmp) > 34)
595 memcpy(str + 34, tmp + 34, 3);
600 return textfile_put(filename, addr, str);
603 int read_link_key(bdaddr_t *local, bdaddr_t *peer, unsigned char *key, uint8_t *type)
605 char filename[PATH_MAX + 1], addr[18], tmp[3], *str;
608 create_filename(filename, PATH_MAX, local, "linkkeys");
611 str = textfile_get(filename, addr);
620 memset(tmp, 0, sizeof(tmp));
621 for (i = 0; i < 16; i++) {
622 memcpy(tmp, str + (i * 2), 2);
623 key[i] = (uint8_t) strtol(tmp, NULL, 16);
627 memcpy(tmp, str + 33, 2);
628 *type = (uint8_t) strtol(tmp, NULL, 10);
636 ssize_t read_pin_code(bdaddr_t *local, bdaddr_t *peer, char *pin)
638 char filename[PATH_MAX + 1], addr[18], *str;
641 create_filename(filename, PATH_MAX, local, "pincodes");
644 str = textfile_get(filename, addr);
648 strncpy(pin, str, 16);
656 static GSList *service_string_to_list(char *services)
659 char *start = services;
662 for (i = 0; !finished; i++) {
663 if (services[i] == '\0')
666 if (services[i] == ' ' || services[i] == '\0') {
668 l = g_slist_append(l, start);
669 start = services + i + 1;
676 static char *service_list_to_string(GSList *services)
684 memset(str, 0, sizeof(str));
688 char *ident = services->data;
690 ret = snprintf(str + len, sizeof(str) - len - 1, "%s%s",
691 ident, services->next ? " " : "");
696 services = services->next;
699 return g_strdup(str);
702 int write_trust(const char *src, const char *addr, const char *service,
705 char filename[PATH_MAX + 1], *str;
706 GSList *services = NULL, *match;
710 create_name(filename, PATH_MAX, STORAGEDIR, src, "trusts");
712 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
714 str = textfile_caseget(filename, addr);
716 services = service_string_to_list(str);
718 match = g_slist_find_custom(services, service, (GCompareFunc) strcmp);
719 trusted = match ? TRUE : FALSE;
721 /* If the old setting is the same as the requested one, we're done */
722 if (trusted == trust) {
723 g_slist_free(services);
729 services = g_slist_append(services, (void *) service);
731 services = g_slist_remove(services, match->data);
733 /* Remove the entry if the last trusted service was removed */
734 if (!trust && !services)
735 ret = textfile_casedel(filename, addr);
737 char *new_str = service_list_to_string(services);
738 ret = textfile_caseput(filename, addr, new_str);
742 g_slist_free(services);
749 gboolean read_trust(const bdaddr_t *local, const char *addr, const char *service)
751 char filename[PATH_MAX + 1], *str;
755 create_filename(filename, PATH_MAX, local, "trusts");
757 str = textfile_caseget(filename, addr);
761 services = service_string_to_list(str);
763 if (g_slist_find_custom(services, service, (GCompareFunc) strcmp))
768 g_slist_free(services);
774 int write_device_profiles(bdaddr_t *src, bdaddr_t *dst, const char *profiles)
776 char filename[PATH_MAX + 1], addr[18];
781 create_filename(filename, PATH_MAX, src, "profiles");
783 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
786 return textfile_put(filename, addr, profiles);
789 int delete_entry(bdaddr_t *src, const char *storage, const char *key)
791 char filename[PATH_MAX + 1];
793 create_filename(filename, PATH_MAX, src, storage);
795 return textfile_del(filename, key);
798 int store_record(const gchar *src, const gchar *dst, sdp_record_t *rec)
800 char filename[PATH_MAX + 1], key[28];
805 create_name(filename, PATH_MAX, STORAGEDIR, src, "sdp");
807 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
809 snprintf(key, sizeof(key), "%17s#%08X", dst, rec->handle);
811 if (sdp_gen_record_pdu(rec, &buf) < 0)
814 size = buf.data_size;
816 str = g_malloc0(size*2+1);
818 for (i = 0; i < size; i++)
819 sprintf(str + (i * 2), "%02X", buf.data[i]);
821 err = textfile_put(filename, key, str);
829 sdp_record_t *record_from_string(const gchar *str)
836 size = strlen(str)/2;
837 pdata = g_malloc0(size);
840 for (i = 0; i < size; i++) {
841 memcpy(tmp, str + (i * 2), 2);
842 pdata[i] = (uint8_t) strtol(tmp, NULL, 16);
845 rec = sdp_extract_pdu(pdata, size, &len);
852 sdp_record_t *fetch_record(const gchar *src, const gchar *dst,
853 const uint32_t handle)
855 char filename[PATH_MAX + 1], key[28], *str;
858 create_name(filename, PATH_MAX, STORAGEDIR, src, "sdp");
860 snprintf(key, sizeof(key), "%17s#%08X", dst, handle);
862 str = textfile_get(filename, key);
866 rec = record_from_string(str);
872 int delete_record(const gchar *src, const gchar *dst, const uint32_t handle)
874 char filename[PATH_MAX + 1], key[28];
876 create_name(filename, PATH_MAX, STORAGEDIR, src, "sdp");
878 snprintf(key, sizeof(key), "%17s#%08X", dst, handle);
880 return textfile_del(filename, key);
888 static void create_stored_records_from_keys(char *key, char *value,
891 struct record_list *rec_list = user_data;
892 const gchar *addr = rec_list->addr;
895 if (strncmp(key, addr, 17))
898 rec = record_from_string(value);
900 rec_list->recs = sdp_list_append(rec_list->recs, rec);
903 void delete_all_records(const bdaddr_t *src, const bdaddr_t *dst)
905 sdp_list_t *records, *seq;
906 char srcaddr[18], dstaddr[18];
908 ba2str(src, srcaddr);
909 ba2str(dst, dstaddr);
911 records = read_records(src, dst);
913 for (seq = records; seq; seq = seq->next) {
914 sdp_record_t *rec = seq->data;
915 delete_record(srcaddr, dstaddr, rec->handle);
919 sdp_list_free(records, (sdp_free_func_t) sdp_record_free);
922 sdp_list_t *read_records(const bdaddr_t *src, const bdaddr_t *dst)
924 char filename[PATH_MAX + 1];
925 struct record_list rec_list;
926 char srcaddr[18], dstaddr[18];
928 ba2str(src, srcaddr);
929 ba2str(dst, dstaddr);
931 rec_list.addr = dstaddr;
932 rec_list.recs = NULL;
934 create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "sdp");
935 textfile_foreach(filename, create_stored_records_from_keys, &rec_list);
937 return rec_list.recs;
940 sdp_record_t *find_record_in_list(sdp_list_t *recs, const char *uuid)
944 for (seq = recs; seq; seq = seq->next) {
945 sdp_record_t *rec = (sdp_record_t *) seq->data;
946 sdp_list_t *svcclass = NULL;
949 if (sdp_get_service_classes(rec, &svcclass) < 0)
952 /* Extract the uuid */
953 uuid_str = bt_uuid2string(svcclass->data);
957 if (!strcasecmp(uuid_str, uuid)) {
958 sdp_list_free(svcclass, free);
963 sdp_list_free(svcclass, free);
969 int store_device_id(const gchar *src, const gchar *dst,
970 const uint16_t source, const uint16_t vendor,
971 const uint16_t product, const uint16_t version)
973 char filename[PATH_MAX + 1], str[20];
975 create_name(filename, PATH_MAX, STORAGEDIR, src, "did");
977 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
979 snprintf(str, sizeof(str), "%04X %04X %04X %04X", source,
980 vendor, product, version);
982 return textfile_put(filename, dst, str);
985 static int read_device_id_from_did(const gchar *src, const gchar *dst,
986 uint16_t *source, uint16_t *vendor,
987 uint16_t *product, uint16_t *version)
989 char filename[PATH_MAX + 1];
990 char *str, *vendor_str, *product_str, *version_str;
992 create_name(filename, PATH_MAX, STORAGEDIR, src, "did");
994 str = textfile_get(filename, dst);
998 vendor_str = strchr(str, ' ');
1003 *(vendor_str++) = 0;
1005 product_str = strchr(vendor_str, ' ');
1010 *(product_str++) = 0;
1012 version_str = strchr(product_str, ' ');
1017 *(version_str++) = 0;
1020 *source = (uint16_t) strtol(str, NULL, 16);
1022 *vendor = (uint16_t) strtol(vendor_str, NULL, 16);
1024 *product = (uint16_t) strtol(product_str, NULL, 16);
1026 *version = (uint16_t) strtol(version_str, NULL, 16);
1033 int read_device_id(const gchar *srcaddr, const gchar *dstaddr,
1034 uint16_t *source, uint16_t *vendor,
1035 uint16_t *product, uint16_t *version)
1037 uint16_t lsource, lvendor, lproduct, lversion;
1043 err = read_device_id_from_did(srcaddr, dstaddr, &lsource,
1044 vendor, product, version);
1046 if (lsource == 0xffff)
1052 str2ba(srcaddr, &src);
1053 str2ba(dstaddr, &dst);
1055 recs = read_records(&src, &dst);
1056 rec = find_record_in_list(recs, PNP_UUID);
1061 pdlist = sdp_data_get(rec, SDP_ATTR_VENDOR_ID_SOURCE);
1062 lsource = pdlist ? pdlist->val.uint16 : 0x0000;
1064 pdlist = sdp_data_get(rec, SDP_ATTR_VENDOR_ID);
1065 lvendor = pdlist ? pdlist->val.uint16 : 0x0000;
1067 pdlist = sdp_data_get(rec, SDP_ATTR_PRODUCT_ID);
1068 lproduct = pdlist ? pdlist->val.uint16 : 0x0000;
1070 pdlist = sdp_data_get(rec, SDP_ATTR_VERSION);
1071 lversion = pdlist ? pdlist->val.uint16 : 0x0000;
1076 sdp_list_free(recs, (sdp_free_func_t)sdp_record_free);
1079 /* FIXME: We should try EIR data if we have it, too */
1081 /* If we don't have the data, we don't want to go through the
1082 * above search every time. */
1089 store_device_id(srcaddr, dstaddr, lsource, lvendor, lproduct, lversion);
1099 *product = lproduct;
1101 *version = lversion;
1106 int write_device_pairable(bdaddr_t *bdaddr, gboolean mode)
1108 char filename[PATH_MAX + 1];
1110 create_filename(filename, PATH_MAX, bdaddr, "config");
1112 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
1114 return textfile_put(filename, "pairable", mode ? "yes" : "no");
1117 int read_device_pairable(bdaddr_t *bdaddr, gboolean *mode)
1119 char filename[PATH_MAX + 1], *str;
1121 create_filename(filename, PATH_MAX, bdaddr, "config");
1123 str = textfile_get(filename, "pairable");
1127 *mode = strcmp(str, "yes") == 0 ? TRUE : FALSE;
1134 gboolean read_blocked(const bdaddr_t *local, const bdaddr_t *remote)
1136 char filename[PATH_MAX + 1], *str, addr[18];
1138 create_filename(filename, PATH_MAX, local, "blocked");
1140 ba2str(remote, addr);
1142 str = textfile_caseget(filename, addr);
1151 int write_blocked(const bdaddr_t *local, const bdaddr_t *remote,
1154 char filename[PATH_MAX + 1], addr[18];
1156 create_filename(filename, PATH_MAX, local, "blocked");
1158 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
1160 ba2str(remote, addr);
1162 if (blocked == FALSE)
1163 return textfile_casedel(filename, addr);
1165 return textfile_caseput(filename, addr, "");
1168 int write_device_services(const bdaddr_t *sba, const bdaddr_t *dba,
1169 uint8_t bdaddr_type, const char *services)
1171 char filename[PATH_MAX + 1], key[20];
1173 create_filename(filename, PATH_MAX, sba, "primaries");
1175 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
1178 sprintf(&key[17], "#%hhu", bdaddr_type);
1180 return textfile_put(filename, key, services);
1183 static void filter_keys(char *key, char *value, void *data)
1185 struct match *match = data;
1187 if (strncasecmp(key, match->pattern, strlen(match->pattern)) == 0)
1188 match->keys = g_slist_append(match->keys, g_strdup(key));
1191 static void delete_by_pattern(const char *filename, char *pattern)
1197 memset(&match, 0, sizeof(match));
1198 match.pattern = pattern;
1200 err = textfile_foreach(filename, filter_keys, &match);
1204 for (l = match.keys; l; l = l->next) {
1205 const char *key = l->data;
1206 textfile_del(filename, key);
1210 g_slist_free_full(match.keys, g_free);
1213 int delete_device_service(const bdaddr_t *sba, const bdaddr_t *dba,
1214 uint8_t bdaddr_type)
1216 char filename[PATH_MAX + 1], key[20];
1218 memset(key, 0, sizeof(key));
1221 sprintf(&key[17], "#%hhu", bdaddr_type);
1223 /* Deleting all characteristics of a given key */
1224 create_filename(filename, PATH_MAX, sba, "characteristics");
1225 delete_by_pattern(filename, key);
1227 /* Deleting all attributes values of a given key */
1228 create_filename(filename, PATH_MAX, sba, "attributes");
1229 delete_by_pattern(filename, key);
1231 /* Deleting all CCC values of a given key */
1232 create_filename(filename, PATH_MAX, sba, "ccc");
1233 delete_by_pattern(filename, key);
1235 create_filename(filename, PATH_MAX, sba, "primaries");
1237 return textfile_del(filename, key);
1240 char *read_device_services(const bdaddr_t *sba, const bdaddr_t *dba,
1241 uint8_t bdaddr_type)
1243 char filename[PATH_MAX + 1], key[20];
1245 create_filename(filename, PATH_MAX, sba, "primaries");
1248 sprintf(&key[17], "#%hhu", bdaddr_type);
1250 return textfile_caseget(filename, key);
1253 int write_device_characteristics(const bdaddr_t *sba, const bdaddr_t *dba,
1254 uint8_t bdaddr_type, uint16_t handle,
1257 char filename[PATH_MAX + 1], addr[18], key[25];
1259 create_filename(filename, PATH_MAX, sba, "characteristics");
1261 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
1264 snprintf(key, sizeof(key), "%17s#%hhu#%04X", addr, bdaddr_type, handle);
1266 return textfile_put(filename, key, chars);
1269 char *read_device_characteristics(const bdaddr_t *sba, const bdaddr_t *dba,
1270 uint8_t bdaddr_type, uint16_t handle)
1272 char filename[PATH_MAX + 1], addr[18], key[25];
1274 create_filename(filename, PATH_MAX, sba, "characteristics");
1277 snprintf(key, sizeof(key), "%17s#%hhu#%04X", addr, bdaddr_type, handle);
1279 return textfile_caseget(filename, key);
1282 int write_device_attribute(const bdaddr_t *sba, const bdaddr_t *dba,
1283 uint8_t bdaddr_type, uint16_t handle,
1286 char filename[PATH_MAX + 1], addr[18], key[25];
1288 create_filename(filename, PATH_MAX, sba, "attributes");
1290 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
1293 snprintf(key, sizeof(key), "%17s#%hhu#%04X", addr, bdaddr_type, handle);
1295 return textfile_put(filename, key, chars);
1298 int read_device_attributes(const bdaddr_t *sba, textfile_cb func, void *data)
1300 char filename[PATH_MAX + 1];
1302 create_filename(filename, PATH_MAX, sba, "attributes");
1304 return textfile_foreach(filename, func, data);
1307 int read_device_ccc(bdaddr_t *local, bdaddr_t *peer, uint8_t bdaddr_type,
1308 uint16_t handle, uint16_t *value)
1310 char filename[PATH_MAX + 1], addr[18], key[25];
1312 unsigned int config;
1315 create_filename(filename, PATH_MAX, local, "ccc");
1318 snprintf(key, sizeof(key), "%17s#%hhu#%04X", addr, bdaddr_type, handle);
1320 str = textfile_caseget(filename, key);
1324 if (sscanf(str, "%04X", &config) != 1)
1334 int write_device_ccc(bdaddr_t *local, bdaddr_t *peer, uint8_t bdaddr_type,
1335 uint16_t handle, uint16_t value)
1337 char filename[PATH_MAX + 1], addr[18], key[25], config[5];
1339 create_filename(filename, PATH_MAX, local, "ccc");
1341 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
1344 snprintf(key, sizeof(key), "%17s#%hhu#%04X", addr, bdaddr_type, handle);
1346 snprintf(config, sizeof(config), "%04X", value);
1348 return textfile_put(filename, key, config);
1351 void delete_device_ccc(bdaddr_t *local, bdaddr_t *peer)
1353 char filename[PATH_MAX + 1], addr[18];
1357 /* Deleting all CCC values of a given address */
1358 create_filename(filename, PATH_MAX, local, "ccc");
1359 delete_by_pattern(filename, addr);
1362 int write_longtermkeys(bdaddr_t *local, bdaddr_t *peer, uint8_t bdaddr_type,
1365 char filename[PATH_MAX + 1], addr[20];
1370 create_filename(filename, PATH_MAX, local, "longtermkeys");
1372 create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
1375 sprintf(&addr[17], "#%hhu", bdaddr_type);
1377 return textfile_put(filename, addr, key);
1380 gboolean has_longtermkeys(bdaddr_t *local, bdaddr_t *peer, uint8_t bdaddr_type)
1382 char filename[PATH_MAX + 1], key[20], *str;
1384 create_filename(filename, PATH_MAX, local, "longtermkeys");
1387 sprintf(&key[17], "#%hhu", bdaddr_type);
1389 str = textfile_caseget(filename, key);