ubuntu bluetooth 配对过程

最新推荐文章于 2024-09-21 09:55:58 发布
最新推荐文章于 2024-09-21 09:55:58 发布
阅读量1.2k 收藏 1
点赞数

bluetoothd运行时（main函数启动时），加载plugin（调用plugin_init函数）：

[cpp]  view plain copy
  1. gboolean plugin_init(GKeyFile *config)  
  2. {  
  3.     GSList *list;  
  4.     GDir *dir;  
  5.     const gchar *file;  
  6.     gchar **disabled;  
  7.     unsigned int i;  
  8.   
  9.     /* Make a call to BtIO API so its symbols got resolved before the 
  10.      * plugins are loaded. */  
  11.     bt_io_error_quark();  
  12.   
  13.     if (config)  
  14.         disabled = g_key_file_get_string_list(config, "General",  
  15.                             "DisablePlugins",  
  16.                             NULL, NULL);  
  17.     else  
  18.         disabled = NULL;  
  19.   
  20.     info("Loading builtin plugins");  
  21.   
  22.     //add default plugins, those plugins always need for bluetoothd runing  
  23.     //those plugins will add to the global link named plugins  
  24.     for (i = 0; __bluetooth_builtin[i]; i++) {  
  25.         if (is_disabled(__bluetooth_builtin[i]->name, disabled))  
  26.             continue;  
  27.   
  28.         add_plugin(NULL,  __bluetooth_builtin[i]);  
  29.     }  
  30.   
  31.     if (strlen(PLUGINDIR) == 0) {  
  32.         g_strfreev(disabled);  
  33.         goto start;  
  34.     }  
  35.   
  36.     info("Loading plugins %s\n", PLUGINDIR);  
  37.   
  38.     dir = g_dir_open(PLUGINDIR, 0, NULL);  
  39.     if (!dir) {  
  40.         g_strfreev(disabled);  
  41.         goto start;  
  42.     }  
  43.   
  44.     //add user plugins, those plugins stored in PLUGINDIR path, and the   
  45.     //PLUGINDIR = /usr/local/lib/bluetooth/plugins. The bluetoothd will  
  46.     //find all those plugins which name *.so, and open them, get the method  
  47.     //named bluetooth_plugin_desc, it will also add those plugins to the  
  48.     //plugins links.  
  49.     while ((file = g_dir_read_name(dir)) != NULL) {  
  50.         struct bluetooth_plugin_desc *desc;  
  51.         void *handle;  
  52.         gchar *filename;  
  53.   
  54.         if (g_str_has_prefix(file, "lib") == TRUE ||  
  55.                 g_str_has_suffix(file, ".so") == FALSE)  
  56.             continue;  
  57.   
  58.         if (is_disabled(file, disabled))  
  59.             continue;  
  60.   
  61.         filename = g_build_filename(PLUGINDIR, file, NULL);  
  62.   
  63.         handle = dlopen(filename, RTLD_NOW);  
  64.         if (handle == NULL) {  
  65.             error("Can't load plugin %s: %s", filename,  
  66.                                 dlerror());  
  67.             g_free(filename);  
  68.             continue;  
  69.         }  
  70.   
  71.         g_free(filename);  
  72.   
  73.         desc = dlsym(handle, "bluetooth_plugin_desc");  
  74.         if (desc == NULL) {  
  75.             error("Can't load plugin description: %s", dlerror());  
  76.             dlclose(handle);  
  77.             continue;  
  78.         }  
  79.   
  80.         if (add_plugin(handle, desc) == FALSE)  
  81.             dlclose(handle);  
  82.     }  
  83.   
  84.     g_dir_close(dir);  
  85.   
  86.     g_strfreev(disabled);  
  87.   
  88. start:  
  89.     //init all of the plugins by calling the plugins init function  
  90.     for (list = plugins; list; list = list->next) {  
  91.         struct bluetooth_plugin *plugin = list->data;  
  92.   
  93.         if (plugin->desc->init() < 0) {  
  94.             error("Failed to init %s plugin", plugin->desc->name);  
  95.             continue;  
  96.         }  
  97.         info("plugins active\n");  
  98.         plugin->active = TRUE;  
  99.     }  
  100.   
  101.     return TRUE;  
  102. }  
函数中__bluetooth_builtin结构体为存储加载的plugin的入口地址，这些地址是通过连接宏##连接的，其中包含hciops模块的加载。此函数将结构体中的地址加载成plugins链表，然后循环调用每个模块的初始化init函数。对应于hciops模块，调用初始化函数为hciops_init。__bluetooth_builtin结构体和连接宏定义如下：

