lib/bluetooth.h

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2000-2001  Qualcomm Incorporated
   6  *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
   7  *  Copyright (C) 2002-2010  Marcel Holtmann <marcel@holtmann.org>
   8  *
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  23  *
  24  */
  25
  26 #ifndef __BLUETOOTH_H
  27 #define __BLUETOOTH_H
  28
  29 #ifdef __cplusplus
  30 extern "C" {
  31 #endif
  32
  33 #include <stdio.h>
  34 #include <stdint.h>
  35 #include <string.h>
  36 #include <endian.h>
  37 #include <byteswap.h>
  38 #include <netinet/in.h>
  39
  40 #ifndef AF_BLUETOOTH
  41 #define AF_BLUETOOTH    31
  42 #define PF_BLUETOOTH    AF_BLUETOOTH
  43 #endif
  44
  45 #define BTPROTO_L2CAP   0
  46 #define BTPROTO_HCI     1
  47 #define BTPROTO_SCO     2
  48 #define BTPROTO_RFCOMM  3
  49 #define BTPROTO_BNEP    4
  50 #define BTPROTO_CMTP    5
  51 #define BTPROTO_HIDP    6
  52 #define BTPROTO_AVDTP   7
  53
  54 #define SOL_HCI         0
  55 #define SOL_L2CAP       6
  56 #define SOL_SCO         17
  57 #define SOL_RFCOMM      18
  58
  59 #ifndef SOL_BLUETOOTH
  60 #define SOL_BLUETOOTH   274
  61 #endif
  62
  63 #define BT_SECURITY     4
  64 struct bt_security {
  65         uint8_t level;
  66         uint8_t key_size;
  67 };
  68 #define BT_SECURITY_SDP         0
  69 #define BT_SECURITY_LOW         1
  70 #define BT_SECURITY_MEDIUM      2
  71 #define BT_SECURITY_HIGH        3
  72
  73 #define BT_DEFER_SETUP  7
  74
  75 #define BT_FLUSHABLE    8
  76
  77 #define BT_FLUSHABLE_OFF        0
  78 #define BT_FLUSHABLE_ON         1
  79
  80 #define BT_POWER                9
  81 struct bt_power {
  82         uint8_t force_active;
  83 };
  84 #define BT_POWER_FORCE_ACTIVE_OFF 0
  85 #define BT_POWER_FORCE_ACTIVE_ON  1
  86
  87 #define BT_CHANNEL_POLICY       10
  88
  89 /* BR/EDR only (default policy)
  90  *   AMP controllers cannot be used.
  91  *   Channel move requests from the remote device are denied.
  92  *   If the L2CAP channel is currently using AMP, move the channel to BR/EDR.
  93  */
  94 #define BT_CHANNEL_POLICY_BREDR_ONLY            0
  95
  96 /* BR/EDR Preferred
  97  *   Allow use of AMP controllers.
  98  *   If the L2CAP channel is currently on AMP, move it to BR/EDR.
  99  *   Channel move requests from the remote device are allowed.
 100  */
 101 #define BT_CHANNEL_POLICY_BREDR_PREFERRED       1
 102
 103 /* AMP Preferred
 104  *   Allow use of AMP controllers
 105  *   If the L2CAP channel is currently on BR/EDR and AMP controller
 106  *     resources are available, initiate a channel move to AMP.
 107  *   Channel move requests from the remote device are allowed.
 108  *   If the L2CAP socket has not been connected yet, try to create
 109  *     and configure the channel directly on an AMP controller rather
 110  *     than BR/EDR.
 111  */
 112 #define BT_CHANNEL_POLICY_AMP_PREFERRED         2
 113
 114 #define BT_VOICE                11
 115 struct bt_voice {
 116         uint16_t setting;
 117 };
 118
 119 #define BT_SNDMTU               12
 120 #define BT_RCVMTU               13
 121
 122 #define BT_VOICE_TRANSPARENT                    0x0003
 123 #define BT_VOICE_CVSD_16BIT                     0x0060
 124
 125 /* Connection and socket states */
 126 enum {
 127         BT_CONNECTED = 1, /* Equal to TCP_ESTABLISHED to make net code happy */
 128         BT_OPEN,
 129         BT_BOUND,
 130         BT_LISTEN,
 131         BT_CONNECT,
 132         BT_CONNECT2,
 133         BT_CONFIG,
 134         BT_DISCONN,
 135         BT_CLOSED
 136 };
 137
 138 /* Byte order conversions */
 139 #if __BYTE_ORDER == __LITTLE_ENDIAN
 140 #define htobs(d)  (d)
 141 #define htobl(d)  (d)
 142 #define htobll(d) (d)
 143 #define btohs(d)  (d)
 144 #define btohl(d)  (d)
 145 #define btohll(d) (d)
 146 #elif __BYTE_ORDER == __BIG_ENDIAN
 147 #define htobs(d)  bswap_16(d)
 148 #define htobl(d)  bswap_32(d)
 149 #define htobll(d) bswap_64(d)
 150 #define btohs(d)  bswap_16(d)
 151 #define btohl(d)  bswap_32(d)
 152 #define btohll(d) bswap_64(d)
 153 #else
 154 #error "Unknown byte order"
 155 #endif
 156
 157 /* Bluetooth unaligned access */
 158 #define bt_get_unaligned(ptr)                   \
 159 __extension__ ({                                \
 160         struct __attribute__((packed)) {        \
 161                 __typeof__(*(ptr)) __v;         \
 162         } *__p = (__typeof__(__p)) (ptr);       \
 163         __p->__v;                               \
 164 })
 165
 166 #define bt_put_unaligned(val, ptr)              \
 167 do {                                            \
 168         struct __attribute__((packed)) {        \
 169                 __typeof__(*(ptr)) __v;         \
 170         } *__p = (__typeof__(__p)) (ptr);       \
 171         __p->__v = (val);                       \
 172 } while(0)
 173
 174 #if __BYTE_ORDER == __LITTLE_ENDIAN
 175 static inline uint64_t bt_get_le64(const void *ptr)
 176 {
 177         return bt_get_unaligned((const uint64_t *) ptr);
 178 }
 179
 180 static inline uint64_t bt_get_be64(const void *ptr)
 181 {
 182         return bswap_64(bt_get_unaligned((const uint64_t *) ptr));
 183 }
 184
 185 static inline uint32_t bt_get_le32(const void *ptr)
 186 {
 187         return bt_get_unaligned((const uint32_t *) ptr);
 188 }
 189
 190 static inline uint32_t bt_get_be32(const void *ptr)
 191 {
 192         return bswap_32(bt_get_unaligned((const uint32_t *) ptr));
 193 }
 194
 195 static inline uint16_t bt_get_le16(const void *ptr)
 196 {
 197         return bt_get_unaligned((const uint16_t *) ptr);
 198 }
 199
 200 static inline uint16_t bt_get_be16(const void *ptr)
 201 {
 202         return bswap_16(bt_get_unaligned((const uint16_t *) ptr));
 203 }
 204
 205 static inline void bt_put_le64(uint64_t val, const void *ptr)
 206 {
 207         bt_put_unaligned(val, (uint64_t *) ptr);
 208 }
 209
 210 static inline void bt_put_be64(uint64_t val, const void *ptr)
 211 {
 212         bt_put_unaligned(bswap_64(val), (uint64_t *) ptr);
 213 }
 214
 215 static inline void bt_put_le32(uint32_t val, const void *ptr)
 216 {
 217         bt_put_unaligned(val, (uint32_t *) ptr);
 218 }
 219
 220 static inline void bt_put_be32(uint32_t val, const void *ptr)
 221 {
 222         bt_put_unaligned(bswap_32(val), (uint32_t *) ptr);
 223 }
 224
 225 static inline void bt_put_le16(uint16_t val, const void *ptr)
 226 {
 227         bt_put_unaligned(val, (uint16_t *) ptr);
 228 }
 229
 230 static inline void bt_put_be16(uint16_t val, const void *ptr)
 231 {
 232         bt_put_unaligned(bswap_16(val), (uint16_t *) ptr);
 233 }
 234
 235 #elif __BYTE_ORDER == __BIG_ENDIAN
 236 static inline uint64_t bt_get_le64(const void *ptr)
 237 {
 238         return bswap_64(bt_get_unaligned((const uint64_t *) ptr));
 239 }
 240
 241 static inline uint64_t bt_get_be64(const void *ptr)
 242 {
 243         return bt_get_unaligned((const uint64_t *) ptr);
 244 }
 245
 246 static inline uint32_t bt_get_le32(const void *ptr)
 247 {
 248         return bswap_32(bt_get_unaligned((const uint32_t *) ptr));
 249 }
 250
 251 static inline uint32_t bt_get_be32(const void *ptr)
 252 {
 253         return bt_get_unaligned((const uint32_t *) ptr);
 254 }
 255
 256 static inline uint16_t bt_get_le16(const void *ptr)
 257 {
 258         return bswap_16(bt_get_unaligned((const uint16_t *) ptr));
 259 }
 260
 261 static inline uint16_t bt_get_be16(const void *ptr)
 262 {
 263         return bt_get_unaligned((const uint16_t *) ptr);
 264 }
 265
 266 static inline void bt_put_le64(uint64_t val, const void *ptr)
 267 {
 268         bt_put_unaligned(bswap_64(val), (uint64_t *) ptr);
 269 }
 270
 271 static inline void bt_put_be64(uint64_t val, const void *ptr)
 272 {
 273         bt_put_unaligned(val, (uint64_t *) ptr);
 274 }
 275
 276 static inline void bt_put_le32(uint32_t val, const void *ptr)
 277 {
 278         bt_put_unaligned(bswap_32(val), (uint32_t *) ptr);
 279 }
 280
 281 static inline void bt_put_be32(uint32_t val, const void *ptr)
 282 {
 283         bt_put_unaligned(val, (uint32_t *) ptr);
 284 }
 285
 286 static inline void bt_put_le16(uint16_t val, const void *ptr)
 287 {
 288         bt_put_unaligned(bswap_16(val), (uint16_t *) ptr);
 289 }
 290
 291 static inline void bt_put_be16(uint16_t val, const void *ptr)
 292 {
 293         bt_put_unaligned(val, (uint16_t *) ptr);
 294 }
 295 #else
 296 #error "Unknown byte order"
 297 #endif
 298
 299 /* BD Address */
 300 typedef struct {
 301         uint8_t b[6];
 302 } __attribute__((packed)) bdaddr_t;
 303
 304 /* BD Address type */
 305 #define BDADDR_BREDR           0x00
 306 #define BDADDR_LE_PUBLIC       0x01
 307 #define BDADDR_LE_RANDOM       0x02
 308
 309 #define BDADDR_ANY   (&(bdaddr_t) {{0, 0, 0, 0, 0, 0}})
 310 #define BDADDR_ALL   (&(bdaddr_t) {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}})
 311 #define BDADDR_LOCAL (&(bdaddr_t) {{0, 0, 0, 0xff, 0xff, 0xff}})
 312
 313 /* Copy, swap, convert BD Address */
 314 static inline int bacmp(const bdaddr_t *ba1, const bdaddr_t *ba2)
 315 {
 316         return memcmp(ba1, ba2, sizeof(bdaddr_t));
 317 }
 318 static inline void bacpy(bdaddr_t *dst, const bdaddr_t *src)
 319 {
 320         memcpy(dst, src, sizeof(bdaddr_t));
 321 }
 322
 323 void baswap(bdaddr_t *dst, const bdaddr_t *src);
 324 bdaddr_t *strtoba(const char *str);
 325 char *batostr(const bdaddr_t *ba);
 326 int ba2str(const bdaddr_t *ba, char *str);
 327 int str2ba(const char *str, bdaddr_t *ba);
 328 int ba2oui(const bdaddr_t *ba, char *oui);
 329 int bachk(const char *str);
 330
 331 int baprintf(const char *format, ...);
 332 int bafprintf(FILE *stream, const char *format, ...);
 333 int basprintf(char *str, const char *format, ...);
 334 int basnprintf(char *str, size_t size, const char *format, ...);
 335
 336 void *bt_malloc(size_t size);
 337 void bt_free(void *ptr);
 338
 339 int bt_error(uint16_t code);
 340 const char *bt_compidtostr(int id);
 341
 342 typedef struct {
 343         uint8_t data[16];
 344 } uint128_t;
 345
 346 static inline void bswap_128(const void *src, void *dst)
 347 {
 348         const uint8_t *s = src;
 349         uint8_t *d = dst;
 350         int i;
 351
 352         for (i = 0; i < 16; i++)
 353                 d[15 - i] = s[i];
 354 }
 355
 356 #if __BYTE_ORDER == __BIG_ENDIAN
 357
 358 #define ntoh64(x) (x)
 359
 360 static inline void ntoh128(const uint128_t *src, uint128_t *dst)
 361 {
 362         memcpy(dst, src, sizeof(uint128_t));
 363 }
 364
 365 static inline void btoh128(const uint128_t *src, uint128_t *dst)
 366 {
 367         bswap_128(src, dst);
 368 }
 369
 370 #else
 371
 372 static inline uint64_t ntoh64(uint64_t n)
 373 {
 374         uint64_t h;
 375         uint64_t tmp = ntohl(n & 0x00000000ffffffff);
 376
 377         h = ntohl(n >> 32);
 378         h |= tmp << 32;
 379
 380         return h;
 381 }
 382
 383 static inline void ntoh128(const uint128_t *src, uint128_t *dst)
 384 {
 385         bswap_128(src, dst);
 386 }
 387
 388 static inline void btoh128(const uint128_t *src, uint128_t *dst)
 389 {
 390         memcpy(dst, src, sizeof(uint128_t));
 391 }
 392
 393 #endif
 394
 395 #define hton64(x)     ntoh64(x)
 396 #define hton128(x, y) ntoh128(x, y)
 397 #define htob128(x, y) btoh128(x, y)
 398
 399 #ifdef __cplusplus
 400 }
 401 #endif
 402
 403 #endif /* __BLUETOOTH_H */