1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
|
/*
*
* BlueZ - Bluetooth protocol stack for Linux
*
* Copyright (C) 2000-2001 Qualcomm Incorporated
* Copyright (C) 2002-2003 Maxim Krasnyansky <maxk@qualcomm.com>
* Copyright (C) 2002-2006 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
*
*/
#include <time.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>
#include "glib-ectomy.h"
#define HCID_CONFIG_FILE CONFIGDIR "/hcid.conf"
#define HCID_DEFAULT_DISCOVERABLE_TIMEOUT 180 /* 3 minutes */
/*
* Scanning modes, used by DEV_SET_MODE
* off: remote devices are not allowed to find or connect to this device
* connectable: remote devices are allowed to connect, but they are not
* allowed to find it.
* discoverable: remote devices are allowed to connect and find this device
* unknown: reserved to not allowed/future modes
*/
#define MODE_OFF "off"
#define MODE_CONNECTABLE "connectable"
#define MODE_DISCOVERABLE "discoverable"
#define MODE_UNKNOWN "unknown"
enum {
HCID_SET_NAME,
HCID_SET_CLASS,
HCID_SET_VOICE,
HCID_SET_INQMODE,
HCID_SET_PAGETO,
HCID_SET_DISCOVTO,
HCID_SET_PTYPE,
HCID_SET_LM,
HCID_SET_LP,
};
struct device_opts {
unsigned long flags;
char *name;
uint32_t class;
uint16_t voice;
uint8_t inqmode;
uint16_t pageto;
uint16_t pkt_type;
uint16_t link_mode;
uint16_t link_policy;
uint16_t scan;
int discovto;
};
extern struct device_opts default_device;
extern struct device_opts *parser_device;
struct device_list {
char *ref; /* HCI device or Bluetooth address */
struct device_list *next;
struct device_opts opts;
};
struct hcid_opts {
char host_name[40];
int auto_init;
int security;
int pairing;
char *config_file;
uint8_t pin_code[16];
int pin_len;
int sock;
};
extern struct hcid_opts hcid;
typedef enum {
REQ_PENDING,
REQ_SENT
} req_status_t;
struct hci_req_data {
int dev_id;
int event;
req_status_t status;
bdaddr_t dba;
uint16_t ogf;
uint16_t ocf;
void *cparam;
int clen;
};
struct hci_req_data *hci_req_data_new(int dev_id, const bdaddr_t *dba, uint16_t ogf, uint16_t ocf, int event, const void *cparam, int clen);
void hci_req_queue_append(struct hci_req_data *data);
void hci_req_queue_remove(int dev_id, bdaddr_t *dba);
#define HCID_SEC_NONE 0
#define HCID_SEC_AUTO 1
#define HCID_SEC_USER 2
#define HCID_PAIRING_NONE 0
#define HCID_PAIRING_MULTI 1
#define HCID_PAIRING_ONCE 2
int read_config(char *file);
struct device_opts *alloc_device_opts(char *ref);
int get_discoverable_timeout(int dev_id);
void init_security_data(void);
void start_security_manager(int hdev);
void stop_security_manager(int hdev);
void toggle_pairing(int enable);
void set_pin_length(bdaddr_t *sba, int length);
int hcid_dbus_init(void);
void hcid_dbus_exit(void);
void hcid_dbus_set_experimental();
int hcid_dbus_use_experimental();
int hcid_dbus_register_device(uint16_t id);
int hcid_dbus_unregister_device(uint16_t id);
int hcid_dbus_start_device(uint16_t id);
int hcid_dbus_stop_device(uint16_t id);
void hcid_dbus_pending_pin_req_add(bdaddr_t *sba, bdaddr_t *dba);
int hcid_dbus_request_pin(int dev, bdaddr_t *sba, struct hci_conn_info *ci);
void hcid_dbus_inquiry_start(bdaddr_t *local);
void hcid_dbus_inquiry_complete(bdaddr_t *local);
void hcid_dbus_periodic_inquiry_start(bdaddr_t *local, uint8_t status);
void hcid_dbus_periodic_inquiry_exit(bdaddr_t *local, uint8_t status);
void hcid_dbus_inquiry_result(bdaddr_t *local, bdaddr_t *peer, uint32_t class, int8_t rssi);
void hcid_dbus_remote_class(bdaddr_t *local, bdaddr_t *peer, uint32_t class);
void hcid_dbus_remote_name(bdaddr_t *local, bdaddr_t *peer, uint8_t status, char *name);
void hcid_dbus_conn_complete(bdaddr_t *local, uint8_t status, uint16_t handle, bdaddr_t *peer);
void hcid_dbus_disconn_complete(bdaddr_t *local, uint8_t status, uint16_t handle, uint8_t reason);
void hcid_dbus_bonding_process_complete(bdaddr_t *local, bdaddr_t *peer, uint8_t status);
void hcid_dbus_setname_complete(bdaddr_t *local);
void hcid_dbus_setscan_enable_complete(bdaddr_t *local);
void hcid_dbus_pin_code_reply(bdaddr_t *local, void *ptr);
void init_devices(void);
int add_device(uint16_t dev_id);
int remove_device(uint16_t dev_id);
int start_device(uint16_t dev_id);
int stop_device(uint16_t dev_id);
int get_device_address(uint16_t dev_id, char *address, size_t size);
int get_device_version(uint16_t dev_id, char *version, size_t size);
int get_device_revision(uint16_t dev_id, char *revision, size_t size);
int get_device_manufacturer(uint16_t dev_id, char *manufacturer, size_t size);
int get_device_company(uint16_t dev_id, char *company, size_t size);
int get_device_name(uint16_t dev_id, char *name, size_t size);
int set_device_name(uint16_t dev_id, const char *name);
int get_device_alias(uint16_t dev_id, const bdaddr_t *bdaddr, char *alias, size_t size);
int set_device_alias(uint16_t dev_id, const bdaddr_t *bdaddr, const char *alias);
int get_encryption_key_size(uint16_t dev_id, const bdaddr_t *baddr);
int write_discoverable_timeout(bdaddr_t *bdaddr, int timeout);
int read_discoverable_timeout(bdaddr_t *bdaddr, int *timeout);
int write_device_mode(bdaddr_t *bdaddr, const char *mode);
int read_device_mode(bdaddr_t *bdaddr, char *mode, int length);
int write_local_name(bdaddr_t *bdaddr, char *name);
int read_local_name(bdaddr_t *bdaddr, char *name);
int write_local_class(bdaddr_t *bdaddr, uint8_t *class);
int read_local_class(bdaddr_t *bdaddr, uint8_t *class);
int write_remote_class(bdaddr_t *local, bdaddr_t *peer, uint32_t class);
int read_remote_class(bdaddr_t *local, bdaddr_t *peer, uint32_t *class);
int write_device_name(bdaddr_t *local, bdaddr_t *peer, char *name);
int read_device_name(bdaddr_t *local, bdaddr_t *peer, char *name);
int write_version_info(bdaddr_t *local, bdaddr_t *peer, uint16_t manufacturer, uint8_t lmp_ver, uint16_t lmp_subver);
int write_features_info(bdaddr_t *local, bdaddr_t *peer, unsigned char *features);
int write_lastseen_info(bdaddr_t *local, bdaddr_t *peer, struct tm *tm);
int write_lastused_info(bdaddr_t *local, bdaddr_t *peer, struct tm *tm);
int write_link_key(bdaddr_t *local, bdaddr_t *peer, unsigned char *key, int type, int length);
int read_link_key(bdaddr_t *local, bdaddr_t *peer, unsigned char *key);
int read_pin_length(bdaddr_t *local, bdaddr_t *peer);
int read_pin_code(bdaddr_t *local, bdaddr_t *peer, char *pin);
void info(const char *format, ...);
void error(const char *format, ...);
void debug(const char *format, ...);
void enable_debug();
void disable_debug();
void start_logging(const char *ident, const char *message);
void stop_logging(void);
|
