Bluez SPP实现代码分析(转)

源：http://blog.csdn.net/walkingman321/article/details/7218705

本文分析蓝牙协议栈中蓝牙转串口(SPP)部分的实现。

1.  基本概念

Bluez提供了蓝牙转串口的功能，应用程序可以通过dbus接口控制bluez的串口功能。

1.1 启动SPP服务等待远端设备连接的过程：

org.bluez.SerialProxyManager->CreateProxy         // 得到一个serial proxy

org.bluez.SerialProxy->SetSerialParameters          // 设置串口参数

org.bluez.SerialProxy->Enable                // 启动串口

之后，bluez就会等待远端设备连接本地的串口服务

1.2 主动连接远端设备的SPP服务的过程：

当远端设备与本地设备之间建立连接，并且本地设备发现远端设备包含SPP功能，则Bluez将会注册一个“org.bluez.Serial”接口的实例。应用程序可通过调用其中的”Connect”接口，建立与远端设备之间的串口连接。

2.  代码分析

与SPP有关的代码在bluez的serial目录中，其初始化函数为serial_init。

static int serial_init(void)

      。。。

      serial_manager_init(connection);

 

int serial_manager_init(DBusConnection *conn)

      。。。

      btd_register_adapter_driver(&serial_proxy_driver);

      btd_register_device_driver(&serial_port_driver);

serial_manager_init函数中包含两个操作，一个是注册serial_proxy_driver，另一个是注册serial_port_driver。

2.1 serial_proxy_driver

static struct btd_adapter_driver serial_proxy_driver = {

      .name   = "serial-proxy",

      .probe  = proxy_probe,

      .remove = proxy_remove,

};

Bluez启动后，对于每一个蓝牙适配器设备，都会调用其中的proxy_probe函数。

static int proxy_probe(struct btd_adapter *adapter)

      。。。

      proxy_register(connection, adapter);

int proxy_register(DBusConnection *conn, struct btd_adapter *btd_adapter)

      。。。

struct serial_adapter *adapter = g_new0(struct serial_adapter, 1);

adapter->conn = dbus_connection_ref(conn);

adapter->btd_adapter = btd_adapter_ref(btd_adapter);

path = adapter_get_path(btd_adapter);

// 注册SerialProxyManager接口

g_dbus_register_interface(conn, path, SERIAL_MANAGER_INTERFACE,

       manager_methods, manager_signals, NULL,

       adapter, manager_path_unregister);

adapters = g_slist_append(adapters, adapter);

// 这里是根据配置文件注册默认的SerialProxyManager接口，可以跳过

serial_proxy_init(adapter);

SerialProxyManager接口的方法如下：

static GDBusMethodTable manager_methods[] = {

      { "CreateProxy",      "ss",     "s", create_proxy },

      { "ListProxies",        "",  "as",     list_proxies },

      { "RemoveProxy",         "s", "",  remove_proxy },

      { },

};

当应用程序需要建立一个serial proxy实例时，可以调用其中的CreateProxy方法，此方法会映射到create_proxy函数。

static DBusMessage *create_proxy(DBusConnection *conn,

                      DBusMessage *msg, void *data)

      // 得到应用程序传下来的参数

dbus_message_get_args(msg, NULL,

                      DBUS_TYPE_STRING, &pattern,

                      DBUS_TYPE_STRING, &address,

                      DBUS_TYPE_INVALID);

      // 得到uuid

uuid_str = bt_name2string(pattern);

register_proxy(adapter, uuid_str, address, &proxy);

。。。

 

static int register_proxy(struct serial_adapter *adapter,

                      const char *uuid_str, const char *address,

                      struct serial_proxy **proxy)

      // 根据应用程序传下来的地址名称，判断地址类型。类型可以是unix socket、串口或者tcp socket。此socket用于bluez与应用程序之间的串口数据通信。如果应用程序发送数据，就写入此socket；如果应用程序接收数据，就由Bluez写入此socket。address到类型的转换细节可以参考函数的具体实现。

      type = addr2type(address);

      。。。

      // 以下是根据地址类型进入相应的初始化函数

      switch (type) {

      case UNIX_SOCKET_PROXY:

           err = proxy_socket_register(adapter, uuid_str, address, proxy);

           break;

      case TTY_PROXY:

           err = proxy_tty_register(adapter, uuid_str, address, NULL,

                            proxy);

           break;

      case TCP_SOCKET_PROXY:

           err = proxy_tcp_register(adapter, uuid_str, address, proxy);

           break;

      default:

           err = -EINVAL;

      }

      。。。

