DBUS入门与应用

转载自：http://www.cnblogs.com/liyiwen/archive/2012/12/02/2798876.html，作者：唐风

DBUD的C编程接口

最近在学 Dbus，不过总是不得其门而入。

大部分资料都讲了很多东西却最终没有让我搞清楚怎么用 DBus，不就是一个 IPC 通信的工具么？就没有一点实用些的资料么？看了很多资料之后还是觉得只见树木不见森林。仔细整理下思路，觉得还是应该从最基本的方面入门，先从 DBus 的 C API 入手学习，有了这些知识，就算麻烦，也可以先在完成一个基本功能的例子程序的同时大概的知道 DBus 的运行机制。

在网上找到这么一篇文章：http://www.matthew.ath.cx/misc/dbus， 正合我意，下面的内容基本是对这篇文章的翻译和扩充。

注意：

1. 翻译没有得到原文作者同意，原文也很简单易懂，最好去读原文。如果收到投诉，我会立即撤掉本文的。
2. 本文不是一篇好的 DBus 入门，有很多基本的东西不在记述之内。
3. 一般情况下不会直接使用 C API 进行 DBus 的编程，而是使用某种 DBus-binding，但我觉得理解 DBus 的 C API 对完整地理解 DBus 是非常重要的。
4. 虽然 DBus 是用 C 写的，而且本文写的是 C API，但是 DBus 设计中充满的面向对象的思想，请注意。

---

一、共通部分的代码

在使用 DBus 进行通信的时候，有一些代码是无论如何都会使用到的。首先，你必须要连接上 Dbus，一般来说，系统中会有一个 System Bus 和一个 Session Bus（他们的差别，请参考我另外的笔记）。其次，你需要在 Dbus 中注册一个名字，用于标识自己。为了简单起见，这里先不考虑重名的情况：

共通用代码

1. DBusError err;
2. DBusConnection* conn;
3. int ret;
4. // initialise the errors
5. dbus_error_init(&err);
6.  
7. // connect to the bus
8. conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
9. if (dbus_error_is_set(&err)) {
10.     fprintf(stderr, "Connection Error (%s)\n", err.message);
11.     dbus_error_free(&err);
12. }
13. if (NULL == conn) {
14.     exit(1);
15. }
16. // request a name on the bus
17. ret = dbus_bus_request_name(conn, "test.method.server",
18.                             DBUS_NAME_FLAG_REPLACE_EXISTING
19.                             , &err);
20. if (dbus_error_is_set(&err)) {
21.     fprintf(stderr, "Name Error (%s)\n", err.message);
22.     dbus_error_free(&err);
23. }
24. if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
25.     exit(1);
26. }

一般来说，连接上 Dbus 和注册一个名称，应该是在程序最开始运行的时候就会进行的操作。

当然，在程序的结束的时候，需要关闭掉与 Dbus 的连接。使用下面的函数：

Code Snippet

1. dbus_connection_close(conn);

二、发送信号（Sending Signal）

信号是一种广播的消息，你可以简单的发出一个信号，这样，所有连接在 DBus 总线上并注册了接受对应信号的进程，都会收到这个信号。为了发出一个信号，需要的只是创建一个 DBusMessage 对象来代表信号，然后追加上一些需要发出的参数，就可以发向总线了。发完之后还需要释放掉 Message。如果内存不足的话，这下面不少函数都会返回 false，所以一般情况下你都需要处理这些情况的返回值。

发送信号

1. dbus_uint32_t serial = 0; // unique number to associate replies with requests
2. DBusMessage* msg;
3. DBusMessageIter args;
4.  
5. // create a signal and check for errors
6. msg = dbus_message_new_signal("/test/signal/Object", // object name of the signal
7.                               "test.signal.Type", // interface name of the signal
8.                               "Test"); // name of the signal
9. if (NULL == msg)
10. {
11.     fprintf(stderr, "Message Null\n");
12.     exit(1);
13. }
14.  
15. // append arguments onto signal
16. dbus_message_iter_init_append(msg, &args);
17. if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &sigvalue)) {
18.     fprintf(stderr, "Out Of Memory!\n");
19.     exit(1);
20. }
21.  
22. // send the message and flush the connection
23. if (!dbus_connection_send(conn, msg, &serial)) {
24.     fprintf(stderr, "Out Of Memory!\n");
25.     exit(1);
26. }
27. dbus_connection_flush(conn);
28.  
29. // free the message
30. dbus_message_unref(msg);

