ubuntu bluetooth 디버깅
18217 단어 블루투스 기술
번역하다
bluez-4.66을 컴파일할 때 configure에서 다음과 같은 dbus 오류가 발생했습니다.
configure: error: D-Bus library is required
해결 방법:
sudo apt-get install libdbus-1-dev libdbus-glib-1-dev
make -j4
최종적으로bluetoothd가 생성됩니다. src/.libs/디렉터리 아래.
운행
ubuntu에서 시스템이 시작될 때 기본적으로 Bluetoothd가 시작되었습니다. 단지 이 Bluetoothd는/usr/sbin/아래에 있습니다.기본값으로 시작하는 블루투스를 킬-9 블루투스로 해치우고 수동으로
우리가 직접 컴파일한bluetoothd를 시작합니다. 검사를 통해 자신이 컴파일한bluetoothd도 운행에 협조할 수 있고 기본적인 파일 배합 기능도 정상입니다.
우리는./bluetoothd -h bluetoothd 실행 명령을 보면 다음과 같습니다.
Usage: bluetoothd [OPTION...] Help Options: -h, --help Show help options Application Options: -n, --nodaemon Don't run as daemon in background -d, --debug=DEBUG Enable debug information output -u, --udev Run from udev mode of operation
가장 간단한 상황에서 우리는 sudo를 사용한다./bluetoothd에서 bluetoothd 프로그램을 시작합니다.sudo를 사용하는 이유는 말할 필요가 없습니다. 프로그램 자체가 루트 권한을 많이 사용하기 때문입니다.우리는 이 명령으로 시작한 후에 프로그램이 곧
백그라운드로 들어갑니다.위help에서 나온 결과를 보고 뒤에 -n 파라미터를 추가하면 프로그램이 컨트롤러에서 실행되고 ctrl+c로 프로그램을 종료할 수 있습니다.여기에서 나는 주로 블루투스 모듈을 디버깅하기 위해 사용한다
내가 원하는 정보를 인쇄하기 위해서 컨트롤러가 프로그램을 뛴다.다른 두 개의 매개 변수는 뒤에서 연구하고 있다.
코드 해석
코드 해석:start_sdp_server(mtu, main_opts.deviceid, SDP_SERVER_COMPAT);
이 부분 코드는 sdpd-server에 있습니다.c 파일에서 함수는 다음과 같습니다.
int start_sdp_server(uint16_t mtu, const char *did, uint32_t flags)
{
int compat = flags & SDP_SERVER_COMPAT;
int master = flags & SDP_SERVER_MASTER;
info("Starting SDP server");
if (init_server(mtu, master, compat) < 0) {
error("Server initialization failed");
return -1;
}
if (did && strlen(did) > 0) {
const char *ptr = did;
uint16_t vid = 0x0000, pid = 0x0000, ver = 0x0000;
vid = (uint16_t) strtol(ptr, NULL, 16);
ptr = strchr(ptr, ':');
if (ptr) {
pid = (uint16_t) strtol(ptr + 1, NULL, 16);
ptr = strchr(ptr + 1, ':');
if (ptr)
ver = (uint16_t) strtol(ptr + 1, NULL, 16);
register_device_id(vid, pid, ver);
}
}
//create a channel according to socket, just like create a port according to the socket
//then add io_accept_event func listen to the channel if there are someone connect to
//the channel, just like we create a port on linux, then we will listen to the port because
//there maybe someone connect to the port, here we act as a server.
l2cap_io = g_io_channel_unix_new(l2cap_sock);
g_io_channel_set_close_on_unref(l2cap_io, TRUE);
g_io_add_watch(l2cap_io, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
io_accept_event, &l2cap_sock);
if (compat && unix_sock > fileno(stderr)) {
unix_io = g_io_channel_unix_new(unix_sock);
g_io_channel_set_close_on_unref(unix_io, TRUE);
g_io_add_watch(unix_io, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
io_accept_event, &unix_sock);
}
return 0;
}클라이언트가 연결되면 accept 인터페이스로 연결을 받을 수 있습니다.여기에서 나는 원리가 같아야 한다고 생각한다. 여기는glib 라이브러리로 이루어질 뿐이다.
다음은 io_accept_이벤트 이 인터페이스:
static gboolean io_accept_event(GIOChannel *chan, GIOCondition cond, gpointer data)
{
GIOChannel *io;
int nsk;
if (cond & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {
g_io_channel_unref(chan);
return FALSE;
}
if (data == &l2cap_sock) {
struct sockaddr_l2 addr;
socklen_t len = sizeof(addr);
nsk = accept(l2cap_sock, (struct sockaddr *) &addr, &len);
} else if (data == &unix_sock) {
struct sockaddr_un addr;
socklen_t len = sizeof(addr);
nsk = accept(unix_sock, (struct sockaddr *) &addr, &len);
} else
return FALSE;
if (nsk < 0) {
error("Can't accept connection: %s", strerror(errno));
return TRUE;
}
//here we accept the connect from client, and then generate a new socket, the new socket
//is for really data transfer, and here we can see we use io_session_event func to deal with
//the new socket for processing the coming data.
io = g_io_channel_unix_new(nsk);
g_io_channel_set_close_on_unref(io, TRUE);
g_io_add_watch(io, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
io_session_event, data);
g_io_channel_unref(io);
return TRUE;
}등록된 io_session_이벤트 인터페이스.다음은 io_session_이벤트 데이터 처리 인터페이스:
static gboolean io_session_event(GIOChannel *chan, GIOCondition cond, gpointer data)
{
sdp_pdu_hdr_t hdr;
uint8_t *buf;
int sk, len, size;
if (cond & G_IO_NVAL)
return FALSE;
sk = g_io_channel_unix_get_fd(chan);
if (cond & (G_IO_HUP | G_IO_ERR)) {
sdp_svcdb_collect_all(sk);
return FALSE;
}
//first receive the sdp pdu hdr, connecting msg i guess
len = recv(sk, &hdr, sizeof(sdp_pdu_hdr_t), MSG_PEEK);
if (len <= 0) {
sdp_svcdb_collect_all(sk);
return FALSE;
}
size = sizeof(sdp_pdu_hdr_t) + ntohs(hdr.plen);
buf = malloc(size);
if (!buf)
return TRUE;
//then receive the real data
len = recv(sk, buf, size, 0);
if (len <= 0) {
sdp_svcdb_collect_all(sk);
free(buf);
return FALSE;
}
//here we will process the data
handle_request(sk, buf, len);
return TRUE;
}sdp_req_t 구조체, 그리고 프로세스로 전전하기_request 이 함수, 그리고 sdp_req_t구조 전송, sdp_req_t 구조는 다음과 같습니다.
typedef struct request {
bdaddr_t device;
bdaddr_t bdaddr;
int local;
int sock;
int mtu;
int flags;
uint8_t *buf;
int len;
} sdp_req_t;static void process_request(sdp_req_t *req)
{
sdp_pdu_hdr_t *reqhdr = (sdp_pdu_hdr_t *)req->buf;
sdp_pdu_hdr_t *rsphdr;
sdp_buf_t rsp;
uint8_t *buf = malloc(USHRT_MAX);
int sent = 0;
int status = SDP_INVALID_SYNTAX;
//prepare the response struct, init the response data
memset(buf, 0, USHRT_MAX);
rsp.data = buf + sizeof(sdp_pdu_hdr_t);
rsp.data_size = 0;
rsp.buf_size = USHRT_MAX - sizeof(sdp_pdu_hdr_t);
rsphdr = (sdp_pdu_hdr_t *)buf;
if (ntohs(reqhdr->plen) != req->len - sizeof(sdp_pdu_hdr_t)) {
status = SDP_INVALID_PDU_SIZE;
goto send_rsp;
}
//here do all kinds of process according to the pdu id
switch (reqhdr->pdu_id) {
case SDP_SVC_SEARCH_REQ:
SDPDBG("Got a svc srch req");
status = service_search_req(req, &rsp);
rsphdr->pdu_id = SDP_SVC_SEARCH_RSP;
break;
case SDP_SVC_ATTR_REQ:
SDPDBG("Got a svc attr req");
status = service_attr_req(req, &rsp);
rsphdr->pdu_id = SDP_SVC_ATTR_RSP;
break;
case SDP_SVC_SEARCH_ATTR_REQ:
SDPDBG("Got a svc srch attr req");
status = service_search_attr_req(req, &rsp);
rsphdr->pdu_id = SDP_SVC_SEARCH_ATTR_RSP;
break;
/* Following requests are allowed only for local connections */
case SDP_SVC_REGISTER_REQ:
SDPDBG("Service register request");
if (req->local) {
status = service_register_req(req, &rsp);
rsphdr->pdu_id = SDP_SVC_REGISTER_RSP;
}
break;
case SDP_SVC_UPDATE_REQ:
SDPDBG("Service update request");
if (req->local) {
status = service_update_req(req, &rsp);
rsphdr->pdu_id = SDP_SVC_UPDATE_RSP;
}
break;
case SDP_SVC_REMOVE_REQ:
SDPDBG("Service removal request");
if (req->local) {
status = service_remove_req(req, &rsp);
rsphdr->pdu_id = SDP_SVC_REMOVE_RSP;
}
break;
default:
error("Unknown PDU ID : 0x%x received", reqhdr->pdu_id);
status = SDP_INVALID_SYNTAX;
break;
}
send_rsp:
//fill in the response data and then send rsp the the client
if (status) {
rsphdr->pdu_id = SDP_ERROR_RSP;
bt_put_unaligned(htons(status), (uint16_t *)rsp.data);
rsp.data_size = sizeof(uint16_t);
}
SDPDBG("Sending rsp. status %d", status);
rsphdr->tid = reqhdr->tid;
rsphdr->plen = htons(rsp.data_size);
/* point back to the real buffer start and set the real rsp length */
rsp.data_size += sizeof(sdp_pdu_hdr_t);
rsp.data = buf;
/* stream the rsp PDU */
sent = send(req->sock, rsp.data, rsp.data_size, 0);
SDPDBG("Bytes Sent : %d", sent);
free(rsp.data);
free(req->buf);
}/*
* The PDU identifiers of SDP packets between client and server
*/
#define SDP_ERROR_RSP 0x01
#define SDP_SVC_SEARCH_REQ 0x02
#define SDP_SVC_SEARCH_RSP 0x03
#define SDP_SVC_ATTR_REQ 0x04
#define SDP_SVC_ATTR_RSP 0x05
#define SDP_SVC_SEARCH_ATTR_REQ 0x06
#define SDP_SVC_SEARCH_ATTR_RSP 0x07코드 해석:plugin_init(config);
이 함수는 현재 디렉터리에서plugin을 정의합니다.c 파일에서 주된 작업은 제공된plugins를plugins 전역 체인 테이블에 추가하고 각각plugins를 초기화하는 것입니다.
gboolean plugin_init(GKeyFile *config)
{
GSList *list;
GDir *dir;
const gchar *file;
gchar **disabled;
unsigned int i;
/* Make a call to BtIO API so its symbols got resolved before the
* plugins are loaded. */
bt_io_error_quark();
if (config)
disabled = g_key_file_get_string_list(config, "General",
"DisablePlugins",
NULL, NULL);
else
disabled = NULL;
DBG("Loading builtin plugins");
//add default plugins, those plugins always need for bluetoothd runing
//those plugins will add to the global link named plugins
for (i = 0; __bluetooth_builtin[i]; i++) {
if (is_disabled(__bluetooth_builtin[i]->name, disabled))
continue;
add_plugin(NULL, __bluetooth_builtin[i]);
}
if (strlen(PLUGINDIR) == 0) {
g_strfreev(disabled);
goto start;
}
DBG("Loading plugins %s", PLUGINDIR);
dir = g_dir_open(PLUGINDIR, 0, NULL);
if (!dir) {
g_strfreev(disabled);
goto start;
}
//add user plugins, those plugins stored in PLUGINDIR path, and the
//PLUGINDIR = /usr/local/lib/bluetooth/plugins. The bluetoothd will
//find all those plugins which name *.so, and open them, get the method
//named bluetooth_plugin_desc, it will also add those plugins to the
//plugins links.
while ((file = g_dir_read_name(dir)) != NULL) {
struct bluetooth_plugin_desc *desc;
void *handle;
gchar *filename;
if (g_str_has_prefix(file, "lib") == TRUE ||
g_str_has_suffix(file, ".so") == FALSE)
continue;
if (is_disabled(file, disabled))
continue;
filename = g_build_filename(PLUGINDIR, file, NULL);
handle = dlopen(filename, RTLD_NOW);
if (handle == NULL) {
error("Can't load plugin %s: %s", filename,
dlerror());
g_free(filename);
continue;
}
g_free(filename);
desc = dlsym(handle, "bluetooth_plugin_desc");
if (desc == NULL) {
error("Can't load plugin description: %s", dlerror());
dlclose(handle);
continue;
}
if (add_plugin(handle, desc) == FALSE)
dlclose(handle);
}
g_dir_close(dir);
g_strfreev(disabled);
start:
//init all of the plugins by calling the plugins init function
for (list = plugins; list; list = list->next) {
struct bluetooth_plugin *plugin = list->data;
if (plugin->desc->init() < 0) {
error("Failed to init %s plugin", plugin->desc->name);
continue;
}
plugin->active = TRUE;
}
return TRUE;
}
extern struct bluetooth_plugin_desc __bluetooth_builtin_audio;
extern struct bluetooth_plugin_desc __bluetooth_builtin_input;
extern struct bluetooth_plugin_desc __bluetooth_builtin_serial;
extern struct bluetooth_plugin_desc __bluetooth_builtin_network;
extern struct bluetooth_plugin_desc __bluetooth_builtin_service;
extern struct bluetooth_plugin_desc __bluetooth_builtin_hciops;
extern struct bluetooth_plugin_desc __bluetooth_builtin_hal;
extern struct bluetooth_plugin_desc __bluetooth_builtin_storage;
static struct bluetooth_plugin_desc *__bluetooth_builtin[] = {
&__bluetooth_builtin_audio,
&__bluetooth_builtin_input,
&__bluetooth_builtin_serial,
&__bluetooth_builtin_network,
&__bluetooth_builtin_service,
&__bluetooth_builtin_hciops,
&__bluetooth_builtin_hal,
&__bluetooth_builtin_storage,
NULL
};
BLUETOOTH_PLUGIN_DEFINE(audio, VERSION,
BLUETOOTH_PLUGIN_PRIORITY_DEFAULT, audio_init, audio_exit)
#ifdef BLUETOOTH_PLUGIN_BUILTIN
#define BLUETOOTH_PLUGIN_DEFINE(name, version, priority, init, exit) \
struct bluetooth_plugin_desc __bluetooth_builtin_ ## name = { \
#name, version, priority, init, exit \
};
#else
#define BLUETOOTH_PLUGIN_DEFINE(name, version, priority, init, exit) \
extern struct bluetooth_plugin_desc bluetooth_plugin_desc \
__attribute__ ((visibility("default"))); \
struct bluetooth_plugin_desc bluetooth_plugin_desc = { \
#name, version, priority, init, exit \
};
#endif
코드 해석:adapter_ops_setup()
먼저 함수 정의를 보십시오.
int adapter_ops_setup(void)
{
if (!adapter_ops)
return -EINVAL;
return adapter_ops->setup();
}
static int hciops_setup(void)
{
struct sockaddr_hci addr;
struct hci_filter flt;
GIOChannel *ctl_io, *child_io;
int sock, err;
info("hciops_setup
");
if (child_pipe[0] != -1)
return -EALREADY;
if (pipe(child_pipe) < 0) {
err = errno;
error("pipe(): %s (%d)", strerror(err), err);
return -err;
}
child_io = g_io_channel_unix_new(child_pipe[0]);
g_io_channel_set_close_on_unref(child_io, TRUE);
child_io_id = g_io_add_watch(child_io,
G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
child_exit, NULL);
g_io_channel_unref(child_io);
/* Create and bind HCI socket */
sock = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
if (sock < 0) {
err = errno;
error("Can't open HCI socket: %s (%d)", strerror(err),
err);
return -err;
}
/* Set filter */
hci_filter_clear(&flt);
hci_filter_set_ptype(HCI_EVENT_PKT, &flt);
hci_filter_set_event(EVT_STACK_INTERNAL, &flt);
if (setsockopt(sock, SOL_HCI, HCI_FILTER, &flt,
sizeof(flt)) < 0) {
err = errno;
error("Can't set filter: %s (%d)", strerror(err), err);
return -err;
}
memset(&addr, 0, sizeof(addr));
addr.hci_family = AF_BLUETOOTH;
addr.hci_dev = HCI_DEV_NONE;
if (bind(sock, (struct sockaddr *) &addr,
sizeof(addr)) < 0) {
err = errno;
error("Can't bind HCI socket: %s (%d)",
strerror(err), err);
return -err;
}
ctl_io = g_io_channel_unix_new(sock);
g_io_channel_set_close_on_unref(ctl_io, TRUE);
ctl_io_id = g_io_add_watch(ctl_io, G_IO_IN, io_stack_event, NULL);
g_io_channel_unref(ctl_io);
/* Initialize already connected devices */
return init_known_adapters(sock);
}
static int init_known_adapters(int ctl)
{
struct hci_dev_list_req *dl;
struct hci_dev_req *dr;
int i, err;
info("init_known_adapters
");
dl = g_try_malloc0(HCI_MAX_DEV * sizeof(struct hci_dev_req) + sizeof(uint16_t));
if (!dl) {
err = errno;
error("Can't allocate devlist buffer: %s (%d)",
strerror(err), err);
return -err;
}
dl->dev_num = HCI_MAX_DEV;
dr = dl->dev_req;
if (ioctl(ctl, HCIGETDEVLIST, (void *) dl) < 0) {
err = errno;
error("Can't get device list: %s (%d)",
strerror(err), err);
g_free(dl);
return -err;
}
for (i = 0; i < dl->dev_num; i++, dr++) {
device_event(HCI_DEV_REG, dr->dev_id);
if (hci_test_bit(HCI_UP, &dr->dev_opt))
device_event(HCI_DEV_UP, dr->dev_id);
}
g_free(dl);
return 0;
}
코드 해석:rfkill_init()
void rfkill_init(void)
{
int fd;
if (!main_opts.remember_powered)
return;
fd = open("/dev/rfkill", O_RDWR);
if (fd < 0) {
error("Failed to open RFKILL control device");
return;
}
channel = g_io_channel_unix_new(fd);
g_io_channel_set_close_on_unref(channel, TRUE);
g_io_add_watch(channel, G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
rfkill_event, NULL);
}
struct rfkill_event {
uint32_t idx;
uint8_t type;
uint8_t op;
uint8_t soft;
uint8_t hard;
};
좋은 웹페이지 즐겨찾기