[cpp]  view plain copy
  1. static struct bluetooth_plugin_desc *__bluetooth_builtin[] = {  
  2.   &__bluetooth_builtin_audio,  
  3.   &__bluetooth_builtin_input,  
  4.   &__bluetooth_builtin_serial,  
  5.   &__bluetooth_builtin_network,  
  6.   &__bluetooth_builtin_service,  
  7.   &__bluetooth_builtin_hciops,  
  8.   &__bluetooth_builtin_hal,  
  9.   &__bluetooth_builtin_storage,  
  10.   NULL  
  11. };  
[cpp]  view plain copy
  1. #define BLUETOOTH_PLUGIN_DEFINE(name, version, priority, init, exit) \  
  2.         struct bluetooth_plugin_desc __bluetooth_builtin_ ## name = { \  
  3.             #name, version, priority, init, exit \  
  4.         };  
hciops模块初始化：
[cpp]  view plain copy
  1. static int hciops_init(void)  
  2. {  
  3.     info("hciops_init\n");  
  4.     return btd_register_adapter_ops(&hci_ops);  
  5. }  

[cpp]  view plain copy
  1. int btd_register_adapter_ops(struct btd_adapter_ops *btd_adapter_ops)  
  2. {  
  3.     /* Already registered */  
  4.     if (adapter_ops)  
  5.         return -EALREADY;  
  6.   
  7.     if (btd_adapter_ops->setup == NULL)  
  8.         return -EINVAL;  
  9.   
  10.     adapter_ops = btd_adapter_ops;  
  11.   
  12.     return 0;  
  13. }  
这个初始化函数将静态hci_ops结构体变量赋值给了全局变量adapter_ops。hci_ops结构定义：

[cpp]  view plain copy
  1. static struct btd_adapter_ops hci_ops = {  
  2.     .setup = hciops_setup,  
  3.     .cleanup = hciops_cleanup,  
  4.     .start = hciops_start,  
  5.     .stop = hciops_stop,  
  6.     .set_powered = hciops_powered,  
  7.     .set_connectable = hciops_connectable,  
  8.     .set_discoverable = hciops_discoverable,  
  9.     .set_limited_discoverable = hciops_set_limited_discoverable,  
  10.     .start_discovery = hciops_start_discovery,  
  11.     .stop_discovery = hciops_stop_discovery,  
  12.     .resolve_name = hciops_resolve_name,  
  13.     .cancel_resolve_name = hciops_cancel_resolve_name,  
  14.     .set_name = hciops_set_name,  
  15.     .read_name = hciops_read_name,  
  16.     .set_class = hciops_set_class,  
  17. };  
在plugin_init加载完plugins后，调用了adapter_ops_setup函数来启动HCI适配层：

[cpp]  view plain copy
  1. int adapter_ops_setup(void)  
  2. {  
  3.     if (!adapter_ops)  
  4.         return -EINVAL;  
  5.   
  6.     return adapter_ops->setup();  
  7. }  
这个函数即调用里 hci_ops静态全局变量的setup函数，看hci_ops全局变量的定义，.setup指向hciops_setup函数：

[cpp]  view plain copy
  1. static int hciops_setup(void)  
  2. {  
  3.     struct sockaddr_hci addr;  
  4.     struct hci_filter flt;  
  5.     GIOChannel *ctl_io, *child_io;  
  6.     int sock, err;  
  7.   
  8.     info("hciops_setup\n");  
  9.   
  10.     if (child_pipe[0] != -1)  
  11.         return -EALREADY;  
  12.   
  13.     if (pipe(child_pipe) < 0) {  
  14.         err = errno;  
  15.         error("pipe(): %s (%d)", strerror(err), err);  
  16.         return -err;  
  17.     }  
  18.   
  19.     child_io = g_io_channel_unix_new(child_pipe[0]);  
  20.     g_io_channel_set_close_on_unref(child_io, TRUE);  
  21.     child_io_id = g_io_add_watch(child_io,  
  22.                 G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,  
  23.                 child_exit, NULL);  
  24.     g_io_channel_unref(child_io);  
  25.   
  26.     /* Create and bind HCI socket */  
  27.     sock = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);  
  28.     if (sock < 0) {  
  29.         err = errno;  
  30.         error("Can't open HCI socket: %s (%d)", strerror(err),  
  31.                                 err);  
  32.         return -err;  
  33.     }  
  34.   
  35.     /* Set filter */  
  36.     hci_filter_clear(&flt);  
  37.     hci_filter_set_ptype(HCI_EVENT_PKT, &flt);  
  38.     hci_filter_set_event(EVT_STACK_INTERNAL, &flt);  
  39.     if (setsockopt(sock, SOL_HCI, HCI_FILTER, &flt,  
  40.                             sizeof(flt)) < 0) {  
  41.         err = errno;  
  42.         error("Can't set filter: %s (%d)", strerror(err), err);  
  43.         return -err;  
  44.     }  
  45.   
  46.     memset(&addr, 0, sizeof(addr));  
  47.     addr.hci_family = AF_BLUETOOTH;  
  48.     addr.hci_dev = HCI_DEV_NONE;  
  49.     if (bind(sock, (struct sockaddr *) &addr,  
  50.                             sizeof(addr)) < 0) {  
  51.         err = errno;  
  52.         error("Can't bind HCI socket: %s (%d)",  
  53.                             strerror(err), err);  
  54.         return -err;  
  55.     }  
  56.   
  57.     ctl_io = g_io_channel_unix_new(sock);  
  58.     g_io_channel_set_close_on_unref(ctl_io, TRUE);  
  59.   
  60.     ctl_io_id = g_io_add_watch(ctl_io, G_IO_IN, io_stack_event, NULL);  
  61.   
  62.     g_io_channel_unref(ctl_io);  
  63.   
  64.     /* Initialize already connected devices */  
  65.     return init_known_adapters(sock);  
  66. }  