三、调用方法（Calling a Method）

调用一个远程方法（remote method）与发送一个信号（sending a signal）是很类似的。需要创建一个 DBusMessage，然后通过注册在 DBus 上的名称指定发送的对象。然后追加相应的参数，但调用方法分为两种，一种是阻塞式的，另一种则可以异步调用。异步调用的时候会得到一个 DBusMessage* 的返回，从这个 DBusMessage 中可以获取一些返回的参数。

调用方法1

1. DBusMessage* msg;
2. DBusMessageIter args;
3. DBusPendingCall* pending;
4.  
5. msg = dbus_message_new_method_call("test.method.server", // target for the method call
6.                                    "/test/method/Object", // object to call on
7.                                    "test.method.Type", // interface to call on
8.                                    "Method"); // method name
9. if (NULL == msg) {
10.     fprintf(stderr, "Message Null\n");
11.     exit(1);
12. }
13.  
14. // append arguments
15. dbus_message_iter_init_append(msg, &args);
16. if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &param)) {
17.     fprintf(stderr, "Out Of Memory!\n");
18.     exit(1);
19. }
20.  
21. // send message and get a handle for a reply
22. if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout
23.     fprintf(stderr, "Out Of Memory!\n");
24.     exit(1);
25. }
26. if (NULL == pending) {
27.     fprintf(stderr, "Pending Call Null\n");
28.     exit(1);
29. }
30. dbus_connection_flush(conn);
31.  
32. // free message
33. dbus_message_unref(msg);

调用方法2

1. bool stat;
2. dbus_uint32_t level;
3.  
4. // block until we receive a reply
5. dbus_pending_call_block(pending);
6.  
7. // get the reply message
8. msg = dbus_pending_call_steal_reply(pending);
9. if (NULL == msg) {
10.     fprintf(stderr, "Reply Null\n");
11.     exit(1);
12. }
13. // free the pending message handle
14. dbus_pending_call_unref(pending);
15.  
16. // read the parameters
17. if (!dbus_message_iter_init(msg, &args))
18.     fprintf(stderr, "Message has no arguments!\n");
19. else if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&args))
20.     fprintf(stderr, "Argument is not boolean!\n");
21. else
22.     dbus_message_iter_get_basic(&args, &stat);
23.  
24. if (!dbus_message_iter_next(&args))
25.     fprintf(stderr, "Message has too few arguments!\n");
26. else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args))
27.     fprintf(stderr, "Argument is not int!\n");
28. else
29.     dbus_message_iter_get_basic(&args, &level);
30.  
31. printf("Got Reply: %d, %d\n", stat, level);
32.  
33. // free reply and close connection
34. dbus_message_unref(msg);

四、接收消息（Receiving a Signal）

接下来的两种操作主要是从总线从读取消息并处理这些消息。

要接收一个消息，你首先需要告诉 DBus 你对什么样的消息感兴趣：

接收消息1

1. // add a rule for which messages we want to see
2. dbus_bus_add_match(conn,
3.                    "type='signal',interface='test.signal.Type'",
4.                    &err); // see signals from the given interface
5. dbus_connection_flush(conn);
6. if (dbus_error_is_set(&err)) {
7.     fprintf(stderr, "Match Error (%s)\n", err.message);
8.     exit(1);
9. }

然后，进程就可以在一个循环中等待这类消息的发生了：

接收消息2

1. / loop listening for signals being emmitted
2. while (true) {
3.  
4.     // non blocking read of the next available message
5.     dbus_connection_read_write(conn, 0);
6.     msg = dbus_connection_pop_message(conn);
7.  
8.     // loop again if we haven't read a message
9.     if (NULL == msg) {
10.         sleep(1);
11.         continue;
12.     }
13.  
14.     // check if the message is a signal from the correct interface and with the correct name
15.     if (dbus_message_is_signal(msg, "test.signal.Type", "Test")) {
16.         // read the parameters
17.         if (!dbus_message_iter_init(msg, &args))
18.             fprintf(stderr, "Message has no arguments!\n");
19.         else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
20.             fprintf(stderr, "Argument is not string!\n");
21.         else {
22.             dbus_message_iter_get_basic(&args, &sigvalue);
23.             printf("Got Signal with value %s\n", sigvalue);
24.         }
25.     }
26.  
27.     // free the message
28.     dbus_message_unref(msg);
29. }