由于三种地质类型的初始化大同小异，所以这里只研究unix socket类型的情况：

当上层应用使用unix socket时，由应用程序建立一个此类型的socket，然后把socket地址传给Bluez，Bluez同样会根据此地址创建socket。之后，Bluez和应用程序之间就可以通过此socket像操作管道一样互相传递数据。在Bluez的实现中，此socket被用于传递蓝牙的串口数据。

static int proxy_socket_register(struct serial_adapter *adapter,

                      const char *uuid128, const char *address,

                      struct serial_proxy **proxy)

      struct serial_proxy *prx;

prx->address = g_strdup(address);

      prx->uuid128 = g_strdup(uuid128);

      prx->type = UNIX_SOCKET_PROXY;

      adapter_get_address(adapter->btd_adapter, &prx->src);

      prx->adapter = adapter;

      register_proxy_object(prx);

static int register_proxy_object(struct serial_proxy *prx)

      。。。

      g_dbus_register_interface(adapter->conn, path,

                            SERIAL_PROXY_INTERFACE,

                            proxy_methods, NULL, NULL,

                            prx, proxy_path_unregister);

      。。。

以上就是create_proxy的全部操作。到这里仅仅建立了一个串口proxy，但此proxy还未使能。使能操作由应用程序调用上面新注册的接口SERIAL_PROXY_INTERFACE中的Enable方法完成。

static GDBusMethodTable proxy_methods[] = {

      { "Enable",             "",  "",  proxy_enable },

      { "Disable",             "",  "",  proxy_disable },

      { "GetInfo",            "",  "a{sv}",proxy_get_info },

      { "SetSerialParameters",  "syys",  "",  proxy_set_serial_params },

      { },

};

static DBusMessage *proxy_enable(DBusConnection *conn,

                      DBusMessage *msg, void *data)

      。。。

enable_proxy(prx);

。。。

static int enable_proxy(struct serial_proxy *prx)

      。。。

      // 监听RFCOMM通道

      prx->io = bt_io_listen(BT_IO_RFCOMM, NULL, confirm_event_cb, prx,

                      NULL, &gerr,

                      BT_IO_OPT_SOURCE_BDADDR, &prx->src,

                      BT_IO_OPT_INVALID);

      // 当调用listen时，Bluez（本地蓝牙适配器）会分配一个channel，然后在这个channel上等待对方连接。这个channel很重要，因为蓝牙协议中根据channel号区分RFCOMM上的各种应用

      bt_io_get(prx->io, BT_IO_RFCOMM, &gerr,

                  BT_IO_OPT_CHANNEL, &prx->channel,

                 BT_IO_OPT_INVALID);

。。。

sdp_record_t *record;

// 分配一个SDP record，这里把channel号设置到了SDP record里面

record = proxy_record_new(prx->uuid128, prx->channel);

// 将record加入到SDP service中，到这里远端设备就能够看到本地设备的蓝牙服务了。该服务在RFCOMM的prx->channel中

add_record_to_server(&prx->src, record);

prx->record_id = record->handle;

。。。

到这里，本地设备已经准备好接受远端设备的串口连接，对方连接时，上面调用的bt_io_listen中的confirm_event_cb回调函数将被调用。

在confirm_event_cb中，为执行鉴权操作，鉴权成功后调用bt_io_accept建立连接。Accept成功后，回调函数connect_event_cb将被调用。

static void connect_event_cb(GIOChannel *chan, GError *conn_err, gpointer data)

      。。。

      switch (prx->type)

      case UNIX_SOCKET_PROXY:

           sk = unix_socket_connect(prx->address);

           break;

      case TTY_PROXY:

           。。。

      case TCP_SOCKET_PROXY:

           。。。

      g_io_add_watch(prx->rfcomm,

                 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,

                 forward_data, prx);

      g_io_add_watch(prx->local,

                 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,

                 forward_data, prx);

      。。。