在函数的最后，调用里init_known_adapters启动里已知的hci设备，初始化HCI适配器：

[cpp]  view plain copy
  1. static int init_known_adapters(int ctl)  
  2. {  
  3.     struct hci_dev_list_req *dl;  
  4.     struct hci_dev_req *dr;  
  5.     int i, err;  
  6.   
  7.     info("init_known_adapters\n");  
  8.   
  9.     dl = g_try_malloc0(HCI_MAX_DEV * sizeof(struct hci_dev_req) + sizeof(uint16_t));  
  10.     if (!dl) {  
  11.         err = errno;  
  12.         error("Can't allocate devlist buffer: %s (%d)",  
  13.                             strerror(err), err);  
  14.         return -err;  
  15.     }  
  16.   
  17.     dl->dev_num = HCI_MAX_DEV;  
  18.     dr = dl->dev_req;  
  19.   
  20.     if (ioctl(ctl, HCIGETDEVLIST, (void *) dl) < 0) {  
  21.         err = errno;  
  22.         error("Can't get device list: %s (%d)",  
  23.                             strerror(err), err);  
  24.         g_free(dl);  
  25.         return -err;  
  26.     }  
  27.   
  28.     for (i = 0; i < dl->dev_num; i++, dr++) {  
  29.         device_event(HCI_DEV_REG, dr->dev_id);  
  30.   
  31.         if (hci_test_bit(HCI_UP, &dr->dev_opt)){  
  32.             info("here start the hci device\n");  
  33.             <span style="color:#000000;">device_event(HCI_DEV_UP, dr->dev_id);</span>  
  34.         }  
  35.     }  
  36.   
  37.     g_free(dl);  
  38.     return 0;  
  39. }  
这个函数通过ioctl获取系统的hci设备列表，然后用device_event(HCI_DEV_UP..)启动HCI设备。device_event接收HCI_DEV_UP消息，调用HCI设备启动函数：

[cpp]  view plain copy
  1. static void device_event(int event, int index)  
  2. {  
  3.     switch (event) {  
  4.     case HCI_DEV_REG:  
  5.         info("HCI dev %d registered", index);  
  6.         device_devreg_setup(index);  
  7.         break;  
  8.   
  9.     case HCI_DEV_UNREG:  
  10.         info("HCI dev %d unregistered", index);  
  11.         manager_unregister_adapter(index);  
  12.         break;  
  13.   
  14. <span style="color:#000000;background-color: rgb(255, 255, 255);">  case HCI_DEV_UP:  
  15.         info("HCI dev %d up", index);  
  16.         device_devup_setup(index);  
  17.         break;</span>  
  18.   
  19.     case HCI_DEV_DOWN:  
  20.         info("HCI dev %d down", index);  
  21.         manager_stop_adapter(index);  
  22.         stop_security_manager(index);  
  23.         break;  
  24.     }  
  25. }  

启动HCI DEV设备：

[cpp]  view plain copy
  1. static void device_devup_setup(int index)  
  2. {  
  3.     configure_device(index);  
  4.   
  5.     <span style="color:#000000;">start_security_manager</span>(index);  
  6.   
  7.     /* Return value 1 means ioctl(DEVDOWN) was performed */  
  8.     if (manager_start_adapter(index) == 1)  
  9.         stop_security_manager(index);  
  10. }  
开始安全管理：