五、提供被远程调用的方法（Exposing a Method to be called）

在第二节中，我们看到了调用一个远程方法，这节就是告诉我们怎么样提供一个方法让别的应用程序调用。用下面的程序，就可以把方法关联在那些提供给外部的方法上，并解析出相应的参数，最后构建一个消息返回给调用方法的应用程序。

提供被远程调用的方法1

1. // loop, testing for new messages
2. while (true) {
3.     // non blocking read of the next available message
4.     dbus_connection_read_write(conn, 0);
5.     msg = dbus_connection_pop_message(conn);
6.   
7.     // loop again if we haven't got a message
8.     if (NULL == msg) {
9.         sleep(1);
10.         continue;
11.     }
12.  
13.     // check this is a method call for the right interface and method
14.     if (dbus_message_is_method_call(msg, "test.method.Type", "Method"))
15.         reply_to_method_call(msg, conn);
16.  
17.     // free the message
18.     dbus_message_unref(msg);
19. }

 

提供被远程调用的方法2

1. void reply_to_method_call(DBusMessage* msg, DBusConnection* conn)
2. {
3.     DBusMessage* reply;
4.     DBusMessageIter args;
5.     DBusConnection* conn;
6.     bool stat = true;
7.     dbus_uint32_t level = 21614;
8.     dbus_uint32_t serial = 0;
9.     char* param = "";
10.  
11.     // read the arguments
12.     if (!dbus_message_iter_init(msg, &args))
13.         fprintf(stderr, "Message has no arguments!\n");
14.     else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
15.         fprintf(stderr, "Argument is not string!\n");
16.     else
17.         dbus_message_iter_get_basic(&args, &param);
18.     printf("Method called with %s\n", param);
19.  
20.     // create a reply from the message
21.     reply = dbus_message_new_method_return(msg);
22.  
23.     // add the arguments to the reply
24.     dbus_message_iter_init_append(reply, &args);
25.     if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_BOOLEAN, &stat)) {
26.         fprintf(stderr, "Out Of Memory!\n");
27.         exit(1);
28.     }
29.     if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &level)) {
30.         fprintf(stderr, "Out Of Memory!\n");
31.         exit(1);
32.     }
33.  
34.     // send the reply && flush the connection
35.     if (!dbus_connection_send(conn, reply, &serial)) {
36.         fprintf(stderr, "Out Of Memory!\n");
37.         exit(1);
38.     }
39.     dbus_connection_flush(conn);
40.  
41.     // free the reply
42.     dbus_message_unref(reply);
43. }

 

这就基本上全部了。但用这些来理解 DBus 显然还远远不够。接下来，就要对这些程序以及背后的理念进行具体的探究了。

基本概念（C API级别的使用观点）

现在开始解释一下 DBus 的基本概念，顺序反了，但和我的理解过程是一致的。看到 C 的编程接口之后，至少对于它的理解会有一定的感性认识。

DBus是用来进行进程间通信的。下面这张图展示了一些DBus的大部分东西，但是它太复杂了：

DBus 本身是构建在 Socket 机制之上。真正的通信还是由 Socket 来完成的。DBus 则是在这之上，制定了一些通信的协议，并提供了更高一层的接口，以更方便应用程序之间进行数据的交互。

在DBus的体系中，有一个常驻的进程 Daemon，所有进程间的交互都通过它来进行分发和管理。所有希望使用 DBus 进行通信的进程，都必须事先连上 Daemon，并将自己的名字注册到 Daemon 上，之后，Daemon会根据需要把消息以及数据发到相应的进程中。

首先使用

1. conn = dbus_bus_get(DBUS_BUS_SESSION, &err);

让应用程序和 DBus 之间取得连接。之后，使用函数

1. ret = dbus_bus_request_name(conn, "test.method.server",
2.                             DBUS_NAME_FLAG_REPLACE_EXISTING
3.                             , &err);

将自己的进程名字注册到 Daemon 上。（参考前篇的[共通用代码]）。这样通信就有了基础了。

DBus 提供的最简单的一种通信方式是信号（Signal），应用程序可以发送一个信号到 Daemon 上，之后，Daemon 会根据信号的种类和谁希望得到信号等信息，把相应的数据发给每个希望得到信号的进程。也就是 Signal 具有广播的功能。信号具有两个基本的属性，一个是名称，用来标识各个不同的信号，一个是数据，信号是可以带一定的数据的。Signal 的通信过程可以用下面的图大概展示出来：

