示例#1
0
文件: dbus.cpp 项目: chyla/pat-lms
DBusMessage* DBus::connection_borrow_message(DBusConnection *connection) {
  BOOST_LOG_TRIVIAL(debug) << "dbus::detail::DBus::dbus_connection_borrow_message: Function call";
  return dbus_connection_borrow_message(connection);
}
示例#2
0
DBusMessage * wxDBusConnection::BorrowMessage()
{
	return dbus_connection_borrow_message(m_connection);
}
示例#3
0
TInt Cstif_3::stif_dbus_connection_return_message0( CStifItemParser& aItem )
	{

	TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksRequests ); 
	TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksHandles );  

	DBusConnection* connection;
	DBusError error;
	DBusMessage* msg;
	DBusMessage* borrow_message;
	DBusMessage* reply = NULL;
	char error_name[40];
	char error_msg[40];
	
	dbus_error_init(&error);
	
	connection = dbus_bus_get_private(DBUS_BUS_SESSION, &error);

	if(!connection)
	{
		sprintf(error_name, "Error_name : %s", error.name);
		iLog->Log(_L8(error_name));
		sprintf(error_msg, "Error_msg : %s", error.message);
		iLog->Log(_L8(error_msg));
		return 1;
	}  
	msg = dbus_message_new_method_call("Test.Method.Call1", "/Test/Method/Object", "test.Method.Call", "dbus_connection_return_message0");
	if(msg == NULL)
		{ 
		iLog->Log(_L8("message error"));
		return 1;
		}
		
	reply = dbus_connection_send_with_reply_and_block(connection, msg, 10000, &error);
	if(!reply)
		return handle_error(&error);
	iLog->Log(_L8("Reply Message is been received "));
	

	borrow_message =  dbus_connection_borrow_message (connection )   ;
	
	if(borrow_message== NULL)
		{
			iLog->Log(_L8("Queue is empty"));
			iLog->Log(_L8("Test case failed"));
			return 1;
		}
	else
		{
			dbus_connection_return_message(connection,borrow_message);
			iLog->Log(_L8("dbus_connection_return_message is executed succesfully"));
			iLog->Log( KSuccess );
			dbus_message_unref(msg);  
	   
		   dbus_connection_close(connection);
		   dbus_connection_unref(connection);
		   dbus_shutdown();
 
		    return KErrNone;
		}
	}
示例#4
0
TInt Cstif_3::stif_dbus_connection_pop_message0( CStifItemParser& aItem )
	{

		TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksRequests ); 
		TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksHandles ); 
		
		
		DBusConnection* connection;
		DBusError error; 
		DBusMessage* msg;
		DBusMessage*pop_message;
		DBusMessage* reply = NULL;
		char error_name[40];
		char error_msg[40];
		dbus_int32_t no = 5;
		
		dbus_error_init(&error);
		
		connection = dbus_bus_get_private(DBUS_BUS_SESSION, &error);
	
		if(!connection)
		{
			sprintf(error_name, "Error_name : %s", error.name);
			iLog->Log(_L8(error_name));
			sprintf(error_msg, "Error_msg : %s", error.message);
			iLog->Log(_L8(error_msg));
			return 1;
		}  
		msg = dbus_message_new_method_call("Test.Method.Call1", "/Test/Method/Object", "test.Method.Call", "dbus_connection_pop_message0");
		if(msg == NULL)
			{ 
			iLog->Log(_L8("message error"));
			return 1;
			}
		
		reply = dbus_connection_send_with_reply_and_block(connection, msg, 10000, &error);
		if(!reply)
			return handle_error(&error);
		dbus_message_get_args(reply, &error, DBUS_TYPE_INT32, &no, DBUS_TYPE_INVALID);
	
		pop_message =  dbus_connection_pop_message (connection )   ;
		
		iLog->Log(_L8("Pop message is been executed succesfully"));
		iLog->Log(_L8("Checking for the message in the Queue"));
		pop_message = dbus_connection_borrow_message (connection );
		if(pop_message == NULL)
			{
			iLog->Log(_L8("Queue is empty as the pop message is removed the message from the Queue"));
				iLog->Log( KSuccess );
				dbus_message_unref(msg);  
				   
				   dbus_connection_close(connection);
				   dbus_connection_unref(connection);
				   dbus_shutdown();
 
				
			    return KErrNone;  
			
				
			}
		else
			{
				
				iLog->Log(_L8("TEST CASE FAILED"));
				return 1;	
				
			}
	}