[cpp]  view plain copy
  1. void start_security_manager(int hdev)  
  2. {  
  3.     GIOChannel *chan = io_data[hdev].channel;  
  4.     struct hci_dev_info *di;  
  5.     struct hci_filter flt;  
  6.     read_stored_link_key_cp cp;  
  7.     int dev;  
  8.   
  9.     if (chan)  
  10.         return;  
  11.   
  12.     info("Starting security manager %d", hdev);  
  13.   
  14.     if ((dev = hci_open_dev(hdev)) < 0) {  
  15.         error("Can't open device hci%d: %s (%d)",  
  16.                         hdev, strerror(errno), errno);  
  17.         return;  
  18.     }  
  19.   
  20.     /* Set filter */  
  21.     hci_filter_clear(&flt);  
  22.     hci_filter_set_ptype(HCI_EVENT_PKT, &flt);  
  23.     hci_filter_set_event(EVT_CMD_STATUS, &flt);  
  24.     hci_filter_set_event(EVT_CMD_COMPLETE, &flt);  
  25.     hci_filter_set_event(EVT_PIN_CODE_REQ, &flt);  
  26.     hci_filter_set_event(EVT_LINK_KEY_REQ, &flt);  
  27.     hci_filter_set_event(EVT_LINK_KEY_NOTIFY, &flt);  
  28.     hci_filter_set_event(EVT_RETURN_LINK_KEYS, &flt);  
  29.     hci_filter_set_event(EVT_IO_CAPABILITY_REQUEST, &flt);  
  30.     hci_filter_set_event(EVT_IO_CAPABILITY_RESPONSE, &flt);  
  31.     hci_filter_set_event(EVT_USER_CONFIRM_REQUEST, &flt);  
  32.     hci_filter_set_event(EVT_USER_PASSKEY_REQUEST, &flt);  
  33.     hci_filter_set_event(EVT_REMOTE_OOB_DATA_REQUEST, &flt);  
  34.     hci_filter_set_event(EVT_USER_PASSKEY_NOTIFY, &flt);  
  35.     hci_filter_set_event(EVT_KEYPRESS_NOTIFY, &flt);  
  36.     hci_filter_set_event(EVT_SIMPLE_PAIRING_COMPLETE, &flt);  
  37.     hci_filter_set_event(EVT_AUTH_COMPLETE, &flt);  
  38.     hci_filter_set_event(EVT_REMOTE_NAME_REQ_COMPLETE, &flt);  
  39.     hci_filter_set_event(EVT_READ_REMOTE_VERSION_COMPLETE, &flt);  
  40.     hci_filter_set_event(EVT_READ_REMOTE_FEATURES_COMPLETE, &flt);  
  41.     hci_filter_set_event(EVT_REMOTE_HOST_FEATURES_NOTIFY, &flt);  
  42.     hci_filter_set_event(EVT_INQUIRY_COMPLETE, &flt);  
  43.     hci_filter_set_event(EVT_INQUIRY_RESULT, &flt);  
  44.     hci_filter_set_event(EVT_INQUIRY_RESULT_WITH_RSSI, &flt);  
  45.     hci_filter_set_event(EVT_EXTENDED_INQUIRY_RESULT, &flt);  
  46.     hci_filter_set_event(EVT_CONN_REQUEST, &flt);  
  47.     hci_filter_set_event(EVT_CONN_COMPLETE, &flt);  
  48.     hci_filter_set_event(EVT_DISCONN_COMPLETE, &flt);  
  49.     if (setsockopt(dev, SOL_HCI, HCI_FILTER, &flt, sizeof(flt)) < 0) {  
  50.         error("Can't set filter on hci%d: %s (%d)",  
  51.                         hdev, strerror(errno), errno);  
  52.         close(dev);  
  53.         return;  
  54.     }  
  55.   
  56.     di = g_new(struct hci_dev_info, 1);  
  57.     if (hci_devinfo(hdev, di) < 0) {  
  58.         error("Can't get device info: %s (%d)",  
  59.                             strerror(errno), errno);  
  60.         close(dev);  
  61.         g_free(di);  
  62.         return;  
  63.     }  
  64.   
  65.     chan = g_io_channel_unix_new(dev);  
  66.     g_io_channel_set_close_on_unref(chan, TRUE);  
  67.     io_data[hdev].watch_id = g_io_add_watch_full(chan, G_PRIORITY_LOW,  
  68.                         G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,  
  69.                         <span style="color:#000000;">io_security_event</span>, di, (GDestroyNotify) g_free);//注册消息处理函数  
  70.     io_data[hdev].channel = chan;  
  71.     io_data[hdev].pin_length = -1;  
  72.   
  73.     if (hci_test_bit(HCI_RAW, &di->flags))  
  74.         return;  
  75.   
  76.     bacpy(&cp.bdaddr, BDADDR_ANY);  
  77.     cp.read_all = 1;  
  78.   
  79.     hci_send_cmd(dev, OGF_HOST_CTL, OCF_READ_STORED_LINK_KEY,  
  80.             READ_STORED_LINK_KEY_CP_SIZE, (void *) &cp);  
  81. }  

