下载编译dbus

下载https://dbus.freedesktop.org/releases/dbus/

dbussrc1.14.0-Linux文档类资源-CSDN下载

dbus-1.14.0.tar.xz

xz -d dbus-1.14.0.tar.xz
tar xvf dbus-1.14.0.tar

2.配置编译

./configure --prefix=/data/opensrc/dbus  #--prefix=/data/opensrc/dbus 指定输出目录makesudo make install

3

cd /data/opensrc/dbus/include/dbus-1.0/dbus  #/data/opensrc/dbus 是编译产物目录
sudo cp ../../../lib/dbus-1.0/include/dbus/dbus-arch-deps.h   ./

  把/usr/local/lib/dbus-1.0/include/dbus/dbus-arch-deps.h拷贝到/usr/include/dbus

测试代码：

/* server.c */#include <dbus/dbus.h>
#include <stdbool.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>static DBusHandlerResult
filter_func(DBusConnection *connection, DBusMessage *message, void *usr_data)
{dbus_bool_t handled = false;char *word = NULL;DBusError dberr;if (dbus_message_is_signal(message, "client.signal.Type", "Test")) {dbus_error_init(&dberr);dbus_message_get_args(message, &dberr, DBUS_TYPE_STRING,&word, DBUS_TYPE_INVALID);if (dbus_error_is_set(&dberr)) {dbus_error_free(&dberr);} else {printf("receive message %s\n", word);handled = true;}}return (handled ? DBUS_HANDLER_RESULT_HANDLED : DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
}int main(int argc, char *argv[])
{DBusError dberr;DBusConnection *dbconn;dbus_error_init(&dberr);dbconn = dbus_bus_get(DBUS_BUS_SESSION, &dberr);if (dbus_error_is_set(&dberr)) {dbus_error_free(&dberr);return -1;}if (!dbus_connection_add_filter(dbconn, filter_func, NULL, NULL)) {return -1;}dbus_bus_add_match(dbconn, "type='signal',interface='client.signal.Type'", &dberr);if (dbus_error_is_set(&dberr)) {dbus_error_free(&dberr);return -1;}while(dbus_connection_read_write_dispatch(dbconn, -1)) {/* loop */}return 0;
}

 gcc -o  server -I /data/opensrc/dbus/include/dbus-1.0    -L /data/opensrc/dbus/lib   server.cc -l dbus-1
其中：指定头文件目录：data/opensrc/dbus/include/dbus-1.0

           执行库目录：/data/opensrc/dbus/lib

           链接库： dbus-1

编译成功

#include <dbus/dbus.h>
#include <stdbool.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>int db_send(DBusConnection *dbconn)
{DBusMessage *dbmsg;char *word;int i;dbmsg = dbus_message_new_signal("/client/signal/Object", // object name of the signal"client.signal.Type",      // interface name of the signal"Test");                   // name of the signalif (!dbmsg) {return -1;}word = "hello world";if (!dbus_message_append_args(dbmsg, DBUS_TYPE_STRING, &word, DBUS_TYPE_INVALID)) {return -1;}if (!dbus_connection_send(dbconn, dbmsg, NULL)) {return -1;}dbus_connection_flush(dbconn);printf("send message %s\n", word);dbus_message_unref(dbmsg);return 0;
}int main(int argc, char *argv[])
{DBusError dberr;DBusConnection *dbconn;int i;dbus_error_init(&dberr);dbconn = dbus_bus_get(DBUS_BUS_SESSION, &dberr);if (dbus_error_is_set(&dberr)) {return -1;}db_send(dbconn);dbus_connection_unref(dbconn);return 0;
}

 gcc -o  client -I /data/opensrc/dbus/include/dbus-1.0    -L /data/opensrc/dbus/lib   client.cc -l dbus-1

测试：

测试工具安装

sudo apt-get install d-feet

 DBUS基础知识

DBus作为一个轻量级的IPC被越来越多的平台接受，用于进程间通信或进程与内核的通信。
DBus进程间通信主要有三层架构：
1.底层接口层：主要是通过libdbus这个函数库，给予系统使用DBus的能力。 
2.总线层：主 要Message bus daemon这个总线守护进程提供的，在Linux系统启动时运行，负责进程间的消息路由和传递，其中包括Linux内核和Linux桌面环境的消息传 递。总线守护进程可同时与多个应用程序相连，并能把来自一个应用程序的消息路由到0或者多个其他程序。 
3.应用封装层：通过一系列基于特定应用程序框架将DBus的底层接口封装成友好的Wrapper库，供不同开发人员使用。比如libdbus-glib, libdbus-python.

如上图所示，Bus Daemon Process是运行在linux系统中的一个后台守护进程，dbus-daemon运行时会调用libdus的库。Application Process1代表的就是应用程序进程，通过调用特定的应用程序框架的Wrapper库与dbus-daemon进行通信。
从上图也可以看出来Application和Daemon中其实还是通过socket进行通行。

DBus的三大优点：低延迟，低开销，高可用性。

*低延迟：DBus一开始就是用来设计成避免来回传递和允许异步操作的。因此虽然在Application和Daemon之间是通过socket实现的，但是又去掉了socket的循环等待，保证了操作的实时高效。

*低开销：DBus使用一个二进制的协议，不需要转化成像XML这样的文本格式。因为DBus是主要用来机器内部的IPC,而不是为了网络上的IPC机制而准备的.所以它才能够在本机内部达到最优效果。

*高可用性：DBus是基于消息机制而不是字节流机制。它能自动管理一大堆困难的IPC问题。同样的，DBus库被设计来让程序员能够使用他们已经写好的代码。而不会让他们放弃已经写好的代码，被迫通过学习新的IPC机制来根据新的IPC特性重写这些代码。

下面根据上图介绍一下DBus中的一些基本概念。

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

系统总线（System Bus）在引导时就会启动，它由操作系统和后台进程使用，安全性非常好，以使得任意的应用程序不能欺骗系统事件。当然，如果一个应用程序需要接受来自系统总线的消息，他也可以直接连接到系统总线中，但是他能发送的消息是受限的。

Bus Name按字面理解为总线名称貌似不是很贴切，应该是一个连接名称，主要是用来标识一个应用和消息总线的连接。从上图可以看出来，总线名称主要分为两类

"org.kde.StatusNotifierWatcher"这种形式的称为公共名（well-knownname）

":1.3"这种形式的称为唯一名（Unique Name）

公共名提供众所周知的服务。其他应用通过这个名称来使用名称对应的服务。可能有多个连接要求提供同个公共名的服 务，即多个应用连接到消息总线，要求提供同个公共名的服务。消息总线会把这些连接排在链表中，并选择一个连接提供公共名代表的服务。可以说这个提供服务的 连接拥有了这个公共名。如果这个连接退出了，消息总线会从链表中选择下一个连接提供服务。

唯一名以“:”开头，“:”后面通常是圆点分隔的两个数字，例如“:1.0”。每个连接都有一个唯一名。在一个 消息总线的生命期内，不会有两个连接有相同的唯一名。拥有公众名的连接同样有唯一名，例如在前面的图 中，“org.kde.StatusNotifierWatcher”的唯一名是“:1.51”。

每个连接都有一个唯一名，但不一定有公共名。

只有唯一名而没有公共名叫做私有连接，因为它们没有提供可以通过公共名访问的服务。

Object Paths

“org.kde.StatusNotifierWatcher”这个连接中有三个Object Paths，标识这个连接中提供了三个不同的服务，每个Object Paths表示一个服务。这个路径在连接中是唯一的。

Interfaces

在每个Object Paths下都包含有多个接口（Interfaces），举例如下接口：

org.freedesktop.DBus.Introspectable

org.freedesktop.DBus.Properties

org.kde.StatusNotifierWatcher

红色的两个是消息总线提供的标准接口，而剩下的一个是需要具体的应用去实现的。

Methods和Signals

Methods表示可以被具体调用的方法

Signals则表示的是信号，此信号可以被广播，而连接了这个信号的对象在接收到信号时就可以进行相应的处理。和Qt中的信号应该是一个意思。

技术实现

        进程1（Process1）需先连接到总线（dbus_bus_get），其次构造消息（dbus_message_new_signal），然后发送消息（dbus_connection_send）到后台进程。后台进程接收消息，然后根据消息类型对消息进行不同处理（bus_dispatch_matches）。

     进程2（Process2）接收消息前需要连接到总线，并告知总线自己希望得到的消息类型（dbus_bus_add_match），然后等待接收消息（dbus_connection_pop_message）。进程2（Process2）收到总线转发的消息时会根据消息类型，做不同的处理（若是信号类型则不需要发送返回值给总线）。

连接到总线

    进程间通信前，需要连接到总线。调用dbus_bus_get函数连接进程到总线，建立进程和总线之间的连接（DBusConnection）。建立连接后，需要为这个连接注册名称，方便后面对这个连接进行操作，调用dbus_bus_request_name函数对连接进行注册名称。

    建立连接和注册名称是在程序开始时执行，程序结束时，调用dbus_connection_close函数关闭一个连接

DBusConnection *dbus_bus_get (DBusBusType type, DBusError *error) /* 建立和总线的连接 */
int dbus_bus_request_name (DBusConnection *connection,   const char *name, unsigned int flags, DBusError *error) /* 注册连接名称 */
void dbus_connection_close (DBusConnection *connection) /* 关闭连接 */

信号的创建和接收

        DBUS中信号是一种广播的消息，当发出一个信号，所有连接到 DBUS 总线上并注册了接受对应信号的进程，都会收到该信号。

    进程发出一个信号前，需要创建一个 DBusMessage 对象来代表信号，然后追加上一些需要发出的参数，就可以发向总线了。发完之后需要释放消息对象

DBusMessage *dbus_message_new_signal (const char *path, const char *iface, const char *name) /* 创建信号类型消息 */
void dbus_message_iter_init_append ( DBusMessage *message, DBusMessageIter *iter) /* 加入参数到信号 */
dbus_bool_t dbus_connection_send ( DBusConnection *connection, DBusMessage *message, dbus_uint32_t *serial) /* 发送信号到总线 */
void dbus_message_unref (DBusMessage *message) /* 释放消息 */

        进程接收信号时，需先告知总线进程感兴趣的消息，然后等待接收消息

void dbus_bus_add_match ( DBusConnection *connection,   const char *rule, DBusError *error) /* 告知总线感兴趣的消息 */
DBusMessage * dbus_connection_pop_message ( DBusConnection *connection) /* 接收消息 */
dbus_bool_t dbus_message_is_signal (DBusMessage *message, const char *iface, const char *signal_name) /* 判断消息是否为信号 */

send_signal.cc

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dbus/dbus.h>
#include <unistd.h>int send_a_signal(char *sigvalue)
{DBusError err;DBusConnection *connection;DBusMessage *msg;DBusMessageIter arg;dbus_uint32_t  serial = 0;int ret;//步骤1:建立与D-Bus后台的连接dbus_error_init(&err);// initialise the errorsconnection = dbus_bus_get(DBUS_BUS_SESSION, &err );// connect to the busif(dbus_error_is_set(&err)){fprintf(stderr, "ConnectionErr : %s\n", err.message);dbus_error_free(&err);}if(connection == NULL)return -1;//步骤2:给连接名分配一个well-known的名字作为Bus name，这个步骤不是必须的，可以用if 0来注释着一段代码，我们可以用这个名字来检查，是否已经开启了这个应用的另外的进程。
#if 1ret = dbus_bus_request_name(connection, "test.singal.source", DBUS_NAME_FLAG_REPLACE_EXISTING, &err);if(dbus_error_is_set(&err)){fprintf(stderr,"Name Err :%s\n", err.message);dbus_error_free(&err);}if(ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)return -1;
#endif//步骤3:发送一个信号//根据图，我们给出这个信号的路径（即可以指向对象），接口，以及信号名，创建一个Messageif((msg = dbus_message_new_signal("/test/signal/Object", "test.signal.Type", "Test"))== NULL){fprintf(stderr, "MessageNULL\n");return -1;}//给这个信号（messge）具体的内容dbus_message_iter_init_append(msg, &arg);if(!dbus_message_iter_append_basic(&arg, DBUS_TYPE_STRING, &sigvalue)){fprintf(stderr, "Out OfMemory!\n");return -1;}//步骤4: 将信号从连接中发送if(!dbus_connection_send(connection, msg, &serial)){fprintf(stderr, "Out of Memory!\n");return -1;}dbus_connection_flush(connection);printf("Signal Send\n");//步骤5: 释放相关的分配的内存。dbus_message_unref(msg);return 0;
}int main( int argc, char **argv){send_a_signal("Hello,world!");while(1);return 0;
}

revice_signal.cc

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <dbus/dbus.h>  
#include <unistd.h>  void listen_signal()  
{  DBusMessage * msg;  DBusMessageIter arg;  DBusConnection * connection;  DBusError err;  int ret;  char * sigvalue;  //步骤1:建立与D-Bus后台的连接  dbus_error_init(&err);  connection =dbus_bus_get(DBUS_BUS_SESSION, &err);  if(dbus_error_is_set(&err)){  fprintf(stderr,"ConnectionError %s\n",err.message);  dbus_error_free(&err);  }  if(connection == NULL)  return;  //步骤2:给连接名分配一个可记忆名字test.singal.dest作为Bus name，这个步骤不是必须的,但推荐这样处理  ret =dbus_bus_request_name(connection,"test.singal.dest",DBUS_NAME_FLAG_REPLACE_EXISTING,&err);  if(dbus_error_is_set(&err)){  fprintf(stderr,"Name Error%s\n",err.message);  dbus_error_free(&err);  }  if(ret !=DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)  return;  //步骤3:通知D-Bus daemon，希望监听来行接口test.signal.Type的信号  dbus_bus_add_match(connection,"type='signal',interface='test.signal.Type'",&err);  //实际需要发送东西给daemon来通知希望监听的内容，所以需要flush  dbus_connection_flush(connection);  if(dbus_error_is_set(&err)){  fprintf(stderr,"Match Error%s\n",err.message);  dbus_error_free(&err);  }  //步骤4:在循环中监听，每隔开1秒，就去试图自己的连接中获取这个信号。这里给出的是中连接中获取任何消息的方式，所以获取后去检查一下这个消息是否我们期望的信号，并获取内容。我们也可以通过这个方式来获取method call消息。  while(1){  dbus_connection_read_write(connection,0);  msg =dbus_connection_pop_message (connection);  if(msg == NULL){  sleep(1);  continue;  }  if(dbus_message_is_signal(msg,"test.signal.Type","Test")){  if(!dbus_message_iter_init(msg,&arg))  fprintf(stderr,"MessageHas no Param");  else if(dbus_message_iter_get_arg_type(&arg)!= DBUS_TYPE_STRING)  printf("Param isnot string");  else  dbus_message_iter_get_basic(&arg,&sigvalue);  printf("Got Singal withvalue : %s\n",sigvalue);  }  dbus_message_unref(msg);  }//End of while  }  int main( int argc , char ** argv){  listen_signal();  return 0;  
}  

 下图显示的是dbus_bus_request_name 分配的名称

 

函数调用和提供函数调用

dbus-1/dbus-example.c at master · duslabo/dbus-1 · GitHub

        调用一个远程函数与发送一个信号原理类似，需要先创建一个消息（DBusMessage），然后通过注册在 DBUS上的名称指定发送的对象。然后追加相应的参数，调用方法分为两种，一种是阻塞式的，另一种为异步调用。异步调用的时候会得到一个“DBusMessage *” 类型的返回消息，从这个返回消息中可以获取一些返回的参数

DBusMessage *dbus_message_new_method_call (const char *destination, const char *path, const char *iface,
const char *method) /* 创建一个函数调用消息 */
void dbus_message_iter_init_append (DBusMessage *message, DBusMessageIter *iter) /* 为消息添加参数 */
dbus_bool_t dbus_connection_send_with_reply (DBusConnection *connection, DBusMessage *message,
DBusPendingCall **pending_return, int timeout_milliseconds) /* 发送消息 */
void dbus_pending_call_block (DBusPendingCall *pending) /* 阻塞等待返回值 */
DBusMessage * dbus_pending_call_steal_reply (DBusPendingCall *pending) /* 获得返回消息 */
dbus_bool_t dbus_message_iter_init (DBusMessage *message, DBusMessageIter *iter) /* 获取参数 */

        提供远程函数调用，首先需告知总线进程感兴趣的消息，其次从总线获取消息并判定消息是方法调用。然后从消息中获取参数进行函数执行，最后创建返回消息，并发送消息至总线，由总线转发至调用的进程。

void dbus_bus_add_match ( DBusConnection *connection, const char *rule, DBusError *error) /* 请求获取调用消息 */DBusMessage * dbus_connection_pop_message ( DBusConnection *connection) /* 从总线获取消息 */
dbus_bool_t dbus_message_is_method_call (DBusMessage *message, const char *iface, const char *method) /* 判定消息是方法调用 */
dbus_bool_t dbus_message_iter_init (DBusMessage *message, DBusMessageIter *iter) /* 获取参数 */
DBusMessage * dbus_message_new_method_return (DBusMessage *method_call) /* 创建返回消息 */
void dbus_message_iter_init_append ( DBusMessage *message, DBusMessageIter *iter) /* 在消息中填入参数 */
dbus_bool_t dbus_connection_send ( DBusConnection *connection,DBusMessage *message,
dbus_uint32_t *serial) /* 发送返回消息 */

send_method.cc

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <dbus/dbus.h>  
#include <unistd.h>  
//建立与session D-Bus daemo的连接，并设定连接的名字，相关的代码已经多次使用过了  
DBusConnection * connect_dbus(){  DBusError err;  DBusConnection * connection;  int ret;  //Step 1: connecting session bus  dbus_error_init(&err);  connection =dbus_bus_get(DBUS_BUS_SESSION, &err);  if(dbus_error_is_set(&err)){  fprintf(stderr,"ConnectionErr : %s\n",err.message);  dbus_error_free(&err);  }  if(connection == NULL)  return NULL;  //step 2: 设置BUS name，也即连接的名字。  ret =dbus_bus_request_name(connection,"test.wei.source",DBUS_NAME_FLAG_REPLACE_EXISTING,&err);  if(dbus_error_is_set(&err)){  fprintf(stderr,"Name Err :%s\n",err.message);  dbus_error_free(&err);  }  if(ret !=DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)  return NULL;  return connection;     
}  void send_a_method_call(DBusConnection * connection,char * param)  
{  DBusError err;  DBusMessage * msg;  DBusMessageIter    arg;  DBusPendingCall * pending;  dbus_bool_t * stat;  dbus_uint32_t * level;     dbus_error_init(&err);  //针对目的地地址，请参考图，创建一个method call消息。// create a new method call and check for errors  msg =dbus_message_new_method_call ("test.wei.dest",// target for the method call"/test/method/Object",// object to call on"test.method.Type", //interface to call on"Method"); // method name if(msg == NULL){  printf("MessageNULL");  return;  }  //为消息添加参数。Appendarguments  dbus_message_iter_init_append(msg, &arg);  if(!dbus_message_iter_append_basic(&arg, DBUS_TYPE_STRING,&param)){  printf("Out of Memory!");  exit(1);  }  //发送消息并获得reply的handle。Queues a message to send, as withdbus_connection_send() , but also returns aDBusPendingCall used to receive a reply to the message.  if(!dbus_connection_send_with_reply (connection, msg,&pending, -1)){  printf("Out of Memory!");  exit(1);  }       if(pending == NULL){  printf("Pending CallNULL: connection is disconnected ");  dbus_message_unref(msg);  return;  }  dbus_connection_flush(connection);  dbus_message_unref(msg);  //waiting a reply，在发送的时候，已经获取了methodreply的handle，类型为DBusPendingCall。  // block until we recieve a reply， Block until the pendingcall is completed.  dbus_pending_call_block (pending);  //get the reply message，Gets thereply, or returns NULL if none has been received yet.  msg =dbus_pending_call_steal_reply (pending);  if (msg == NULL) {  fprintf(stderr, "ReplyNull\n");  exit(1);  }  // free the pendingmessage handle  dbus_pending_call_unref(pending);  // read the parameters  if(!dbus_message_iter_init(msg, &arg))  fprintf(stderr, "Message hasno arguments!\n");  else if (dbus_message_iter_get_arg_type(&arg) != DBUS_TYPE_BOOLEAN)  fprintf(stderr, "Argument isnot boolean!\n");  else  dbus_message_iter_get_basic(&arg, &stat);  if (!dbus_message_iter_next(&arg))  fprintf(stderr, "Message hastoo few arguments!\n");  else if (dbus_message_iter_get_arg_type(&arg) != DBUS_TYPE_UINT32 )  fprintf(stderr, "Argument isnot int!\n");  else  dbus_message_iter_get_basic(&arg, &level);  printf("Got Reply: %d,%d\n", stat, level);  dbus_message_unref(msg);  
}  int main( int argc , char ** argv){  DBusConnection * connection;  connection = connect_dbus();  if(connection == NULL)  return -1;  send_a_method_call(connection,"Hello, D-Bus");  return 0;  
}  

receive_method.cc

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <dbus/dbus.h>  
#include <unistd.h>  void reply_to_method_call(DBusMessage * msg, DBusConnection * conn){  DBusMessage * reply;  DBusMessageIter arg;  char * param = NULL;  dbus_bool_t stat = TRUE;  dbus_uint32_t level = 2010;  dbus_uint32_t serial = 0;  //从msg中读取参数，这个在上一次学习中学过  if(!dbus_message_iter_init(msg,&arg))  printf("Message has noargs\n");  else if(dbus_message_iter_get_arg_type(&arg)!= DBUS_TYPE_STRING)  printf("Arg is notstring!\n");  else  dbus_message_iter_get_basic(&arg,& param);  if(param == NULL) return;  //创建返回消息reply  reply = dbus_message_new_method_return(msg);  //在返回消息中填入两个参数，和信号加入参数的方式是一样的。这次我们将加入两个参数。  dbus_message_iter_init_append(reply,&arg);  if(!dbus_message_iter_append_basic(&arg,DBUS_TYPE_BOOLEAN,&stat)){  printf("Out ofMemory!\n");  exit(1);  }  if(!dbus_message_iter_append_basic(&arg,DBUS_TYPE_UINT32,&level)){  printf("Out ofMemory!\n");  exit(1);  }  //发送返回消息  if( !dbus_connection_send(conn, reply,&serial)){  printf("Out of Memory\n");  exit(1);  }  dbus_connection_flush (conn);  dbus_message_unref (reply);  
}  void listen_dbus()  
{  DBusMessage * msg;  DBusMessageIter arg;  DBusConnection * connection;  DBusError err;  int ret;  char * sigvalue;  dbus_error_init(&err);  //创建于session D-Bus的连接  connection =dbus_bus_get(DBUS_BUS_SESSION, &err);  if(dbus_error_is_set(&err)){  fprintf(stderr,"ConnectionError %s\n",err.message);  dbus_error_free(&err);  }  if(connection == NULL)  return;  //设置一个BUS name：test.wei.dest  ret =dbus_bus_request_name(connection,"test.wei.dest",DBUS_NAME_FLAG_REPLACE_EXISTING,&err);  if(dbus_error_is_set(&err)){  fprintf(stderr,"Name Error%s\n",err.message);  dbus_error_free(&err);  }  if(ret !=DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)  return;  //要求监听某个singal：来自接口test.signal.Type的信号  dbus_bus_add_match(connection,"type='signal',interface='test.signal.Type'",&err);  dbus_connection_flush(connection);  if(dbus_error_is_set(&err)){  fprintf(stderr,"Match Error%s\n",err.message);  dbus_error_free(&err);  }  while(true){  dbus_connection_read_write(connection,0);  msg =dbus_connection_pop_message (connection);  if(msg == NULL){  sleep(1);  continue;  }  if(dbus_message_is_signal(msg,"test.signal.Type","Test")){  if(!dbus_message_iter_init(msg,&arg))  fprintf(stderr,"Message Has no Param");  else if(dbus_message_iter_get_arg_type(&arg) != DBUS_TYPE_STRING)  printf("Param isnot string");  else  dbus_message_iter_get_basic(&arg,&sigvalue);  }else if(dbus_message_is_method_call(msg,"test.method.Type","Method")){  //我们这里面先比较了接口名字和方法名字，实际上应当现比较路径  if(strcmp(dbus_message_get_path(msg),"/test/method/Object") == NULL)  reply_to_method_call(msg,connection);  }  dbus_message_unref(msg);  }  }  
int main( int argc , char ** argv){  listen_dbus();  return 0;  
}  

dbus-send

dbus-send [--system | --session | --address=ADDRESS ][--address=ADDRESS] [--dest=NAME] [--print-reply [=literal]] [--reply-timeout=MSEC][--type=TYPE] OBJECT_PATH INTERFACE.MEMBER [CONTENTS...]

dbus-daemon