如果一个进程（比如 B ）想接收接口名为 test.signal.Type 的信号，那么可以使用下面的函数向 Daemon 添加匹配信号，让 Daemon 知道自己对这种信号感兴趣。

1. // add a rule for which messages we want to see
2. dbus_bus_add_match(conn,
3.                    "type='signal',interface='test.signal.Type'",
4.                    &err); // see signals from the given interface

然后， 进程 B 可以使用下面的函数来进行等待：

1. dbus_connection_read_write(conn, 0);
2. msg = dbus_connection_pop_message(conn);

一旦有消息发送过来，进程 B 就可以通过 msg 取到相应的数据了。（参考前篇代码段[接收消息1、2] ）

现在有一个进程 A，

1. dbus_uint32_t serial = 0; // unique number to associate replies with requests
2. DBusMessage* msg;
3.  
4. // create a signal and check for errors
5. msg = dbus_message_new_signal("/test/signal/Object", // object name of the signal
6.                               "test.signal.Type", // interface name of the signal
7.                               "Test"); // name of the signal
8.  
9. // append arguments onto signal
10. dbus_message_iter_init_append(msg, &args);
11. if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &sigvalue)) {
12.     fprintf(stderr, "Out Of Memory!\n");
13.     exit(1);
14. }
15.  
16. // send the message and flush the connection
17. if (!dbus_connection_send(conn, msg, &serial)) {
18.     fprintf(stderr, "Out Of Memory!\n");
19.     exit(1);
20. }

到这里为止，已经涉及到了几个基本而又核心的概念，搞清楚它们，几乎就大概知道了 DBus 的使用方法了。

DBusMessage 是 DBus 中的核心数据结构。可以这样理解：DBus中传递消息数据的时候，就是通过它来传递的。对于使用者来说，DBusMessage 中存储了两种重要的信息，一种是为通信机制服务的各种 Name，一种是通信的数据本身。

各种名字（Name）

在前面用到的很多接口中都还有名称/路径字符串作为参数。

DBus Name： 在 DBus 中最为重要的名字是“Bus Name”，Bus Name 是一个每个应用程序（或是通信对象）用来标识自己用的。几乎可以当成是“IP”地址来理解。Bus Name有两种，一种是“Unique Connection Name”，是以冒号开头的，是全局唯一但“人类不友好”的命名，一种是“Well-know Name”，人类友好的。Bus Name 的命名规则是：

1. Bus name 就像网址一样，由“.”号分割的多个子字符串组成，每个子字符串都必须至少有一个以上的字符。
2. 每个子字符串都只能由“[A-Z][a-z][0-9]_-”这些 ASCII 字符组成，只有 Unique Name 的子串可以以数字开头。
3. 每个 Bus name 至少要有一个“.”，和两个子字符串，不能以“.”开头
4. Bus name 不能超过 255 个字符

几个例子是：Unique Name   :392-2.33 org.freedesktop.DBus 等等

DBus Name 是用来给应用程序进行标识自己的，所以每当程序连上 DBus Daemon 后，就会分配到一个 Unique Name，同时应用程序还可以要求自己分配另一个 Well-know name （通过 dbus_bus_request_name 函数）。

Object path：DBus 中的 object path，与 interface 一样，也只是个概念在更高一层的框架（QT Dbus）中才比较有用，在 C API 这一层，几乎可以无视这个概念，把它当成一个普通的字符串，根据通信的需要，用来做一种标识和区分。

Bus Name确定了一个应用到消息总线的连接。在一个应用中可以有多个提供服务的对象。这些对象按照树状结构组织起来。每个对象都有一个唯一的路径（Object Paths）。或者说，在一个应用中，一个对象路径标志着一个唯一的对象。

Object path 的命名规则是：/com/example/MusicPlayer1

1. object path 可以是任意长度的
2. 以'/'开头，并以以'/'分隔的若干子字符串组成
3. 每个子串必须由“[A-Z][a-z][0-9]_”中的字符组成
4. 不能有空子串（也就是不能连续两个'/'符）
5. 除了“root path”（'/'）之外，不能再有 object path 是以 '/' 结尾的了。

一个 object path 的例子：/com/example/MusicPlayer1

Interface name： 

通过对象路径，我们找到应用中的一个对象。每个对象可以实现多个接口。（关于这点的理解可以参照上面的代码，结合起来就可以理解了！）