这个函数打开里hci dev设备（实际上就是一个socket），设置处理消息类型，然后创建channel，最后用io_security_event函数侦听远程设备发送过来的消息（socket数据）。接收消息函数：

[cpp]  view plain copy
  1. static gboolean io_security_event(GIOChannel *chan, GIOCondition cond,  
  2.                                 gpointer data)  
  3. {  
  4.     unsigned char buf[HCI_MAX_EVENT_SIZE], *ptr = buf;  
  5.     struct hci_dev_info *di = data;  
  6.     int type, dev;  
  7.     size_t len;  
  8.     hci_event_hdr *eh;  
  9.     GIOError err;  
  10.     evt_cmd_status *evt;  
  11.   
  12.     if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {  
  13.         delete_channel(chan);  
  14.         return FALSE;  
  15.     }  
  16.   
  17.     if ((err = g_io_channel_read(chan, (gchar *) buf, sizeof(buf), &len))) {  
  18.         if (err == G_IO_ERROR_AGAIN)  
  19.             return TRUE;  
  20.         delete_channel(chan);  
  21.         return FALSE;  
  22.     }  
  23.   
  24.     type = *ptr++;  
  25.   
  26.     if (type != HCI_EVENT_PKT)  
  27.         return TRUE;  
  28.   
  29.     eh = (hci_event_hdr *) ptr;  
  30.     ptr += HCI_EVENT_HDR_SIZE;  
  31.   
  32.     dev = g_io_channel_unix_get_fd(chan);  
  33.   
  34.     ioctl(dev, HCIGETDEVINFO, (void *) di);  
  35.   
  36.     if (hci_test_bit(HCI_RAW, &di->flags))  
  37.         return TRUE;  
  38.   
  39.     hci_cmd_print(eh->evt);  
  40.   
  41.     switch (eh->evt) {  
  42.     case EVT_CMD_STATUS://命令状态  
  43.         cmd_status(dev, &di->bdaddr, ptr);  
  44.         break;  
  45.   
  46.     case EVT_CMD_COMPLETE://命令完成  
  47.         cmd_complete(dev, &di->bdaddr, ptr);  
  48.         break;  
  49.   
  50.     case EVT_REMOTE_NAME_REQ_COMPLETE://获取远程设备名  
  51.         remote_name_information(dev, &di->bdaddr, ptr);  
  52.         break;  
  53.   
  54.     case EVT_READ_REMOTE_VERSION_COMPLETE:  
  55.         remote_version_information(dev, &di->bdaddr, ptr);  
  56.         break;  
  57.   
  58.     case EVT_READ_REMOTE_FEATURES_COMPLETE://读取远程设备属性  
  59.         remote_features_information(dev, &di->bdaddr, ptr);  
  60.         break;  
  61.   
  62.     case EVT_REMOTE_HOST_FEATURES_NOTIFY:  
  63.         remote_features_notify(dev, &di->bdaddr, ptr);  
  64.         break;  
  65.   
  66.     case EVT_INQUIRY_COMPLETE:  
  67.         evt = (evt_cmd_status *) ptr;  
  68.         inquiry_complete(&di->bdaddr, evt->status, FALSE);  
  69.         break;  
  70.   
  71.     case EVT_INQUIRY_RESULT:  
  72.         inquiry_result(dev, &di->bdaddr, eh->plen, ptr);  
  73.         break;  
  74.   
  75.     case EVT_INQUIRY_RESULT_WITH_RSSI:  
  76.         inquiry_result_with_rssi(dev, &di->bdaddr, eh->plen, ptr);  
  77.         break;  
  78.   
  79.     case EVT_EXTENDED_INQUIRY_RESULT:  
  80.         extended_inquiry_result(dev, &di->bdaddr, eh->plen, ptr);  
  81.         break;  
  82.   
  83.     case EVT_CONN_COMPLETE://连接完成  
  84.         conn_complete(dev, di->dev_id, &di->bdaddr, ptr);  
  85.         break;  
  86.   
  87.     case EVT_DISCONN_COMPLETE://断开连接  
  88.         disconn_complete(dev, &di->bdaddr, ptr);  
  89.         break;  
  90.   
  91.     case EVT_AUTH_COMPLETE:  
  92.         auth_complete(dev, &di->bdaddr, ptr);  
  93.         break;  
  94.   
  95.     case EVT_SIMPLE_PAIRING_COMPLETE:  
  96.         simple_pairing_complete(dev, &di->bdaddr, ptr);  
  97.         break;  
  98.   
  99.     case EVT_CONN_REQUEST://配对请求  
  100.         conn_request(dev, &di->bdaddr, ptr);  
  101.         break;  
  102.     }  
  103.   
  104.     /* Check for pending command request */  
  105.     check_pending_hci_req(di->dev_id, eh->evt);  
  106.     switch (eh->evt) {  
  107.     case EVT_PIN_CODE_REQ://PIN码请求  
  108.         pin_code_request(dev, &di->bdaddr, (bdaddr_t *) ptr);  
  109.         break;  
  110.   
  111.     case EVT_LINK_KEY_REQ:  
  112.         link_key_request(dev, &di->bdaddr, (bdaddr_t *) ptr);  
  113.         break;  
  114.   
  115.     case EVT_LINK_KEY_NOTIFY://linkkey通知  
  116.         link_key_notify(dev, &di->bdaddr, ptr);  
  117.         break;  
  118.   
  119.     case EVT_RETURN_LINK_KEYS:  
  120.         return_link_keys(dev, &di->bdaddr, ptr);  
  121.         break;  
  122.   
  123.     case EVT_IO_CAPABILITY_REQUEST:  
  124.         io_capa_request(dev, &di->bdaddr, (bdaddr_t *) ptr);  
  125.         break;  
  126.   
  127.     case EVT_IO_CAPABILITY_RESPONSE:  
  128.         io_capa_response(dev, &di->bdaddr, ptr);  
  129.         break;  
  130.   
  131.     case EVT_USER_CONFIRM_REQUEST:  
  132.         user_confirm_request(dev, &di->bdaddr, ptr);  
  133.         break;  
  134.   
  135.     case EVT_USER_PASSKEY_REQUEST:  
  136.         user_passkey_request(dev, &di->bdaddr, ptr);  
  137.         break;  
  138.   
  139.     case EVT_USER_PASSKEY_NOTIFY:  
  140.         user_passkey_notify(dev, &di->bdaddr, ptr);  
  141.         break;  
  142.   
  143.     case EVT_REMOTE_OOB_DATA_REQUEST:  
  144.         remote_oob_data_request(dev, &di->bdaddr, ptr);  
  145.         break;  
  146.     }  
  147.   
  148.     return TRUE;  
  149. }  

