DBUS基础知识

Dear 丶 2022-08-13 11:46 162阅读 0赞

**原文地址：[http://www.cnblogs.com/wzh206/archive/2010/05/13/1734901.html][http_www.cnblogs.com_wzh206_archive_2010_05_13_1734901.html]**

**1. 进程间使用D-Bus通信**

> D-Bus是一种高级的进程间通信机制，它由freedesktop.org项目提供，使用GPL许可证发行。D-Bus最主要的用途是在Linux桌面环境为进程提供通信，同时能将Linux桌面环境和Linux内核事件作为消息传递到进程。D-Bus的主要概率为总线，注册后的进程可通过总线接收或传递消息，进程也可注册后等待内核事件响应，例如等待网络状态的转变或者计算机发出关机指令。目前，D-Bus已被大多数Linux发行版所采用，开发者可使用D-Bus实现各种复杂的进程间通信任务。

**2. D-Bus的基本概念**

> D-Bus是一个消息总线系统，其功能已涵盖进程间通信的所有需求，并具备一些特殊的用途。D-Bus是三层架构的进程间通信系统，其中包括：

> 接口层：接口层由函数库libdbus提供，进程可通过该库使用D-Bus的能力。

> 总线层：总线层实际上是由D-Bus总线守护进程提供的。它在Linux系统启动时运行，负责进程间的消息路由和传递，其中包括Linux内核和Linux桌面环境的消息传递。

> 包装层：包装层一系列基于特定应用程序框架的Wrapper库。

> D-Bus具备自身的协议，协议基于二进制数据设计，与数据结构和编码方式无关。该协议无需对数据进行序列化，保证了信息传递的高效性。无论是libdbus，还是D-Bus总线守护进程，均不需要太大的系统开销。

> 总线是D-Bus的进程间通信机制，一个系统中通常存在多条总线，这些总线由D-Bus总线守护进程管理。最重要的总线为系统总线（System Bus），Linux内核引导时，该总线就已被装入内存。只有Linux内核、Linux桌面环境和权限较高的程序才能向该总线写入消息，以此保障系统安全性，防止有恶意进程假冒Linux发送消息。

> 会话总线（Session Buses）由普通进程创建，可同时存在多条。会话总线属于某个进程私有，它用于进程间传递消息。

> 进程必须注册后才能收到总线中的消息，并且可同时连接到多条总线中。D-Bus提供了匹配器（Matchers）使进程可以有选择性的接收消息，另外运行进程注册回调函数，在收到指定消息时进行处理。匹配器的功能等同与路由，用于避免处理无关消息造成进程的性能下降。除此以外，D-Bus机制的重要概念有以下几个。

> 对象：对象是封装后的匹配器与回调函数，它以对等（peer-to-peer）协议使每个消息都有一个源地址和一个目的地址。这些地址又称为对象路径，或者称之为总线名称。对象的接口是回调函数，它以类似C++的虚拟函数实现。当一个进程注册到某个总线时，都要创建相应的消息对象。

> 消息：D-Bus的消息分为信号（signals）、方法调用（method calls）、方法返回（method returns）和错误（errors）。信号是最基本的消息，注册的进程可简单地发送信号到总线上，其他进程通过总线读取消息。方法调用是通过总线传递参数，执行另一个进程接口函数的机制，用于某个进程控制另一个进程。方法返回是注册的进程在收到相关信息后，自动做出反应的机制，由回调函数实现。错误是信号的一种，是注册进程错误处理机制之一。

> 服务：服务（Services）是进程注册的抽象。进程注册某个地址后，即可获得对应总线的服务。D-Bus提供了服务查询接口，进程可通过该接口查询某个服务是否存在。或者在服务结束时自动收到来自系统的消息。

> **建立服务的流程:**  
> \----------------------------------  
> 建立一个dbus连接之后 -- dbus\_bus\_get()，为这个dbus连接(DbusConnection)起名 -- dbus\_bus\_request\_name()，这个名字将会成为我们在后续进行远程调用的时候的服务名，然后我们进入监听循环 -- dbus\_connection\_read\_write()。在循环中，我们从总线上取出消息 -- dbus\_connection\_pop\_message()，并通过比对消息中的方法接口名和方法名 -- dbus\_message\_is\_method\_call()，如果一致，那么我们跳转到相应的处理中去。在相应的处理中，我们会从消息中取出远程调用的参数。并且建立起回传结果的通路 -- reply\_to\_method\_call()。回传动作本身等同于一次不需要等待结果的远程调用。  
> **发送信号的流程:**  
> \----------------------------------  
> 建立一个dbus连接之后，为这个dbus连接起名，建立一个发送信号的通道，注意，在建立通道的函数中，需要我们填写该信号的接口名和信号名 -- dbus\_message\_new\_signal()。然后我们把信号对应的相关参数压进去 -- dbus\_message\_iter\_init\_append(); dbus\_message\_iter\_append\_basic()。然后就可以启动发送了 -- dbus\_connection\_send(); dbus\_connection\_flush。  
> **进行一次远程调用的流程:**  
> \----------------------------------  
> 建立好dbus连接之后，为这dbus连接命名，申请一个远程调用通道 -- dbus\_message\_new\_method\_call()，注意，在申请远程调用通道的时候，需要填写服务器名，本次调用的接口名，和本次调用名(方法名)。压入本次调用的参数 -- dbus\_message\_iter\_init\_append(); dbus\_message\_iter\_append\_basic()，实际上是申请了一个首地址，我们就是把我们真正要传的参数，往这个首地址里面送(送完之后一般都会判断是否内存越界了)。然后就是启动发送调用并释放发送相关的消息结构 -- dbus\_connection\_send\_with\_reply()。这个启动函数中带有一个句柄。我们马上会阻塞等待这个句柄给我们带回总线上回传的消息。当这个句柄回传消息之后，我们从消息结构中分离出参数。用dbus提供的函数提取参数的类型和参数 -- dbus\_message\_iter\_init(); dbus\_message\_iter\_next(); dbus\_message\_iter\_get\_arg\_type(); dbus\_message\_iter\_get\_basic()。也就达成了我们进行本次远程调用的目的了。  
> **信号接收流程:**  
> \----------------------------------  
> 建立一个dbus连接之后，为这个dbus连接起名，为我们将要进行的消息循环添加匹配条件(就是通过信号名和信号接口名来进行匹配控制的) -- dbus\_bus\_add\_match()。我们进入等待循环后，只需要对信号名，信号接口名进行判断就可以分别处理各种信号了。在各个处理分支上。我们可以分离出消息中的参数。对参数类型进行判断和其他的处理。  
> **[dbus\_connection][dbus_connection]\_read\_write()**  
> \--------------------------------------  
> As long as the connection is open, this function will block until it can read or write, then read or write, then return \#TRUE.  
> If the connection is closed, the function returns \#FALSE.  
> **dbus\_connection\_pop\_message()**  
> \--------------------------------------  
> Returns the first-received message from the incoming message queue, removing it from the queue. The caller owns a reference to the returned message. If the queue is empty, returns \#NULL.  
> **dbus\_connection\_send()**  
> \--------------------------------------  
> Adds a message to the outgoing message queue. Does not block to write the message to the network; that happens asynchronously. To force the message to be written, call dbus\_connection\_flush(). Because this only queues the message, the only reason it can  
> fail is lack of memory. Even if the connection is disconnected, no error will be returned.  
> @param connection the connection.  
> @param message the message to write.  
> @param serial return location for message serial, or \#NULL if you don't care  
> @returns \#TRUE on success.  
> **dbus\_connection\_send\_with\_reply()**  
> \--------------------------------------  
> Queues a message to send, as with dbus\_connection\_send(), but also returns a \#DBusPendingCall used to receive a reply to the message. If no reply is received in the given timeout\_milliseconds, this function expires the pending reply and generates a synthetic error reply (generated in-process, not by the remote application) indicating that a timeout occurred.  
> A \#DBusPendingCall will see a reply message before any filters or registered object path handlers. See dbus\_connection\_dispatch() for details on when handlers are run.  
> A \#DBusPendingCall will always see exactly one reply message, unless it's cancelled with dbus\_pending\_call\_cancel().  
> If \#NULL is passed for the pending\_return, the \#DBusPendingCall will still be generated internally, and used to track the message reply timeout. This means a timeout error will occur if no reply arrives, unlike with dbus\_connection\_send().  
> If -1 is passed for the timeout, a sane default timeout is used. -1 is typically the best value for the timeout for this reason, unless you want a very short or very long timeout. There is no way to avoid a timeout entirely, other than passing INT\_MAX for the  
> timeout to mean "very long timeout." libdbus clamps an INT\_MAX timeout down to a few hours timeout though.  
> @warning if the connection is disconnected, the \#DBusPendingCall will be set to \#NULL, so be careful with this.  
> @param connection the connection  
> @param message the message to send  
> @param pending\_return return location for a \#DBusPendingCall object, or \#NULL if connection is disconnected  
> @param timeout\_milliseconds timeout in milliseconds or -1 for default  
> @returns \#FALSE if no memory, \#TRUE otherwise.  
> **[dbus\_message][dbus_message]\_is\_signal()**  
> \--------------------------------------  
> Checks whether the message is a signal with the given interface and member fields. If the message is not \#DBUS\_MESSAGE\_TYPE\_SIGNAL, or has a different interface or member field, returns \#FALSE.  
> **dbus\_message\_iter\_init()**  
> \--------------------------------------  
> Initializes a \#DBusMessageIter for reading the arguments of the message passed in.  
> **dbus\_message\_iter\_next()**  
> \--------------------------------------  
> Moves the iterator to the next field, if any. If there's no next field, returns \#FALSE. If the iterator moves forward, returns \#TRUE.  
> **dbus\_message\_iter\_get\_arg\_type()**  
> \--------------------------------------  
> Returns the argument type of the argument that the message iterator points to. If the iterator is at the end of the message, returns \#DBUS\_TYPE\_INVALID.  
> **dbus\_message\_iter\_get\_basic()**  
> \--------------------------------------  
> Reads a basic-typed value from the message iterator. Basic types are the non-containers such as integer and string.  
> **dbus\_message\_new\_signal()**  
> \--------------------------------------  
> Constructs a new message representing a signal emission. Returns \#NULL if memory can't be allocated for the message. A signal is identified by its originating object path, interface, and the name of the signal.  
> Path, interface, and signal name must all be valid (the D-Bus specification defines the syntax of these fields).  
> @param path the path to the object emitting the signal  
> @param interface the interface the signal is emitted from  
> @param name name of the signal  
> @returns a new DBusMessage, free with dbus\_message\_unref()  
> **dbus\_message\_iter\_init\_append()**  
> \--------------------------------------  
> Initializes a \#DBusMessageIter for appending arguments to the end of a message.  
> @param message the message  
> @param iter pointer to an iterator to initialize  
> **dbus\_message\_iter\_append\_basic()**  
> \--------------------------------------  
> Appends a basic-typed value to the message. The basic types are the non-container types such as integer and string.  
> @param iter the append iterator  
> @param type the type of the value  
> @param value the address of the value  
> @returns \#FALSE if not enough memory  
> **dbus\_message\_new\_method\_call()**  
> \--------------------------------------  
> Constructs a new message to invoke a method on a remote object. Returns \#NULL if memory can't be allocated for the message. The destination may be \#NULL in which case no destination is set; this is appropriate when using D-Bus in a peer-to-peer context (no message bus). The interface may be \#NULL, which means that if multiple methods with the given name exist it is undefined which one will be invoked.  
> The path and method names may not be \#NULL.  
> Destination, path, interface, and method name can't contain any invalid characters (see the D-Bus specification).  
> @param destination name that the message should be sent to or \#NULL  
> @param path object path the message should be sent to  
> @param interface interface to invoke method on, or \#NULL  
> @param method method to invoke  
> @returns a new DBusMessage, free with dbus\_message\_unref()  
> **[dbus\_bus][dbus_bus]\_get()**  
> \--------------------------------------  
> Connects to a bus daemon and registers the client with it. If a connection to the bus already exists, then that connection is returned. The caller of this function owns a reference to the bus.  
> @param type bus type  
> @param error address where an error can be returned.  
> @returns a \#DBusConnection with new ref  
> **dbus\_bus\_request\_name()**  
> \--------------------------------------  
> Asks the bus to assign the given name to this connection by invoking the RequestName method on the bus.  
> First you should know that for each bus name, the bus stores a queue of connections that would like to own it. Only one owns it at a time - called the primary owner. If the primary owner releases the name or disconnects, then the next owner in the queue atomically takes over.  
> So for example if you have an application org.freedesktop.TextEditor and multiple instances of it can be run, you can have all of them sitting in the queue. The first one to start up will receive messages sent to org.freedesktop.TextEditor, but if that one exits another will become the primary owner and receive messages.  
> The queue means you don't need to manually watch for the current owner to disappear and then request the name again.  
> @param connection the connection  
> @param name the name to request  
> @param flags flags  
> @param error location to store the error  
> @returns a result code, -1 if error is set  
> 给DBusConnection起名字(命名) -- 两个相互通信的连接(connection)不能同名  
> 命名规则: xxx.xxx (zeng.xiaolong)  
> **dbus\_bus\_add\_match()**  
> \--------------------------------------  
> Adds a match rule to match messages going through the message bus. The "rule" argument is the string form of a match rule.  
> @param connection connection to the message bus  
> @param rule textual form of match rule  
> @param error location to store any errors  
> **dbus\_pending\_call\_block()**  
> \--------------------------------------  
> Block until the pending call is completed. The blocking is as with dbus\_connection\_send\_with\_reply\_and\_block(); it does not enter the main loop or process other messages, it simply waits for the reply in question.  
> If the pending call is already completed, this function returns immediately.  
> @todo when you start blocking, the timeout is reset, but it should really only use time remaining since the pending call was created. This requires storing timestamps instead of intervals in the timeout  
> @param pending the pending call  
> **dbus\_pending\_call\_steal\_reply()**  
> \--------------------------------------  
> Gets the reply, or returns \#NULL if none has been received yet. Ownership of the reply message passes to the caller. This function can only be called once per pending call, since the reply message is tranferred to the caller.  
> @param pending the pending call  
> @returns the reply message or \#NULL.

> 安装D-Bus可在其官方网站下载源码编译，地址为[http://dbus.freedesktop.org][http_dbus.freedesktop.org]。或者在终端上输入下列指令：

1.  1.  yum install dbus dbus-devel dbus-doc

> 安装后，头文件位于"/usr/include/dbus-<版本号>/dbus"目录中，编译使用D-Bus的程序时需加入编译指令"\`pkg-config --cflags --libs dbus-1\`"。

**3. D-Bus的用例**

> 在使用GNOME桌面环境的Linux系统中，通常用GLib库提供的函数来管理总线。在测试下列用例前，首先需要安装GTK+开发包（见22.3节）并配置编译环境。该用例一共包含两个程序文件，每个程序文件需单独编译成为可执行文件。

> **1．消息发送程序**

> "dbus-ding-send.c"程序每秒通过会话总线发送一个参数为字符串Ding!的信号。该程序的源代码如下：

> 1.  \#include <glib.h> // 包含glib库
> 2.  \#include <dbus/dbus-glib.h> // 包含  
>     glib库中D-Bus管理库
> 3.  \#include <stdio.h>
> 4.  static gboolean send\_ding(DBusConnection \*bus);// 定义发送消息函数的原型
> 5.  int main ()
> 6.  \{
> 7.  GMainLoop \*loop; // 定义一个事件循环对象的指针
> 8.  DBusConnection \*bus; // 定义总线连接对象的指针
> 9.  DBusError error; // 定义D-Bus错误消息对象
> 10. loop = g\_main\_loop\_new(NULL, FALSE); // 创建新事件循环对象
> 11. dbus\_error\_init (&error); // 将错误消息对象连接到D-Bus
> 12. // 错误消息对象
> 13. bus = dbus\_bus\_get(DBUS\_BUS\_SESSION, &error);// 连接到总线
> 14. if (!bus) \{ // 判断是否连接错误
> 15. g\_warning("连接到D-Bus失败: %s", error.message);
> 16. // 使用GLib输出错误警告信息
> 17. dbus\_error\_free(&error); // 清除错误消息
> 18. return 1;
> 19. \}
> 20. dbus\_connection\_setup\_with\_g\_main(bus, NULL);
> 21. // 将总线设为接收GLib事件循环
> 22. g\_timeout\_add(1000, (GSourceFunc)send\_ding, bus);
> 23. // 每隔1000ms调用一次send\_ding()函数
> 24. // 将总线指针作为参数
> 25. g\_main\_loop\_run(loop); // 启动事件循环
> 26. return 0;
> 27. \}
> 28. static gboolean send\_ding(DBusConnection \*bus) // 定义发  
>     送消息函数的细节
> 29. \{
> 30. DBusMessage \*message; // 创建消息对象指针
> 31. message = dbus\_message\_new\_signal("/com/burtonini/dbus/ding",
> 32. "com.burtonini.dbus.Signal",
> 33. "ding"); // 创建消息对象并标识路径
> 34. dbus\_message\_append\_args(message,
> 35. DBUS\_TYPE\_STRING, "ding!",
> 36. DBUS\_TYPE\_INVALID); //将字符串Ding!定义为消息
> 37. dbus\_connection\_send(bus, message, NULL); // 发送该消息
> 38. dbus\_message\_unref(message); // 释放消息对象
> 39. g\_print("ding!\\n"); // 该函数等同与标准输入输出  
>     
> 40. return TRUE;
> 41. \}
> 
> main()函数创建一个GLib事件循环，获得会话总线的一个连接，并将D-Bus事件处理集成到GLib事件循环之中。然后它创建了一个名为send\_ding()函数作为间隔为一秒的计时器，并启动事件循环。send\_ding()函数构造一个来自于对象路径"/com/burtonini/dbus/ding"和接口"com.burtonini.dbus.Signal"的新的Ding信号。然后，字符串Ding!作为参数添加到信号中并通过总线发送。在标准输出中会打印一条消息以让用户知道发送了一个信号。

> **2．消息接收程序**

> dbus-ding-listen.c程序通过会话总线接收dbus-ding-send.c程序发送到消息。该程序的源代码如下：

> 1.  \#include <glib.h> // 包含glib库
> 2.  \#include <dbus/dbus-glib.h> // 包含glib库中D-Bus管理库
> 3.  static DBusHandlerResult signal\_filter // 定义接收消息函数的原型
> 4.  (DBusConnection \*connection, DBusMessage \*message, void \*user\_data);
> 5.  int main()
> 6.  \{
> 7.  GMainLoop \*loop; // 定义一个事件循环对象的指针
> 8.  DBusConnection \*bus; // 定义总线连接对象的指针
> 9.  DBusError error; // 定义D-Bus错误消息对象
> 10. loop = g\_main\_loop\_new(NULL, FALSE); // 创建新事件循环对象
> 11. dbus\_error\_init(&error); // 将错误消息对象连接到D-Bus
> 12. // 错误消息对象
> 13. bus = dbus\_bus\_get(DBUS\_BUS\_SESSION, &error); // 连接到总线
> 14. if (!bus) \{ // 判断是否连接错误
> 15. g\_warning("连接到D-Bus失败: %s", error.message);
> 16. // 使用GLib输出错误警告信息
> 17. dbus\_error\_free(&error); // 清除错误消息
> 18. return 1;
> 19. \}
> 20. dbus\_connection\_setup\_with\_g\_main(bus, NULL);
> 21. // 将总线设为接收GLib事件循环
> 22. dbus\_bus\_add\_match(bus, "type='signal',interface  
>     ='com.burtonini.dbus.Signal'"); // 定义匹配器
> 23. dbus\_connection\_add\_filter(bus, signal\_filter, loop, NULL);
> 24. // 调用函数接收消息
> 25. g\_main\_loop\_run(loop); // 启动事件循环
> 26. return 0;
> 27. \}
> 28. static DBusHandlerResult // 定义接收消息函数的细节
> 29. signal\_filter (DBusConnection \*connection,  
>     DBusMessage \*message, void \*user\_data)
> 30. \{
> 31. GMainLoop \*loop = user\_data; // 定义事件循环对象的指针，并与主函数中的同步
> 32. if (dbus\_message\_is\_signal // 接收连接成功消息，判断是否连接失败
> 33. (message, DBUS\_INTERFACE\_ORG\_FREEDESKTOP\_LOCAL,  
>     "Disconnected")) \{
> 34. g\_main\_loop\_quit (loop); // 退出主循环
> 35. return DBUS\_HANDLER\_RESULT\_HANDLED;
> 36. \}
> 37. if (dbus\_message\_is\_signal(message, "com.burtonini.dbus.Signal",
> 38. "Ping")) \{
> 39. // 指定消息对象路径，判断是否成功
> 40. DBusError error; // 定义错误对象
> 41. char \*s;
> 42. dbus\_error\_init(&error); // 将错误消息对象连接到D-Bus错误
> 43. // 消息对象
> 44. if (dbus\_message\_get\_args // 接收消息，并判断是否有错误
> 45. (message, &error, DBUS\_TYPE\_STRING, &s,  
>     DBUS\_TYPE\_INVALID)) \{
> 46. g\_print("接收到的消息是: %s\\n", s); // 输出接收到的消息
> 47. dbus\_free (s); // 清除该消息
> 48. \}
> 49. else \{ // 有错误时执行下列语句
> 50. g\_print("消息已收到，但有错误提示: %s\\n", error.message);
> 51. dbus\_error\_free (&error);
> 52. \}
> 53. return DBUS\_HANDLER\_RESULT\_HANDLED;
> 54. \}
> 55. return DBUS\_HANDLER\_RESULT\_NOT\_YET\_HANDLED;
> 56. \}
> 
> 该程序侦听dbus-ping-send.c程序正在发出的信号。main()函数和前面一样启动，创建一个到总线的连接。然后它声明愿意在使用com.burtonini.dbus.Signal接口的信号被发送时得到通知，将signal\_filter()函数设置为通知函数，然后进入事件循环。当满足匹配的消息被发送时，signal\_func()函数会被调用。
> 
> 如果需要确定在接收消息时如何处理，可通过检测消息头实现。若收到的消息为总线断开信号，则主事件循环将被终止，因为监听的总线已经不存在了。若收到其他的消息，首先将收到的消息与期待的消息进行比较，两者相同则输出其中参数，并退出程序。两者不相同则告知总线并没有处理该消息，这样消息会继续保留在总线中供别的程序处理。

[http_www.cnblogs.com_wzh206_archive_2010_05_13_1734901.html]: http://www.cnblogs.com/wzh206/archive/2010/05/13/1734901.html
[dbus_connection]: http://dbus.freedesktop.org/doc/api/html/group__DBusConnection.html#g9d4515606dd1fc4fc098885e0eeaa586
[dbus_message]: http://dbus.freedesktop.org/doc/api/html/group__DBusMessage.html
[dbus_bus]: http://dbus.freedesktop.org/doc/api/html/group__DBusBus.html
[http_dbus.freedesktop.org]: http://dbus.freedesktop.org/