DBus 也有 interface 这个概念，主要是用来为更高一层的框架使用方面而设定的。在 C API 这一层，你几乎可以无视这个概念，只需要知道这个一个“字符串”，并在消息匹配是被 DBus 使用到，会随着消息在不同的进程之前传递，从进程 A 发送一个消息或是数据到进程 B 时，其中必定会带有一个部分就是这个字符串，至于 B 进程怎么用（或是无视它）都可以。它的命名规则与 DBus Name 几乎是一样的，只有一点要注意，interface name 中不能带有“-”字符。

Member name：Member 包含两种类型，一种是 Signal，一种是 Method。在大多数方面，他们几乎是一样的，除了两点：1. Signal是在总线中进行广播的，而Method是指定发给某个进程的。2. Signal 不会有返回，而 Method 一定会有返回（同步的或是异步的）。Member name的命名规则是这样的：

1. 只能包含"[A-Z][a-z][0-9]_"这些字符，且不能以数字开头。不能包含“.”。
2. 不能超过255个字符

以 C API 的层面来看，Member name最大的作用就是在两个进程间共享“发出的消息的类型信息”。DBus 只能以 Signal / Method 来进行消息通信，这两种方式都允许在消息发出之前，在消息中 append 各种类型的数据，当通信的对方收到消息后，它就可以通过 Signal / Method 的名称知道如何把各种数据再解析出来。

到现在为止，已经介绍了三种最为重要的 Name，如果与的熟悉 windows 消息机制对比的话，我大概觉得，DBus Name 就是进程的 ID，有了这个你才能把消息发给指定的进程，object path ，interface等概念在“（QT等）高层框架中才有意义”，C API 级别的使用的话，可以无视它的概念，当成消息甄别用的信息就好了。 Member name 相当于 Message type，有了它你才知道怎么去解析发过来的数据。

下篇将会记录 DBusMessage 另一个主要的组成部分：通信数据。

通信数据的设置和获取

前篇主要是有讲一些相对高层的概念，比如 object，interface，method 之类的，对于这些“C 本来没有的东西”，如何在 DBus 中表现的确实很让我迷惑了一阵。但通信数据的发送可能比前面那些名称好理解得多。因为这些概念都是很本来就是底层的，很 C 的。

DBus 提供了一个 DBusMessageIter 的类型，使用这个类型的变量，我们就可以向 DBusMessage 中很容易地加入数据，也可以很容易地从中取出数据。

1. DBusMessage* msg;
2. DBusMessageIter args;
3.  
4. // msg...
5.  
6. dbus_message_iter_init_append(msg, &args);
7. dbus_uint32_t my_data = 10;
8. if(!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &my_data)) {
9.     printf("Out of memory\n");
10.     return RES_FAILED;
11. }
12.  
13. dbus_connection_flush(conn);
14. dbus_message_unref(msg);

第 2 行的代码声明了一个 DBusMessageIter 的对象 args，第 6 行的代码处，对 args 进行初始化，这可以让一个 DBusMessageIter 对象与对应的 DBusMessage 关联起来，后面再对 DBusMessageIter的时候（设置或者取得数据），就是对相应的 DBusMessage 进行处理。然后使用第8行的函数，将一个 uint32 的数据 my_data 追加到 msg 中了。如果还要追加新的参数的话，只需要继续调用该函数，并传入适当的参数就可以了。

1. dbus_bool_t dbus_message_iter_append_basic(DBusMessageIter * iter,
2.                                                           inttype,
3.                                            const void *      value
4.                                            )

这个函数可以用来向 DBusMessageIter 中追加一些“基本类型”（basic）的数据，所谓基本类型的数据，在 DBus 中是这么定义的：

Conventional Name	Encoding	Alignment
BYTE	A single 8-bit byte.	1
BOOLEAN	As for UINT32, but only 0 and 1 are valid values.	4
INT16	16-bit signed integer in the message's byte order.	2
UINT16	16-bit unsigned integer in the message's byte order.	2
INT32	32-bit signed integer in the message's byte order.	4
UINT32	32-bit unsigned integer in the message's byte order.	4
INT64	64-bit signed integer in the message's byte order.	8
UINT64	64-bit unsigned integer in the message's byte order.	8
DOUBLE	64-bit IEEE 754 double in the message's byte order.	8
STRING	A UINT32 indicating the string's length in bytes excluding its terminating nul, followed by non-nul string data of the given length, followed by a terminating nul byte.	4 (for the length)
OBJECT_PATH	Exactly the same as STRING except the content must be a valid object path (see below).	4 (for the length)