这个函数接收到远程设备发送过来的socket数据，然后解析出cmd，并执行对应的操作。在这里，用9510和PC配对，PC收到如下消息：

手机端输入PIN码前：

EVT_CONN_REQUEST
EVT_CMD_STATUS
EVT_PIN_CODE_REQ
bluetoothd[2395]: pin_code_request (sba=00:1C:26:FB:26:DC, dba=36:15:00:EF:80:6E)
手机端输入PIN码后：
EVT_CMD_COMPLETE
EVT_LINK_KEY_NOTIFY
bluetoothd[2395]: link_key_notify (sba=00:1C:26:FB:26:DC, dba=36:15:00:EF:80:6E, type=0)
EVT_CONN_COMPLETE
EVT_CMD_STATUS
EVT_READ_REMOTE_FEATURES_COMPLETE
EVT_CMD_STATUS
EVT_REMOTE_NAME_REQ_COMPLETE
EVT_CMD_STATUS
EVT_REMOTE_NAME_REQ_COMPLETE
EVT_CMD_STATUS
EVT_DISCONN_COMPLETE

下面看以下各个CMD是啥意思。


EVT_CONN_REQUEST:

[cpp]  view plain copy
  1. static inline void conn_request(int dev, bdaddr_t *sba, void *ptr)  
  2. {  
  3.     evt_conn_request *evt = ptr;  
  4.     uint32_t class = evt->dev_class[0] | (evt->dev_class[1] << 8)  
  5.                 | (evt->dev_class[2] << 16);  
  6.   
  7.     hcid_dbus_remote_class(sba, &evt->bdaddr, class);//从本地/var/lib/buetooth/bdaddr/classes文件中读取来配对地址的class值，如果有变化，dbus通知  
  8.   
  9.     write_remote_class(sba, &evt->bdaddr, class);//将class写入/var/lib/buetooth/bdaddr/classes文件  
  10. }  



EVT_CMD_STATUS：