unix_socket_connect函数中将根据address建立一个unix socket，并执行了connect。注意到上层应用同样建立了这么一个socket，如果此时上层应用调用select等待在此socket中，那么这里调用connect后，上层应用将得到通知，从而得知与远端设备的连接已经建立。

接下来再看看g_io_add_watch的调用。这里调用两次，一次是针对远端设备的socket；一次是针对与上层应用之间的socket，即刚建立的unix socket。这两个socket之间有一个配对关系，一个用于与远端设备的串口数据传输，另一个用于与上层应用的数据传输。这两个通道关联后就建立了远端设备与上层应用之间的连接，这个关联就由两次g_io_add_watch调用的回调函数forward_data实现。

forward_data被调用时，说明相应的通道上有数据，其伪代码如下：

1.    得到通道上的数据

2.    将数据发送到另一个通道。

通过此种方式，两个通道之间实现了关联。

2.2 serial_port_driver

static struct btd_device_driver serial_port_driver = {

      .name   = "serial-port",

      .uuids   = BTD_UUIDS(RFCOMM_UUID_STR),

      .probe  = port_probe,

      .remove      = port_remove,

};

当包含UUID RFCOMM_UUID_STR的远端设备连接到本地时，Bluez就会调用serial_port_driver的port_probe函数。

static int port_probe(struct btd_device *device, GSList *uuids)

      while (uuids) {

           serial_probe(device, uuids->data);

           uuids = uuids->next;

      }

static int serial_probe(struct btd_device *device, const char *uuid)

      const sdp_record_t * rec = btd_device_get_record(device, uuid);

      // 从SDP record中得到channel号，此channel用于串口通信

      int ch = sdp_get_proto_port(protos, RFCOMM_UUID);

      。。。

port_register(connection, path, &src, &dst, uuid, ch);

 

int port_register(DBusConnection *conn, const char *path, bdaddr_t *src,

                 bdaddr_t *dst, const char *uuid, uint8_t channel)

      。。。

      create_serial_device(conn, path, src, dst);

      。。。

static struct serial_device *create_serial_device(DBusConnection *conn,

                            const char *path, bdaddr_t *src,

                            bdaddr_t *dst)

      // 新建一个serial_device

      Struct serial_device* device = g_new0(struct serial_device, 1);

      。。。

      // 注册一个SERIAL_PORT_INTERFACE接口

      g_dbus_register_interface(conn, path, SERIAL_PORT_INTERFACE,

                      port_methods, NULL, NULL, device, path_unregister);

以上为本地设备发现一个支持SPP的远端设备之后执行的操作，最后就是对这个设备新建了一个SERIAL_PORT_INTERFACE接口的实例。此接口的定义为：

static GDBusMethodTable port_methods[] = {

      { "Connect",    "s", "s", port_connect, G_DBUS_METHOD_FLAG_ASYNC },

      { "Disconnect", "s", "",  port_disconnect },

      { }

};

当上层应用需要主动连接远端设备，而不是被动等待远端设备连接本地设备时，就可以调用这里的connect方法，此方法最终映射到port_connect函数。

Port_connect函数最终是调用到bt_io_connect函数。

bt_io_connect (BT_IO_RFCOMM, rfcomm_connect_cb, port,

                      NULL, NULL,

                      BT_IO_OPT_SOURCE_BDADDR, &device->src,

                      BT_IO_OPT_DEST_BDADDR, &device->dst,

                      BT_IO_OPT_CHANNEL, port->channel,

                      BT_IO_OPT_INVALID);

其中指定的连接成功后的回调函数为rfcomm_connect_cb。

在rfcomm_connect_cb中，调用了ioctl RFCOMMCREATEDEV。

此ioctl会在/dev目录下创建一个设备节点rfcomm%d。此设备节点的名称会被传给上层应用。这样，上层应用就能通过此节点发送、接收数据，其数据与远端设备之间通过蓝牙串口传输。