（参考 DBus 的在线 API 的 Marshaling (Wire Format) 一节）

有 basic type，当然也就有更复杂的不是 basic 的类型，但这和基本概念的关系不大，在这篇文章中就不多介绍了。（请参考我其它的 DBus 博文）

到现在为止，我已经知道如何把数据入到一个 DBusMessage 中了，那么，如何从一个 DBusMessage 中取出数据呢？比如，我在 A 进程使用上面的代码把 my_data 加到 DBusMessage 中了，现在 B 进程取到了 DBusMessage，如何把数据取出来呢？

1. DBusMessage* msg;
2. DBusMessageIter args;
3.  
4. // get a DBusMessage from process A
5.  
6. if(!dbus_message_iter_init(msg, &args)) {
7.     printf("dbus_message_iter_init error, msg has no arguments!\n");
8. }
9. else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args)){
10.     printf("not a uint 32 type !\n");
11. }
12. else {
13.     dbus_uint32_t my_age = 0;
14.     dbus_message_iter_get_basic(&args, &my_age);
15.     printf("Got signal with value %d\n", my_age);
16. }

很简单，一样的先使用 dbus_messge_iter_init 先把 DBusMessage 对象和从 DBus 总线中取到的 msg 关联起来。这样，使用第 9 行的函数先取得第一个通信数据中第一个参数的类型，如果类型无误的话可以进而使用第 14 行的函数取得参数值本身。

这样，一个简单的数据如何入到 DBusMessage 中，又如何从 DBusMessage 中取出来就明白了。那么如何将 DBusMessage 在进程之间传递呢？

消息的发送和获取

消息的发送其实比较简单，当进程 A 准备申请好一个 DBusMessage对象，设置好它的“类型”（就是各种名字），放好需要通信的数据，之后，使用下面的代码就可以将数据发送到总线上：

1. dbus_uint32_t serial = 0;
2.  
3. if(!dbus_connection_send(conn, msg, &serial)) {
4.     printf("Out of memory");
5.     return RES_FAILED;
6. }
7. dbus_connection_flush(conn);

这很简单，只是 dbus_connection_flush 这个函数有点突兀，它的作用是“Blocks until the outgoing message queue is empty.”，可以简单地理解为调用这个函数可以使用得发送进程一直等消息发送完了才能继续运行。

接受方的代码也很简单：

1. dbus_connection_read_write(conn, 0);
2. msg = dbus_connection_pop_message(conn);
3.  
4. if(NULL == msg) {
5.     sleep(1);
6.     continue;
7. }

使用 1 和 2 行的代码就可以取出发送到本进程的消息，之后就可以使用 msg （如果 msg 不是 NULL 的话）来获取通信数据了。

 

到这里，基本概念就有了。后面，应该对 DBus 的细节再深入的探索。

 

Sample 代码：

发送方进程(my_client)：

My_Client.cpp

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <dbus/dbus.h>
4. #include <unistd.h>
5.  
6. const int RES_SUCCESS = -1;
7. const int RES_FAILED  = 0;
8.  
9. int my_dbus_initialization(char const * _bus_name, DBusConnection ** _conn) {
10.     DBusError err;
11.  
12.     int ret;
13.  
14.     dbus_error_init(&err);
15.  
16.     *_conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
17.     if(dbus_error_is_set(&err)) {
18.         printf("Connection Error\n");
19.         dbus_error_free(&err);
20.         return RES_FAILED;
21.     }
22.  
23.     ret = dbus_bus_request_name(*_conn, _bus_name, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
24.     if(dbus_error_is_set(&err)){
25.         printf("Requece name error \n");
26.         dbus_error_free(&err);
27.         return RES_FAILED;
28.     }
29.  
30.     if(DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
31.         return RES_FAILED;
32.     }
33.  
34.     return RES_SUCCESS;
35. }
36.  
37. int my_dbus_send_sigal(DBusConnection * conn) {
38.     dbus_uint32_t serial = 0;
39.     DBusMessage* msg;
40.     DBusMessageIter args;
41.     char sigvalue[20] = "liyiwen";
42.  
43.     msg = dbus_message_new_signal("/test/signal/Object",  // object name
44.         "test.signal.Type",     // interface name
45.         "Test");                // name of signal
46.  
47.     if (NULL == msg) {
48.         printf("Message Null");
49.         return RES_FAILED;
50.     }
51.  
52.     dbus_message_iter_init_append(msg, &args);
53.  
54.     printf("%s\n", sigvalue);
55.     dbus_uint32_t my_age = 10;
56.     if(!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &my_age)) {
57.         printf("Out of memory\n");
58.         return RES_FAILED;
59.     }
60.  
61.     if(!dbus_connection_send(conn, msg, &serial)) {
62.         printf("Out of memory");
63.         return RES_FAILED;
64.     }
65.     dbus_connection_flush(conn);
66.  
67.     dbus_message_unref(msg);
68.  
69.     return RES_SUCCESS;
70.  
71. }
72.  
73. int main(int agrc, char** argv)
74. {
75.     DBusConnection * conn;
76.  
77.     printf("Start\n");
78.     if (RES_FAILED == my_dbus_initialization("test.method.client", &conn)) {
79.         exit(1);
80.     }
81.     my_dbus_send_sigal(conn);
82.  
83.     while(1){sleep(10);}
84.  
85.     return 0;
86. }