[cpp]  view plain copy
  1. static inline void cmd_status(int dev, bdaddr_t *sba, void *ptr)  
  2. {  
  3.     evt_cmd_status *evt = ptr;  
  4.     uint16_t opcode = btohs(evt->opcode);  
  5.   
  6.     if (opcode == cmd_opcode_pack(OGF_LINK_CTL, OCF_INQUIRY))  
  7.         start_inquiry(sba, evt->status, FALSE);  
  8. } 
Ubuntu蓝牙配对过程编程
CodeSpark的博客
09-25 641
在Ubuntu操作系统中，我们可以通过编程来实现蓝牙设备的配对过程。本文将详细介绍如何在Ubuntu上进行蓝牙配对，并提供相应的源代码示例。通过以上步骤，我们可以在Ubuntu上使用Python编程语言实现蓝牙设备的配对和连接过程。请确保您的系统已正确配置蓝牙适配器，并且蓝牙设备处于可配对和可连接的状态。替换为您要配对的蓝牙设备的实际MAC地址，并执行代码。它将与指定的蓝牙设备进行配对。替换为您要连接的蓝牙设备的实际MAC地址，并执行代码。执行以上代码，它将搜索蓝牙设备并打印它们的名称和MAC地址。
Ubuntu下如何用蓝牙连接手机和蓝牙鼠标
挽风阁的专栏
09-21 6127
转自：http://edu.21cn.com/linux/g_188_502460-1.htm   　　Ubuntu下本本硬件基本都能支持了，除蓝牙等几样不外。同学来传文件都只能进XP。今天下午没课，决定把蓝牙功能搞定。经过一番Google后终于把蓝牙“请出山”了。 　　实现了电脑和蓝牙手机互传的功能（感谢TX兄和另外一位同学提供蓝牙手机）。遗憾的是目前只能手机来连接电脑，而未发现电脑主动连
蓝牙耳机连接ubuntu
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
09-15 1283
【代码】蓝牙耳机连接ubuntu。
【完美解决】Ubuntu 20.04 解决蓝牙无法使用 安装USB蓝牙适配器驱动 蓝牙无法打开 No default controller available 等一系列问题
最新发布
MOS_JBET的博客
09-21 1312
问题的起因为，我在Vmware虚拟机下的Ubuntu20.04无法正常打开蓝牙，开关开启后依然无法检测到设备。然后我尝试了一系列的步骤bluetoothctl 输入power on及其他指令，报错：No default controller available，也尝试了几乎我能查阅到的所有方法，重新安装bluez，blueman等等，我还重新修改了源以为是下载软件时出现了问题。
小米真无线耳机 Air 2s产品蓝牙配对ubuntu20.04 笔记本电脑
苏凯的博客
11-18 1832
4.点击蓝牙设置 bluetooth Settings ，点击右边缩小窗口的旁边按钮打开蓝牙；2.打开ubunru20.04 系统右上角wifi的位置，点击；1.打开耳机，按压侧面按钮2秒，指示灯显示白色闪烁。8.小米真无线耳机 Air 2s 说明书。5.点击找到的Mi Air 2s。3.打开蓝牙图标箭头方向的菜单。6.点击 Connection。
Ubuntu下怎么通过命令完成蓝牙的配对和连接
热门推荐
zhuyong006的博客
05-07 2万+
1.输入hciconfig命令，确认你的蓝牙设备是否被系统识别，避免你插入多个蓝牙设备 2.为你的蓝牙设备上电，输入hciconfig hci0 up 3.输入bluetoothctl命令 4.启动搜索模式，输入scan on 5.当找到你需要连接的蓝牙设备时，输入scan off，停止探索 6.完成配对输入pair 蓝牙地址(你需要连接的设备) 7.手机端需要确认配对请求，之后ubu...
Ubuntu下蓝牙的操作
xiaofeng1234的专栏
08-05 3437
在笔记本上插入蓝牙适配器（US）之后
bose_qc35-ubuntu：通过蓝牙将Bose QuietComfort 35与Ubuntu配对
02-06
对于音频爱好者来说，能够将自己的设备，如Bose QuietComfort 35（简称Bose QC35）无线耳机，与Ubuntu系统完美配对是一项基本需求。本文将详细解释如何在Ubuntu上配置蓝牙连接，特别是针对Bose QC35耳机。 首先，...
linux如何进行蓝牙调试,ubuntu bluetooth 调试
weixin_35691715的博客
05-16 2259
configure: error: D-Bus library is required解决方法：sudo apt-get install libdbus-1-dev libdbus-glib-1-devmake -j4最终产生bluetoothd，在src/.libs/目录下。运行在ubuntu下，系统启动时默认已经启动里了bluetoothd，只是这个bluetoothd位于/usr/sbin/...
ubuntu蓝牙音响配对成功但在声音设置中无法设置的解决 耳机 a2dp 输出 蓝牙耳机 pactl.pdf
03-24
1. Ubuntu系统的蓝牙连接过程：用户首先需要在Ubuntu系统中打开蓝牙设置，搜索可用设备，并将蓝牙音响或耳机配对成功。这一步是通过蓝牙管理界面完成的，这需要系统已经安装了蓝牙适配器的驱动，并且蓝牙服务处于...
Ubuntu20.04无法连接蓝牙
qq_62964142的博客
04-18 1139
连接蓝牙的时候一直转圈显示搜索中，但是搜索不出来任何设备。
ubuntu系统使用蓝牙连接检测设备
pumbkin的博客
07-20 3980
9、设备断连后重新连接，需要[bluetooth]命令行提示符下，输入以下命令删除设备，重复7-8。11、输入minicom进入控制台，即可发送和接收蓝牙数据。8、输入pin配对码（设备上获得），设备上也需要同意配对。5、打开设备的蓝牙，终端输入以下命令启动蓝牙控制器。6、[bluetooth]命令行提示符下，启动扫描。7、出现设备名称和MAC地址后，连接设备。10、输入以下命令建立串口连接。2、查看适配器是否被系统识别。1、插入usb蓝牙适配器。
Ubuntu 蓝牙串口通讯 （基于 PyBluez）
黎国溥
04-12 4540
系统：Ubuntu 14.04 蓝牙：绿联USB2.0蓝牙适配器（型号：CM109；芯片：CSR8510） 一、蓝牙识别： 1、插入硬件，打开终端，查看是否检测到设备： $ lsusb Bus 001 Device 003: ID 0a12:0001 Cambridge Silicon Radio, Ltd Bluetooth Dongle (HCI mode) 2、查看是...
Ubuntu 中蓝牙识别及bluepy蓝牙串口测试
chenkanuo的博客
08-09 1026
在Ubuntu 系统中，经常需要进行蓝牙调试。下面介绍一种蓝牙适配器（CSR8510 ）的使用方法。系统 ：Ubuntu 16.04 python3 版本 : python3USB2 . 0 蓝牙适配器 ：CSR8510以上就是今天要讲的内容，本文仅仅简单介绍了bluepy的使用，设定目标蓝牙 Mac 地址，可以通过执行脚本获取相关信息。
HFP简介：嵌入式环境下的Bluetooth Profile Specification
CodeMaven的博客
09-28 167
代码首先通过hci_get_route函数获取蓝牙适配器的ID，然后使用hci_open_dev函数打开适配器。HFP的主要目标是提供一种标准化的方法，使车辆内的通信系统能够与蓝牙耳机进行交互。为了支持不同类型的设备间的通信，Bluetooth定义了各种不同的配置文件（Profile），其中之一就是HFP（Hands-Free Profile）。开发人员可以根据具体需求，参考Bluetooth Profile Specification中的要求和行为，利用相应的库或框架来实现完整的HFP功能。
Ubuntu安装蓝牙模块pybluez以及问题解决方案【完美解决】
KRISNAT
12-16 1599
近期因工程需要在Ubuntu中使用蓝牙远程一些设备。安装Bluetooth的Python第三方软件包pybluez时遇到很多问题，一番折腾后完美解决。此篇博客进行了梳理和总结，供大家参考。直接使用pip指令安装蓝牙模块pybluez不容易成功，需要提前安装好提供头文件。然后使用安装。若访问不了GitHub仓库的可以使用网上下载好的代码仓库通过指令安装。收集整理和创作不易, 若有帮助🉑, 请帮忙👍➕✨✨🚀🚀。
蓝牙简单配对（Simple Pairing）协议及代码流程简述
hfyutdg的博客
11-10 1万+
蓝牙简单配对（Simple Pairing）协议及代码流程简述
Bluetooth-->蓝牙开发之状态判断
<angcyo>菜鸟视角
07-27 1万+
1:判断设备是否支持蓝牙 BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter(); if (null == adapter) { //蓝牙不支持 } 2:判断蓝牙是否打开 if (!adapter.isEnabled()) { //蓝牙未打开 //adapter.enable();//打开蓝牙
Ubuntu 蓝牙GPS配对OpenCPN指南
对于Ubuntu 12.04，配置过程略有不同，包括与GPS设备通过蓝牙图标配对，断开连接，获取设备ID，以及通过sdptool records命令查找GPS通道。在编辑/etc/bluetooth/rfcomm.conf文件中，用户可以设置GPS的连接参数。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值