Ubuntu Bluetooth 配對過程

bluetoothd運行時（main函數啟動時），加載plugin（調用plugin_init函數）：

1. gboolean plugin_init(GKeyFile *config)
2. {
3. GSList *list;
4. GDir *dir;
5. const gchar *file;
6. gchar **disabled;
7. unsigned int i;
9. /* Make a call to BtIO API so its symbols got resolved before the
10. * plugins are loaded. */
11. bt_io_error_quark();
13. if (config)
14. disabled = g_key_file_get_string_list(config, "General",
15. "DisablePlugins",
16. NULL, NULL);
17. else
18. disabled = NULL;
20. info("Loading builtin plugins");
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;
28. add_plugin(NULL, __bluetooth_builtin[i]);
29. }
31. if (strlen(PLUGINDIR) == 0) {
32. g_strfreev(disabled);
33. goto start;
34. }
36. info("Loading plugins %s\n", PLUGINDIR);
38. dir = g_dir_open(PLUGINDIR, 0, NULL);
39. if (!dir) {
40. g_strfreev(disabled);
41. goto start;
42. }
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;
54. if (g_str_has_prefix(file, "lib") == TRUE ||
55. g_str_has_suffix(file, ".so") == FALSE)
56. continue;
58. if (is_disabled(file, disabled))
59. continue;
61. filename = g_build_filename(PLUGINDIR, file, NULL);
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. }
71. g_free(filename);
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. }
80. if (add_plugin(handle, desc) == FALSE)
81. dlclose(handle);
82. }
84. g_dir_close(dir);
86. g_strfreev(disabled);
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;
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. }
101. return TRUE;
102. }

函數中__bluetooth_builtin結構體為存儲加載的plugin的入口地址，這些地址是通過連接宏##連接的，其中包含hciops模塊的加載。此函數將結構體中的地址加載成plugins鏈表，然後循環調用每個模塊的初始化init函數。對應於hciops模塊，調用初始化函數為hciops_init。__bluetooth_builtin結構體和連接宏定義如下：

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. };

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模塊初始化：

1. static int hciops_init(void)
2. {
3. info("hciops_init\n");
4. return btd_register_adapter_ops(&hci_ops);
5. }

1. int btd_register_adapter_ops(struct btd_adapter_ops *btd_adapter_ops)
2. {
3. /* Already registered */
4. if (adapter_ops)
5. return -EALREADY;
7. if (btd_adapter_ops->setup == NULL)
8. return -EINVAL;
10. adapter_ops = btd_adapter_ops;
12. return 0;
13. }

這個初始化函數將靜態hci_ops結構體變量賦值給了全局變量adapter_ops。hci_ops結構定義：

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. };

static struct btd_adapter_ops hci_ops = { .setup = hciops_setup, .cleanup = hciops_cleanup, .start = hciops_start, .stop = hciops_stop, .set_powered = hciops_powered, .set_connectable = hciops_connectable, .set_discoverable = hciops_discoverable, .set_limited_discoverable = hciops_set_limited_discoverable, .start_discovery = hciops_start_discovery, .stop_discovery = hciops_stop_discovery, .resolve_name = hciops_resolve_name, .cancel_resolve_name = hciops_cancel_resolve_name, .set_name = hciops_set_name, .read_name = hciops_read_name, .set_class = hciops_set_class, }; 在plugin_init加載完plugins後，調用了adapter_ops_setup函數來啟動HCI適配層：

[cpp] view plaincopyprint?

1. int adapter_ops_setup(void)
2. {
3. if (!adapter_ops)
4. return -EINVAL;
6. return adapter_ops->setup();
7. }

這個函數即調用裡 hci_ops靜態全局變量的setup函數，看hci_ops全局變量的定義，.setup指向hciops_setup函數：

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;
8. info("hciops_setup\n");
10. if (child_pipe[0] != -1)
11. return -EALREADY;
13. if (pipe(child_pipe) < 0) {
14. err = errno;
15. error("pipe(): %s (%d)", strerror(err), err);
16. return -err;
17. }
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);
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. }
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. }
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. }
57. ctl_io = g_io_channel_unix_new(sock);
58. g_io_channel_set_close_on_unref(ctl_io, TRUE);
60. ctl_io_id = g_io_add_watch(ctl_io, G_IO_IN, io_stack_event, NULL);
62. g_io_channel_unref(ctl_io);
64. /* Initialize already connected devices */
65. return init_known_adapters(sock);
66. }

在函數的最後，調用裡init_known_adapters啟動裡已知的hci設備，初始化HCI適配器：

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;
7. info("init_known_adapters\n");
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. }
17. dl->dev_num = HCI_MAX_DEV;
18. dr = dl->dev_req;
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. }
28. for (i = 0; i < dl->dev_num; i++, dr++) {
29. device_event(HCI_DEV_REG, dr->dev_id);
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. }
37. g_free(dl);
38. return 0;
39. }