int main()
{
 	
		DBusConnection* connection;
	DBusError error;
	DBusMessage* msg;
	DBusMessage* borrow_message;
	DBusMessage* reply = NULL;
	char error_name[40];
	char error_msg[40];
	
	dbus_error_init(&error);
	
	connection = dbus_bus_get_private(DBUS_BUS_SESSION, &error);

	if(!connection)
	{
		std_log(LOG_FILENAME_LINE, "Error_name :%s",error.name);
		std_log(LOG_FILENAME_LINE, "Error_message:%s",error.message);
		create_xml(1);
		return 1;
	}  
	msg = dbus_message_new_method_call("Test.Method.Call1", "/Test/Method/Object", "test.Method.Call", "dbus_connection_return_message0");
	if(msg == NULL)
		{ 
		std_log(LOG_FILENAME_LINE, "message error");
		create_xml(1);
		return 1;
		}
		
	reply = dbus_connection_send_with_reply_and_block(connection, msg, 10000, &error);
	if(!reply)
		return 1;
		std_log(LOG_FILENAME_LINE, "Reply Message is been received");
	
	

	borrow_message =  dbus_connection_borrow_message (connection )   ;
	
	if(borrow_message== NULL)
		{
			std_log(LOG_FILENAME_LINE, "Queue is empty");
			std_log(LOG_FILENAME_LINE, "Testcase failed");
			create_xml(1);
			return 1;
		}
	else
		{
			dbus_connection_return_message(connection,borrow_message);
			std_log(LOG_FILENAME_LINE, "dbus_connection_return_message os executed successfully");
			std_log(LOG_FILENAME_LINE, "Success");
			create_xml(0);
			dbus_message_unref(msg);  
	   
		   dbus_connection_close(connection);
		   dbus_connection_unref(connection);
		   dbus_shutdown();
 
		    return 0;
		}
			
		
}
示例#6
0
static int dbus_selector_process_recv(DBusConnection* conn, int iswaiting_rpcreply,
                                      DBusPendingCall** pendingargptr)
{
    int ret = 1; /* default fail */

    /* remove this call that consumes .1ms because dbus is already read 
     * by dbus_watch_handle():
     * dbus_connection_read_write(conn, 0);
     * 
     * according to dbus_connection_dispatch(): The incoming data buffer 
     * is filled when the connection reads from its underlying transport 
     * (such as a socket). Reading usually happens in dbus_watch_handle() 
     * or dbus_connection_read_write().
     */
    DBusDispatchStatus dispatch_rc = dbus_connection_get_dispatch_status(conn);
    if ( DBUS_DISPATCH_DATA_REMAINS != dispatch_rc ) {
        printf(" ERROR recv no message in queue \n");
    }
    while( DBUS_DISPATCH_DATA_REMAINS == dispatch_rc ) {
        DBusMessage* msg = dbus_connection_borrow_message(conn);
        if ( msg == NULL ) {
            printf(" ERROR recv pending check FAILED: remains but "
                            "no message borrowed. \n");
            break;
        }
        int mtype = dbus_message_get_type(msg);
        if ( iswaiting_rpcreply &&  
             ( mtype == DBUS_MESSAGE_TYPE_METHOD_RETURN ||
               mtype == DBUS_MESSAGE_TYPE_ERROR           ) ) {
            printf(" RPC REPLY pending check SUCCESS: received rpc reply \n");
            dbus_connection_return_message(conn, msg);
            dbus_connection_dispatch(conn);
                                  /* dispatch so the received message at the 
                                   * head of queue is passed to the pendingcall
                                   */
            dbus_selector_process_post_reply( conn, pendingargptr );
                struct timeval tmn = {0,0}; gettimeofday(&tmn,NULL);
                printf(" RPC returned time  %lu.%06lu\n", tmn.tv_sec, tmn.tv_usec);

                unsigned int tmncost = usdiff(&tmn0, &tmn);
                printf(" RPC cost time      %19s.%06u\n", "", tmncost);

                if ( tmnlistcnt < tmnmax ) {
                    tmnlist[tmnlistcnt] = tmncost;
                    tmnlistcnt ++;
                } else if ( tmnlistcnt == tmnmax ) {
                    unsigned int tmnavg = 0;
                    unsigned int i;
                    for (i=0; i<tmnmax; i++) {
                        tmnavg += tmnlist[i];
                    }
                    tmnavg /= tmnmax;
                    tmnlistcnt ++;
                    printf("time consumed           %9s.%06u\n", "", tmncost);
                    printf("time consumed avg       %30s.%06u tmnmax %u\n", 
                           "", tmnavg, tmnmax);
exit(0);
                }

            printf(" RPC REPLY pending check SUCCESS: processed rpc reply \n");
        } else if ( mtype == DBUS_MESSAGE_TYPE_METHOD_RETURN ) {
            printf(" RECV pending check FAILED: received rpc reply \n");
            dbus_connection_steal_borrowed_message(conn, msg);
            dbus_message_unref(msg);
        } else if ( mtype == DBUS_MESSAGE_TYPE_ERROR ) {
            printf(" RECV pending check FAILED: received ERROR \n");
            dbus_connection_steal_borrowed_message(conn, msg);
            dbus_message_unref(msg);
        } else if ( mtype == DBUS_MESSAGE_TYPE_SIGNAL ) {
            printf(" SIGNAL pending check SUCCESS: received and drop \n");
            dbus_connection_steal_borrowed_message(conn, msg);
            dbus_message_unref(msg);
        } else if ( mtype == DBUS_MESSAGE_TYPE_METHOD_CALL ) {
            printf(" RPC RECV check SUCCESS: received rpc call. \n");
            dbus_connection_steal_borrowed_message(conn, msg);
            DBusMessage* reply = NULL;
            do {
                /* craft a reply message */
                DBusMessageIter args;
                dbus_uint32_t serial = 111;
                dbus_bool_t   stat    = TRUE;
                dbus_uint32_t retval1 = 555;
                const char *strval    = "good";
                reply = dbus_message_new_method_return(msg);
                dbus_message_iter_init_append(reply, &args);
                if ( !dbus_message_iter_append_basic(
                                       &args, DBUS_TYPE_BOOLEAN, &stat) ) {
                    printf(" error rpc reply Out Of Memory!\n");
                    break;
                }
                if ( !dbus_message_iter_append_basic(
                                       &args, DBUS_TYPE_UINT32, &retval1) ) {
                    printf(" error rpc reply Out Of Memory!\n");
                    break;
                }
                if ( !dbus_message_iter_append_basic(
                                       &args, DBUS_TYPE_STRING, &strval) ) {
                    printf(" error rpc reply Out Of Memory!\n");
                    break;
                }
                if ( !dbus_connection_send(conn, reply, &serial)) {
                    printf(" error rpc reply Out Of Memory!\n");
                    break;
                }
                dbus_connection_flush(conn);
            } while(0);
            if ( reply != NULL ) { dbus_message_unref(reply); }
            if ( msg != NULL ) { /* msg not consumed */
                //dbus_connection_return_message(conn, msg);
                dbus_message_unref(msg);
            }
            ret = 0; /* success */
        } else {
            printf(" error unknown msg type %d \n", mtype);
        }
        dispatch_rc = dbus_connection_get_dispatch_status(conn);
    }
    return ret;
}