接收方进程（my_server.cpp）

My_Server.cpp

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <dbus/dbus.h>
4. #include <unistd.h>
5.  
6. const int RES_SUCCESS = -1;
7. const int RES_FAILED  = 0;
8.  
9. int my_dbus_initialization(char const * _bus_name, DBusConnection **_conn) {
10.     DBusError err;
11.     int ret;
12.  
13.     dbus_error_init(&err);
14.  
15.     *_conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
16.     if(dbus_error_is_set(&err)) {
17.         printf("Connection Error(%s) \n", err.message);
18.         dbus_error_free(&err);
19.         return RES_FAILED;
20.     }
21.  
22.     ret = dbus_bus_request_name(*_conn, _bus_name, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
23.     if(dbus_error_is_set(&err)){
24.         printf("Requece name error(%s) \n", err.message);
25.         dbus_error_free(&err);
26.         return RES_FAILED;
27.     }
28.     if(DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
29.         return RES_FAILED;
30.     }
31.     return RES_SUCCESS;
32. }
33.  
34. int main(int agrc, char** argv)
35. {
36.  
37.     DBusError err;
38.     DBusMessage* msg;
39.     DBusMessageIter args;
40.  
41.     dbus_error_init(&err);
42.     DBusConnection *conn;
43.     if (RES_FAILED == my_dbus_initialization("test.method.server", &conn)) {
44.         exit(1);
45.     }
46.  
47.     dbus_bus_add_match(conn, "type='signal', interface='test.signal.Type'", &err);
48.  
49.     dbus_connection_flush(conn);
50.     if(dbus_error_is_set(&err)) {
51.         printf("dbus_bus_add_match err (%s)", err.message);
52.         return RES_FAILED;
53.     }
54.  
55.     while(1) {
56.         dbus_connection_read_write(conn, 0);
57.         msg = dbus_connection_pop_message(conn);
58.  
59.         if(NULL == msg) {
60.             sleep(1);
61.             continue;
62.         }
63.  
64.         if(dbus_message_is_signal(msg, "test.signal.Type", "Test")) {
65.             if(!dbus_message_iter_init(msg, &args)) {
66.                 printf("dbus_message_iter_init error, msg has no arguments!\n");
67.             }
68.             else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args)){
69.                 printf("not a uint 32 type !\n");
70.             }
71.             else {
72.                 dbus_uint32_t my_age = 0;
73.                 dbus_message_iter_get_basic(&args, &my_age);
74.                 printf("Got signal with value %d\n", my_age);
75.             }
76.         }
77.  
78.         dbus_message_unref(msg);
79.  
80.     }
81.  
82.     return 0;
83. }

参考资料：

1. http://dbus.freedesktop.org/doc/dbus-specification.html  这当然是最权威最重要的资料，但我觉得不是一个很好的入门资料。
2. http://dbus.freedesktop.org/doc/dbus-tutorial.html 这里面有一些不错的例子，对Names 的解释也很好，但用的是 glib 的 binding，不能探究更底层的动作一度还是让我云里雾里。
3. http://dbus.freedesktop.org/doc/api/html/group__DBusMessage.html  DBus 的 C 编程接口的在线文档，非常棒也非常有用
4. http://dbus.freedesktop.org/doc/dbus/libdbus-tutorial.html 如何用 C API 层面的 DBus ，相见恨晚。