dbus参考代码--在一个dbus方法中调用另外一个dbus服务端提供的方法

ゝ一纸荒年。 2022-02-26 09:54 599阅读 1赞

这是在网上的代码基础上修改的，主要是项目中用到了dbus的嵌套调用，所以写了测试代码。贴出来供参考。

转载请注明：http://blog.csdn.net/shanzhizi

  1. /********************************************************************************/ 
  2. /*
  3. * Example low-level D-Bus code.
  4. * Written by Matthew Johnson <dbus@matthew.ath.cx>
  5. *
  6. * This code has been released into the Public Domain.
  7. * You may do whatever you like with it.
  8. */
  9. #include <dbus/dbus.h>
  10. #include <stdbool.h>
  11. #include <unistd.h>
  12. #include <stdio.h>
  13. #include <stdlib.h> 
  15. DBusConnection* g_conn;
  16. /**http://blog.csdn.net/shanzhizi
  17. * Connect to the DBUS bus and send a broadcast signal
  18. */
  19. void sendsignal(char* sigvalue)
  20. {
  21.    DBusMessage* msg;
  22.    DBusMessageIter args;
  23.    DBusConnection* conn;
  24.    DBusError err;
  25.    int ret;
  26.    dbus_uint32_t serial = 0; 
  27.    printf("Sending signal with value %s\n", sigvalue); 
  28.    // initialise the error value
  29.    dbus_error_init(&err); 
  30.    // connect to the DBUS system bus, and check for errors
  31.    conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
  32.    if (dbus_error_is_set(&err)) { 
  33.       fprintf(stderr, "Connection Error (%s)\n", err.message); 
  34.       dbus_error_free(&err); 
  35.    }
  36.    if (NULL == conn) { 
  37.       exit(1); 
  38.    } 
  39.    // register our name on the bus, and check for errors
  40.    ret = dbus_bus_request_name(conn, "test.signal.source", DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
  41.    if (dbus_error_is_set(&err)) { 
  42.       fprintf(stderr, "Name Error (%s)\n", err.message); 
  43.       dbus_error_free(&err); 
  44.    }
  45.    if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) { 
  46.       exit(1);
  47.    } 
  48.    // create a signal & check for errors 
  49.    msg = dbus_message_new_signal("/test/signal/Object", // object name of the signal
  50.                                  "test.signal.Type",    // interface name of the signal
  51.                                  "Test");               // name of the signal
  52.    if (NULL == msg) 
  53.    { 
  54.       fprintf(stderr, "Message Null\n"); 
  55.       exit(1); 
  56.    } 
  57.    // append arguments onto signal
  58.    dbus_message_iter_init_append(msg, &args);
  59.    if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &sigvalue)) {
  60.       fprintf(stderr, "Out Of Memory!\n"); 
  61.       exit(1);
  62.    } 
  63.    // send the message and flush the connection
  64.    if (!dbus_connection_send(conn, msg, &serial)) {
  65.       fprintf(stderr, "Out Of Memory!\n"); 
  66.       exit(1);
  67.    }
  68.    dbus_connection_flush(conn);
  70.    printf("Signal Sent\n");
  72.    // free the message 
  73.    dbus_message_unref(msg);
  74. } 
  77. /**
  78. * Call a method on a remote object
  79. */
  80. void query(char* param) 
  81. {
  82.    DBusMessage* msg;
  83.    DBusMessageIter args;
  84.    DBusConnection* conn;
  85.    DBusError err;
  86.    DBusPendingCall* pending;
  87.    int ret;
  88.    char *stat = "";
  89.    dbus_uint32_t level; 
  90.    printf("Calling remote method with %s\n", param); 
  91.    // initialiset the errors
  92.    dbus_error_init(&err); 
  93.    // connect to the system bus and check for errors
  94.    conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
  95.    if (dbus_error_is_set(&err)) { 
  96.       fprintf(stderr, "Connection Error (%s)\n", err.message); 
  97.       dbus_error_free(&err);
  98.    }
  99.    if (NULL == conn) { 
  100.       exit(1); 
  101.    } 
  102.    // request our name on the bus
  103.    ret = dbus_bus_request_name(conn, "ws.method.cgi", DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
  104.    if (dbus_error_is_set(&err)) { 
  105.       fprintf(stderr, "Name Error (%s)\n", err.message); 
  106.       dbus_error_free(&err);
  107.    }
  108.    if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) { 
  109.       exit(1);
  110.    } 
  111.    // create a new method call and check for errors
  112.    msg = dbus_message_new_method_call("ws.method.listen",// target for the method call
  113.                                       "/ws/method/object", // object to call on
  114.                                       "ws.method.Type",    // interface to call on
  115.                                       "Method");             // method name
  116.    if (NULL == msg) { 
  117.       fprintf(stderr, "Message Null\n");
  118.       exit(1);
  119.    } 
  120.    // append arguments
  121.    dbus_message_iter_init_append(msg, &args);
  122.    if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, m)) {
  123.       fprintf(stderr, "Out Of Memory!\n"); 
  124.       exit(1);
  125.    }
  127.    // send message and get a handle for a reply
  128.    if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout
  129.       fprintf(stderr, "Out Of Memory!\n"); 
  130.       exit(1);
  131.    }
  132.    if (NULL == pending) { 
  133.       fprintf(stderr, "Pending Call Null\n"); 
  134.       exit(1); 
  135.    }
  136.    dbus_connection_flush(conn);
  138.    printf("Request Sent\n");
  140.    // free message
  141.    dbus_message_unref(msg);
  143.    // block until we recieve a reply
  144.    dbus_pending_call_block(pending); 
  145.    // get the reply message
  146.    msg = dbus_pending_call_steal_reply(pending);
  147.    if (NULL == msg) {
  148.       fprintf(stderr, "Reply Null\n"); 
  149.       exit(1); 
  150.    }
  151.    // free the pending message handle
  152.    dbus_pending_call_unref(pending); 
  153.    // read the parameters
  154.    if (!dbus_message_iter_init(msg, &args))
  155.       fprintf(stderr, "Message has no arguments!\n"); 
  156.    else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) 
  157.       fprintf(stderr, "Argument is not boolean!\n"); 
  158.    else
  159.       dbus_message_iter_get_basic(&args, &stat); 
  160.    if (!dbus_message_iter_next(&args))
  161.       fprintf(stderr, "Message has too few arguments!\n"); 
  162.    else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args)) 
  163.       fprintf(stderr, "Argument is not int!\n"); 
  164.    else
  165.       dbus_message_iter_get_basic(&args, &level); 
  166.    printf("Got Reply: %s, %d\n", stat, level);
  168.    // free reply 
  169.    dbus_message_unref(msg);   
  170. } 
  175. /**http://blog.csdn.net/shanzhizi
  176. * Call a method on a remote object
  177. */
  178. void igmp_query(DBusConnection* conn,char* param) 
  179. {
  180.     DBusMessage* msg;
  181.    DBusMessageIter args;
  182.    DBusPendingCall* pending;
  183.    int ret;
  184.    char *stat="";
  185.    dbus_uint32_t level; 
  187.    // create a new method call and check for errors
  188.    msg = dbus_message_new_method_call("ws.method.igmp",// target for the method call
  189.                                       "/ws/method/object", // object to call on
  190.                                       "ws.method.Type",    // interface to call on
  191.                                       "Method");             // method name
  192.    if (NULL == msg) { 
  193.       fprintf(stderr, "Message Null\n");
  194.       exit(1);
  195.    } 
  196.    // append arguments
  197.    dbus_message_iter_init_append(msg, &args);
  198.    if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, m)) {
  199.       fprintf(stderr, "Out Of Memory!\n"); 
  200.       exit(1);
  201.    }
  203.    // send message and get a handle for a reply
  204.    if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout
  205.       fprintf(stderr, "Out Of Memory!\n"); 
  206.       exit(1);
  207.    }
  208.    if (NULL == pending) { 
  209.       fprintf(stderr, "Pending Call Null\n"); 
  210.       exit(1); 
  211.    }
  212.    dbus_connection_flush(conn);
  214.    printf("igmp Request Sent\n");
  216.    // free message
  217.    dbus_message_unref(msg);
  219.    // block until we recieve a reply
  220.    dbus_pending_call_block(pending); 
  221.    // get the reply message
  222.    msg = dbus_pending_call_steal_reply(pending);
  223.    if (NULL == msg) {
  224.       fprintf(stderr, "Reply Null\n"); 
  225.       exit(1); 
  226.    }
  227.    // free the pending message handle
  228.    dbus_pending_call_unref(pending); 
  229.    // read the parameters
  230.    if (!dbus_message_iter_init(msg, &args))
  231.       fprintf(stderr, "Message has no arguments!\n"); 
  232.    else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) 
  233.       fprintf(stderr, "Argument is not boolean!\n"); 
  234.    else
  235.       dbus_message_iter_get_basic(&args, &stat); 
  236.    if (!dbus_message_iter_next(&args))
  237.       fprintf(stderr, "Message has too few arguments!\n"); 
  238.    else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args)) 
  239.       fprintf(stderr, "Argument is not int!\n"); 
  240.    else
  241.       dbus_message_iter_get_basic(&args, &level); 
  242.    printf("Got Reply: %s, %d\n", stat, level);
  244.    // free reply 
  245.    dbus_message_unref(msg);   
  246. } 
  249. DBusMessage        *reply_to_method_call(DBusMessage* msg, void *user_data)
  250. {
  251.    DBusMessage* reply;
  252.    DBusMessageIter args;
  253.    bool stat = true;
  254.    dbus_uint32_t level = 10;
  255.    dbus_uint32_t serial = 0;
  256.    char* param = ""; 
  257.    char returnstr[30]="cgi server return";
  258.    char *ssparam = returnstr;
  259.    // read the arguments
  260.    if (!dbus_message_iter_init(msg, &args))
  261.       fprintf(stderr, "Message has no arguments!\n"); 
  262.    else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) 
  263.       fprintf(stderr, "Argument is not string!\n"); 
  264.    else 
  265.       dbus_message_iter_get_basic(&args, m); 
  267.    printf("Method called with %s\n", param); 
  268. igmp_query(g_conn,"igmp");     
  269.    // create a reply from the message
  270.    reply = dbus_message_new_method_return(msg); 
  271.    // add the arguments to the reply
  272.    /*dbus_message_iter_init_append(reply, &args);
  273.    if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &ssparam)) { 
  274.       fprintf(stderr, "Out Of Memory!\n"); 
  275.       exit(1);
  276.    }
  277.    printf("******************\n");
  278.    if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &level)) { 
  279.       fprintf(stderr, "Out Of Memory!\n"); 
  280.       exit(1);
  281.    } */
  283.    dbus_message_append_args (reply,
  284.                                 DBUS_TYPE_STRING,&ssparam,
  285.                                 DBUS_TYPE_UINT32,&level,
  286.                                 DBUS_TYPE_INVALID);
  288.                                 return reply;
  290. } 
  292. DBusHandlerResult ws_dbus_message_handler_listen(DBusConnection *connection, DBusMessage *message, void *user_data)
  293. {
  294.     DBusMessage        *reply = NULL;
  295.     const char * path =dbus_message_get_path(message);
  296.     if(NULL==path){
  297.         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  298.     }
  299.     if (strcmp(path,"/ws/method/object") == 0) {
  300.     /*syslog_ax_dbus_dbg("npd obj path"WS_DBUS_METHOD_OBJPATH"\r\n");*/
  301.         if (dbus_message_is_method_call(message,"ws.method.Type","Method")) {
  302.             reply = reply_to_method_call(message,user_data);
  303.         }else{
  304.             printf("unknown method call\n");
  305.         }
  306.     }else{
  307.             printf("unknown path call\n");;
  308.     }
  310.     if(reply){
  311.                // send the reply && flush the connection
  312.            if (!dbus_connection_send(connection, reply, NULL)) {
  313.                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  314.            }
  315.            dbus_connection_flush(connection);
  316.            // free the reply
  317.            dbus_message_unref(reply);
  319.         return DBUS_HANDLER_RESULT_HANDLED ;
  320.     }else{
  321.         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  322.     }
  323. }
  326. DBusMessage        *reply_to_method_call_igmp(DBusMessage* msg, void *user_data)
  327. {
  328.    DBusMessage* reply;
  329.    DBusMessageIter args;
  330.    bool stat = true;
  331.    dbus_uint32_t level = 20;
  332.    dbus_uint32_t serial = 0;
  333.    char* param = ""; 
  334.    char returnstr[30]="igmp server return";
  335.    char *ssparam = returnstr;
  336.    // read the arguments
  337.    if (!dbus_message_iter_init(msg, &args))
  338.       fprintf(stderr, "Message has no arguments!\n"); 
  339.    else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) 
  340.       fprintf(stderr, "Argument is not string!\n"); 
  341.    else 
  342.       dbus_message_iter_get_basic(&args, m); 
  344.    printf("Method called with %s\n", param); 
  346.    // create a reply from the message
  347.    reply = dbus_message_new_method_return(msg); 
  348.    // add the arguments to the reply
  349.    /*dbus_message_iter_init_append(reply, &args);
  350.    if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &ssparam)) { 
  351.       fprintf(stderr, "Out Of Memory!\n"); 
  352.       exit(1);
  353.    }
  354.    printf("******************\n");
  355.    if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &level)) { 
  356.       fprintf(stderr, "Out Of Memory!\n"); 
  357.       exit(1);
  358.    } */
  359.    dbus_message_append_args (reply,
  360.                                 DBUS_TYPE_STRING,&ssparam,
  361.                                 DBUS_TYPE_UINT32,&level,
  362.                                 DBUS_TYPE_INVALID);
  364.                                 return reply;
  366. } 
  367. DBusHandlerResult ws_dbus_message_handler_igmp(DBusConnection *connection, DBusMessage *message, void *user_data)
  368. {
  369.     DBusMessage        *reply = NULL;
  370.     const char * path =dbus_message_get_path(message);
  371.     if(NULL==path){
  372.         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  373.     }
  374.     if (strcmp(path,"/ws/method/object") == 0) {
  375.     /*syslog_ax_dbus_dbg("npd obj path"WS_DBUS_METHOD_OBJPATH"\r\n");*/
  376.         if (dbus_message_is_method_call(message,"ws.method.Type","Method")) {
  377.             reply = reply_to_method_call_igmp(message,user_data);
  378.         }else{
  379.             printf("unknown method call\n");
  380.         }
  381.     }else{
  382.             printf("unknown path call\n");
  383.     }
  385.     if(reply){
  386.                // send the reply && flush the connection
  387.            if (!dbus_connection_send(connection, reply, NULL)) {
  388.                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  389.            }
  390.            dbus_connection_flush(connection);
  391.            // free the reply
  392.            dbus_message_unref(reply);
  394.         return DBUS_HANDLER_RESULT_HANDLED ;
  395.     }else{
  396.         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  397.     }
  398. }
  401. /**
  402. * Server that exposes a method call and waits for it to be called
  403. */
  404. void listen() 
  405. {
  406.    DBusMessage* msg;
  407.    DBusMessage* reply;
  408.    DBusMessageIter args;
  409.    //DBusConnection* conn;
  410.    DBusError err;
  411.    int ret;
  412.    char* param; 
  413.    printf("Listening for method calls\n"); 
  414.    // initialise the error
  415.    dbus_error_init(&err);
  417.    // connect to the bus and check for errors
  418.    g_conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
  419.    if (dbus_error_is_set(&err)) { 
  420.       fprintf(stderr, "Connection Error (%s)\n", err.message); 
  421.       dbus_error_free(&err); 
  422.    }
  423.    if (NULL == g_conn) {
  424.       fprintf(stderr, "Connection Null\n"); 
  425.       exit(1); 
  426.    }
  428.    // request our name on the bus and check for errors
  429.    ret = dbus_bus_request_name(g_conn, "ws.method.listen", 
  430.                                DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
  431.    if (dbus_error_is_set(&err)) { 
  432.       fprintf(stderr, "Name Error (%s)\n", err.message); 
  433.       dbus_error_free(&err);
  434.    }
  435.    if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) { 
  436.       fprintf(stderr, "Not Primary Owner (%d)\n", ret);
  437.       exit(1); 
  438.    } 
  439.    // loop, testing for new messages
  440.    /*while (true) {
  441.       // non blocking read of the next available message
  442.       dbus_connection_read_write(conn, -1);
  443.       msg = dbus_connection_pop_message(conn); 
  444.       // loop again if we haven't got a message
  445.       if (NULL == msg) { 
  446.          sleep(1); 
  447.          continue; 
  448.       }
  450.       // check this is a method call for the right interface & method
  451.       if (dbus_message_is_method_call(msg, "test.method.Type", "Method"))
  452.       {
  453.           igmp_query(conn,"igmp");
  454.          reply_to_method_call(msg, conn,"daemon return",201); 
  455.       }
  456.       // free the message
  457.       dbus_message_unref(msg);
  458.    }*/
  460.     // 设置处理消息的函数  56:  
  461.       if (!dbus_connection_add_filter (g_conn, ws_dbus_message_handler_listen, NULL, NULL)) { 
  462.                 return;  
  463.      }  
  464.       // 分派消息的Loop 
  465.        while (dbus_connection_read_write_dispatch (g_conn, -1))  
  466.             sleep(0);
  467. } 
  471. /**
  472. * Server that exposes a method call and waits for it to be called
  473. */
  474. void listen_igmp() 
  475. {
  476.    DBusMessage* msg;
  477.    DBusMessage* reply;
  478.    DBusMessageIter args;
  479.    DBusConnection* conn;
  480.    DBusError err;
  481.    int ret;
  482.    char* param; 
  483.    printf("Listening for method calls\n"); 
  484.    // initialise the error
  485.    dbus_error_init(&err);
  487.    // connect to the bus and check for errors
  488.    conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
  489.    if (dbus_error_is_set(&err)) { 
  490.       fprintf(stderr, "Connection Error (%s)\n", err.message); 
  491.       dbus_error_free(&err); 
  492.    }
  493.    if (NULL == conn) {
  494.       fprintf(stderr, "Connection Null\n"); 
  495.       exit(1); 
  496.    }
  498.    // request our name on the bus and check for errors
  499.    ret = dbus_bus_request_name(conn, "ws.method.igmp", 
  500.                                DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
  501.    if (dbus_error_is_set(&err)) { 
  502.       fprintf(stderr, "Name Error (%s)\n", err.message); 
  503.       dbus_error_free(&err);
  504.    }
  505.    if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) { 
  506.       fprintf(stderr, "Not Primary Owner (%d)\n", ret);
  507.       exit(1); 
  508.    } 
  509.    // 设置处理消息的函数  56:  
  510.       if (!dbus_connection_add_filter (conn, ws_dbus_message_handler_igmp, NULL, NULL)) { 
  511.                 return;  
  512.      }  
  513.       // 分派消息的Loop 
  514.        while (dbus_connection_read_write_dispatch (conn, -1))  
  515.             sleep(0);
  516. } 
  521. /**
  522. * Listens for signals on the bus
  523. */
  524. void receive()
  525. {
  526.    DBusMessage* msg;
  527.    DBusMessageIter args;
  528.    DBusConnection* conn;
  529.    DBusError err;
  530.    int ret;
  531.    char* sigvalue; 
  532.    printf("Listening for signals\n"); 
  533.    // initialise the errors
  534.    dbus_error_init(&err);
  536.    // connect to the bus and check for errors
  537.    conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
  538.    if (dbus_error_is_set(&err)) { 
  539.       fprintf(stderr, "Connection Error (%s)\n", err.message);
  540.       dbus_error_free(&err); 
  541.    }
  542.    if (NULL == conn) { 
  543.       exit(1);
  544.    }
  546.    // request our name on the bus and check for errors
  547.    ret = dbus_bus_request_name(conn, "test.signal.sink", DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
  548.    if (dbus_error_is_set(&err)) { 
  549.       fprintf(stderr, "Name Error (%s)\n", err.message);
  550.       dbus_error_free(&err); 
  551.    }
  552.    if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
  553.       exit(1);
  554.    } 
  555.    // add a rule for which messages we want to see
  556.    dbus_bus_add_match(conn, "type='signal',interface='test.signal.Type'", &err); // see signals from the given interface
  557.    dbus_connection_flush(conn);
  558.    if (dbus_error_is_set(&err)) { 
  559.       fprintf(stderr, "Match Error (%s)\n", err.message);
  560.       exit(1); 
  561.    }
  562.    printf("Match rule sent\n"); 
  563.    // loop listening for signals being emmitted
  564.    while (true) { 
  565.       // non blocking read of the next available message
  566.       dbus_connection_read_write(conn, 0);
  567.       msg = dbus_connection_pop_message(conn); 
  568.       // loop again if we haven't read a message
  569.       if (NULL == msg) { 
  570.          sleep(1);
  571.          continue;
  572.       } 
  573.       // check if the message is a signal from the correct interface and with the correct name
  574.       if (dbus_message_is_signal(msg, "test.signal.Type", "Test")) {
  576.          // read the parameters
  577.          if (!dbus_message_iter_init(msg, &args))
  578.             fprintf(stderr, "Message Has No Parameters\n");
  579.          else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) 
  580.             fprintf(stderr, "Argument is not string!\n"); 
  581.          else
  582.             dbus_message_iter_get_basic(&args, &sigvalue);
  584.          printf("Got Signal with value %s\n", sigvalue);
  585.       } 
  586.       // free the message
  587.       dbus_message_unref(msg);
  588.    }
  589. } 
  593. int main(int argc, char** argv)
  594. {
  595.  char* param = "no param"; 
  596.  printf("#Kluter T1:argc=%d\n", argc);
  597.  if (2 > argc) 
  598.  {
  599.       printf ("Syntax: dbus-example [send|receive|listen|query] [<param>]\n");
  600.       return 1;
  601.    } 
  603.  if (3 >= argc && NULL != argv[2]) 
  604.   param = argv[2]; 
  605.  if (0 == strcmp(argv[1], "send"))
  606.   sendsignal(param);
  607.  else if (0 == strcmp(argv[1], "receive"))
  608.   receive();
  609.  else if (0 == strcmp(argv[1], "listen"))
  610.   listen();
  611.  else if (0 == strcmp(argv[1], "query"))
  612.   query(param);
  613.   else if(0 == strcmp(argv[1]),"listen_igmp")
  614.       listen_igmp();
  615.  else 
  616.  {
  617.   printf ("Syntax: dbus-example [send|receive|listen|query] [<param>]\n");
  618.   return 1;
  619.  }
  620.  return 0;
  621. } 
  622. /****************************************************************************/

发表评论

表情：
评论列表 （有 0 条评论，599人围观）

还没有评论，来说两句吧...

相关阅读

    相关 dbus(dbus-daemon)

    如何高效的利用dbus做client-server架构 //如果要传回数据到client侧，假设处理过的数据为：your\_strcut\_tdealed\_with\_

    悠悠悠悠/ 0 赞/ 95 阅读

    相关 dbus和qtdbus

    什么是D-Bus？ D-Bus是一种消息总线系统，用于两个应用之间的通信。 对于进程间通信，D-Bus也可以管理应用的生命周期， Qt D-Bus D-Bus

    冷不防冷不防/ 0 赞/ 76 阅读

    相关 DBus学习资料

    网上搜集的一些关于dbus学习的资料。尤其是“一个完整的DBus学习教程”这份资料非常有借鉴意义。另外DBus官方网站中dbus-tutorial这篇文章也非常值得学习。还有“

    桃扇骨桃扇骨/ 0 赞/ 202 阅读