int main (int argc, char **argv) { DBusConnection *connection; DBusError error; EchoData echo_data; int result; echo_data.argc = argc; echo_data.argv = argv; dbus_error_init (&error); connection = dbus_bus_get (DBUS_BUS_STARTER, &error); if (connection == NULL) { fprintf (stderr, "*** Failed to open connection to activating message bus: %s\n", error.message); dbus_error_free (&error); return 1; } loop = _dbus_loop_new (); if (loop == NULL) die ("No memory\n"); if (!test_connection_setup (loop, connection)) die ("No memory\n"); if (!dbus_connection_add_filter (connection, filter_func, NULL, NULL)) die ("No memory"); if (!dbus_connection_register_object_path (connection, echo_path, &echo_vtable, (void*) &echo_data)) die ("No memory"); { void *d; if (!dbus_connection_get_object_path_data (connection, echo_path, &d)) die ("No memory"); if (d != (void*) &echo_data) die ("dbus_connection_get_object_path_data() doesn't seem to work right\n"); } result = dbus_bus_request_name (connection, "org.freedesktop.DBus.TestSuiteShellEchoServiceSuccess", 0, &error); if (dbus_error_is_set (&error)) { fprintf (stderr, "Error %s\n", error.message); _dbus_verbose ("*** Failed to acquire service: %s\n", error.message); dbus_error_free (&error); exit (1); } _dbus_verbose ("*** Test service entering main loop\n"); _dbus_loop_run (loop); test_connection_shutdown (loop, connection); dbus_connection_remove_filter (connection, filter_func, NULL); dbus_connection_unref (connection); _dbus_loop_unref (loop); loop = NULL; dbus_shutdown (); _dbus_verbose ("*** Test service exiting\n"); return 0; }
static int Open( vlc_object_t *p_this ) { intf_thread_t *p_intf = (intf_thread_t*)p_this; /* initialisation of the connection */ if( !dbus_threads_init_default() ) return VLC_EGENERIC; intf_sys_t *p_sys = calloc( 1, sizeof( intf_sys_t ) ); if( unlikely(!p_sys) ) return VLC_ENOMEM; playlist_t *p_playlist; DBusConnection *p_conn; p_sys->i_player_caps = PLAYER_CAPS_NONE; p_sys->i_playing_state = PLAYBACK_STATE_INVALID; if( vlc_pipe( p_sys->p_pipe_fds ) ) { free( p_sys ); msg_Err( p_intf, "Could not create pipe" ); return VLC_EGENERIC; } DBusError error; dbus_error_init( &error ); /* connect privately to the session bus * the connection will not be shared with other vlc modules which use dbus, * thus avoiding a whole class of concurrency issues */ p_conn = dbus_bus_get_private( DBUS_BUS_SESSION, &error ); if( !p_conn ) { msg_Err( p_this, "Failed to connect to the D-Bus session daemon: %s", error.message ); dbus_error_free( &error ); free( p_sys ); return VLC_EGENERIC; } dbus_connection_set_exit_on_disconnect( p_conn, FALSE ); /* register a well-known name on the bus */ char unique_service[sizeof (DBUS_MPRIS_BUS_NAME) + 10]; snprintf( unique_service, sizeof (unique_service), DBUS_MPRIS_BUS_NAME"-%"PRIu32, (uint32_t)getpid() ); dbus_bus_request_name( p_conn, unique_service, 0, &error ); if( dbus_error_is_set( &error ) ) { msg_Err( p_this, "Error requesting service name %s: %s", unique_service, error.message ); dbus_error_free( &error ); free( p_sys ); return VLC_EGENERIC; } msg_Dbg( p_intf, "listening on dbus as: %s", unique_service ); dbus_bus_request_name( p_conn, DBUS_MPRIS_BUS_NAME, 0, NULL ); /* Register the entry point object path */ dbus_connection_register_object_path( p_conn, DBUS_MPRIS_OBJECT_PATH, &dbus_mpris_vtable, p_this ); dbus_connection_flush( p_conn ); p_intf->pf_run = Run; p_intf->p_sys = p_sys; p_sys->p_conn = p_conn; p_sys->p_events = vlc_array_new(); p_sys->p_timeouts = vlc_array_new(); p_sys->p_watches = vlc_array_new(); vlc_mutex_init( &p_sys->lock ); p_playlist = pl_Get( p_intf ); p_sys->p_playlist = p_playlist; var_AddCallback( p_playlist, "item-current", AllCallback, p_intf ); var_AddCallback( p_playlist, "intf-change", AllCallback, p_intf ); var_AddCallback( p_playlist, "volume", AllCallback, p_intf ); var_AddCallback( p_playlist, "mute", AllCallback, p_intf ); var_AddCallback( p_playlist, "playlist-item-append", AllCallback, p_intf ); var_AddCallback( p_playlist, "playlist-item-deleted", AllCallback, p_intf ); var_AddCallback( p_playlist, "random", AllCallback, p_intf ); var_AddCallback( p_playlist, "repeat", AllCallback, p_intf ); var_AddCallback( p_playlist, "loop", AllCallback, p_intf ); var_AddCallback( p_playlist, "fullscreen", AllCallback, p_intf ); if( !dbus_connection_set_timeout_functions( p_conn, add_timeout, remove_timeout, timeout_toggled, p_intf, NULL ) ) { dbus_connection_unref( p_conn ); free( p_sys ); return VLC_ENOMEM; } if( !dbus_connection_set_watch_functions( p_conn, add_watch, remove_watch, watch_toggled, p_intf, NULL ) ) { dbus_connection_unref( p_conn ); free( p_sys ); return VLC_ENOMEM; } /* dbus_connection_set_wakeup_main_function( p_conn, wakeup_main_loop, p_intf, NULL); */ return VLC_SUCCESS; }
/** * wpa_supplicant_dbus_ctrl_iface_init - Initialize dbus control interface * @global: Pointer to global data from wpa_supplicant_init() * Returns: Pointer to dbus_ctrl_iface date or %NULL on failure * * Initialize the dbus control interface and start receiving commands from * external programs over the bus. */ struct ctrl_iface_dbus_priv * wpa_supplicant_dbus_ctrl_iface_init(struct wpa_global *global) { struct ctrl_iface_dbus_priv *iface; DBusError error; int ret = -1; DBusObjectPathVTable wpas_vtable = { NULL, &wpas_message_handler, NULL, NULL, NULL, NULL }; iface = wpa_zalloc(sizeof(struct ctrl_iface_dbus_priv)); if (iface == NULL) return NULL; iface->global = global; /* Get a reference to the system bus */ dbus_error_init(&error); iface->con = dbus_bus_get(DBUS_BUS_SYSTEM, &error); dbus_error_free(&error); if (!iface->con) { perror("dbus_bus_get[ctrl_iface_dbus]"); wpa_printf(MSG_ERROR, "Could not acquire the system bus."); goto fail; } /* Tell dbus about our mainloop integration functions */ if (integrate_with_eloop(iface->con, iface)) goto fail; /* Register the message handler for the global dbus interface */ if (!dbus_connection_register_object_path(iface->con, WPAS_DBUS_PATH, &wpas_vtable, iface)) { perror("dbus_connection_register_object_path[dbus]"); wpa_printf(MSG_ERROR, "Could not set up DBus message " "handler."); goto fail; } /* Register our service with the message bus */ dbus_error_init(&error); switch (dbus_bus_request_name(iface->con, WPAS_DBUS_SERVICE, 0, &error)) { case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER: ret = 0; break; case DBUS_REQUEST_NAME_REPLY_EXISTS: case DBUS_REQUEST_NAME_REPLY_IN_QUEUE: case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER: perror("dbus_bus_request_name[dbus]"); wpa_printf(MSG_ERROR, "Could not request DBus service name: " "already registered."); break; default: perror("dbus_bus_request_name[dbus]"); wpa_printf(MSG_ERROR, "Could not request DBus service name: " "%s %s.", error.name, error.message); break; } dbus_error_free(&error); if (ret != 0) goto fail; wpa_printf(MSG_DEBUG, "Providing DBus service '" WPAS_DBUS_SERVICE "'."); /* * Dispatch initial DBus messages that may have come in since the bus * name was claimed above. Happens when clients are quick to notice the * wpa_supplicant service. * * FIXME: is there a better solution to this problem? */ eloop_register_timeout(0, 50, dispatch_initial_dbus_messages, iface->con, NULL); return iface; fail: wpa_supplicant_dbus_ctrl_iface_deinit(iface); return NULL; }
int rd_acquire( rd_device **_d, DBusConnection *connection, const char *device_name, const char *application_name, int32_t priority, rd_request_cb_t request_cb, DBusError *error) { rd_device *d = NULL; int r, k; DBusError _error; DBusMessage *m = NULL, *reply = NULL; dbus_bool_t good; if (!error) error = &_error; dbus_error_init(error); if (!_d) return -EINVAL; if (!connection) return -EINVAL; if (!device_name) return -EINVAL; if (!request_cb && priority != INT32_MAX) return -EINVAL; if (!(d = calloc(sizeof(rd_device), 1))) return -ENOMEM; d->ref = 1; if (!(d->device_name = strdup(device_name))) { r = -ENOMEM; goto fail; } if (!(d->application_name = strdup(application_name))) { r = -ENOMEM; goto fail; } d->priority = priority; d->connection = dbus_connection_ref(connection); d->request_cb = request_cb; if (!(d->service_name = malloc(sizeof(SERVICE_PREFIX) + strlen(device_name)))) { r = -ENOMEM; goto fail; } sprintf(d->service_name, SERVICE_PREFIX "%s", d->device_name); if (!(d->object_path = malloc(sizeof(OBJECT_PREFIX) + strlen(device_name)))) { r = -ENOMEM; goto fail; } sprintf(d->object_path, OBJECT_PREFIX "%s", d->device_name); if ((k = dbus_bus_request_name( d->connection, d->service_name, DBUS_NAME_FLAG_DO_NOT_QUEUE| (priority < INT32_MAX ? DBUS_NAME_FLAG_ALLOW_REPLACEMENT : 0), error)) < 0) { r = -EIO; goto fail; } if (k == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) goto success; if (k != DBUS_REQUEST_NAME_REPLY_EXISTS) { r = -EIO; goto fail; } if (priority <= INT32_MIN) { r = -EBUSY; goto fail; } if (!(m = dbus_message_new_method_call( d->service_name, d->object_path, "org.freedesktop.ReserveDevice1", "RequestRelease"))) { r = -ENOMEM; goto fail; } if (!dbus_message_append_args( m, DBUS_TYPE_INT32, &d->priority, DBUS_TYPE_INVALID)) { r = -ENOMEM; goto fail; } if (!(reply = dbus_connection_send_with_reply_and_block( d->connection, m, 5000, /* 5s */ error))) { if (dbus_error_has_name(error, DBUS_ERROR_TIMED_OUT) || dbus_error_has_name(error, DBUS_ERROR_UNKNOWN_METHOD) || dbus_error_has_name(error, DBUS_ERROR_NO_REPLY)) { /* This must be treated as denied. */ r = -EBUSY; goto fail; } r = -EIO; goto fail; } dbus_message_unref(m); m = NULL; if (!dbus_message_get_args( reply, error, DBUS_TYPE_BOOLEAN, &good, DBUS_TYPE_INVALID)) { r = -EIO; goto fail; } dbus_message_unref(reply); reply = NULL; if (!good) { r = -EBUSY; goto fail; } if ((k = dbus_bus_request_name( d->connection, d->service_name, DBUS_NAME_FLAG_DO_NOT_QUEUE| (priority < INT32_MAX ? DBUS_NAME_FLAG_ALLOW_REPLACEMENT : 0)| DBUS_NAME_FLAG_REPLACE_EXISTING, error)) < 0) { r = -EIO; goto fail; } if (k != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) { r = -EIO; goto fail; } success: d->owning = 1; if (!(dbus_connection_register_object_path( d->connection, d->object_path, &vtable, d))) { r = -ENOMEM; goto fail; } d->registered = 1; if (!dbus_connection_add_filter( d->connection, filter_handler, d, NULL)) { r = -ENOMEM; goto fail; } d->filtering = 1; *_d = d; return 0; fail: if (m) dbus_message_unref(m); if (reply) dbus_message_unref(reply); if (&_error == error) dbus_error_free(&_error); if (d) rd_release(d); return r; }
static int Open( vlc_object_t *p_this ) { /* initialisation of the connection */ intf_thread_t *p_intf = (intf_thread_t*)p_this; intf_sys_t *p_sys = malloc( sizeof( intf_sys_t ) ); playlist_t *p_playlist; DBusConnection *p_conn; DBusError error; char *psz_service_name = NULL; if( !p_sys ) return VLC_ENOMEM; p_sys->b_meta_read = false; p_sys->i_caps = CAPS_NONE; p_sys->b_dead = false; p_sys->p_input = NULL; p_sys->i_playing_state = -1; p_sys->b_unique = var_CreateGetBool( p_intf, "dbus-unique-service-id" ); if( p_sys->b_unique ) { if( asprintf( &psz_service_name, "%s-%d", DBUS_MPRIS_BUS_NAME, getpid() ) < 0 ) { free( p_sys ); return VLC_ENOMEM; } } else { psz_service_name = strdup(DBUS_MPRIS_BUS_NAME); } dbus_error_init( &error ); /* connect to the session bus */ p_conn = dbus_bus_get( DBUS_BUS_SESSION, &error ); if( !p_conn ) { msg_Err( p_this, "Failed to connect to the D-Bus session daemon: %s", error.message ); dbus_error_free( &error ); free( p_sys ); return VLC_EGENERIC; } /* register a well-known name on the bus */ dbus_bus_request_name( p_conn, psz_service_name, 0, &error ); if( dbus_error_is_set( &error ) ) { msg_Err( p_this, "Error requesting service %s: %s", psz_service_name, error.message ); dbus_error_free( &error ); free( psz_service_name ); free( p_sys ); return VLC_EGENERIC; } msg_Info( p_intf, "listening on dbus as: %s", psz_service_name ); free( psz_service_name ); /* we register the objects */ dbus_connection_register_object_path( p_conn, DBUS_MPRIS_ROOT_PATH, &dbus_mpris_root_vtable, p_this ); dbus_connection_register_object_path( p_conn, DBUS_MPRIS_PLAYER_PATH, &dbus_mpris_player_vtable, p_this ); dbus_connection_register_object_path( p_conn, DBUS_MPRIS_TRACKLIST_PATH, &dbus_mpris_tracklist_vtable, p_this ); dbus_connection_flush( p_conn ); p_intf->pf_run = Run; p_intf->p_sys = p_sys; p_sys->p_conn = p_conn; p_sys->p_events = vlc_array_new(); vlc_mutex_init( &p_sys->lock ); p_playlist = pl_Get( p_intf ); p_sys->p_playlist = p_playlist; var_AddCallback( p_playlist, "item-current", AllCallback, p_intf ); var_AddCallback( p_playlist, "intf-change", AllCallback, p_intf ); var_AddCallback( p_playlist, "playlist-item-append", AllCallback, p_intf ); var_AddCallback( p_playlist, "playlist-item-deleted", AllCallback, p_intf ); var_AddCallback( p_playlist, "random", AllCallback, p_intf ); var_AddCallback( p_playlist, "repeat", AllCallback, p_intf ); var_AddCallback( p_playlist, "loop", AllCallback, p_intf ); UpdateCaps( p_intf ); return VLC_SUCCESS; }
int main() { DBusConnection* connection; DBusError error; DBusMessage* msg; dbus_int32_t arg_int32 = 1010; DBusObjectPathVTable vtable = { NULL,NULL,NULL }; char* str = "DBus Testing. hjgfyh34348#$!%^45678901730952698376092869876DBus Testing. hjgfyh34348#$!%^~!@#$%^&*()_+`-=<>?:{},./;'[]45678901730952698376092869876"; FILE* fp[MAX_SIGNALS]={NULL}; char buf[20] = ""; int cnt=0; char exe_param[100]; char names[][40]={"test.Signal.Send3 ", "test.Signal.Send4 ", "test.Signal.Send5 "}; char obj_path[][40]={"/Test/Signal/Object3", "/Test/Signal/Object4", "/Test/Signal/Object5"}; int fd; const char* fifopath = "C:\\signalfifo.file"; int err; err = mkfifo(fifopath, 0666); if (err != 0) { // probably file already exists, delete the file unlink(fifopath); // try once more.. err = mkfifo(fifopath, 0666); if (err != 0) { create_xml(1); return 1; } } for(cnt=0;cnt< MAX_SIGNALS;cnt++) { #if defined(__WINSCW__) || defined(__WINS__) strcpy(exe_param,"Z:\\sys\\bin\\Simple_Server.exe "); #else strcpy(exe_param,"C:\\sys\\bin\\Simple_Server.exe "); #endif strcat(exe_param, names[cnt]); strcat(exe_param, obj_path[cnt]); fp[cnt] = popen(exe_param, "r"); if(!fp[cnt]) { std_log(LOG_FILENAME_LINE, "fp %d is NULL", cnt); create_xml(1); return 1; } //wait till the server is up fd = open(fifopath, O_RDONLY); if (fd> 0) { err = read(fd, buf, 20); close(fd); } else { std_log(LOG_FILENAME_LINE, "Error in FIFO open()."); create_xml(1); return 1; } if (strcmp("done", buf)) { std_log(LOG_FILENAME_LINE,"done is not returned from server."); create_xml(1); return 1; } } unlink(fifopath); dbus_error_init(&error); connection = dbus_bus_get(DBUS_BUS_SESSION, &error); if(!connection || dbus_error_is_set(&error)) return handle_error(&error); msg = dbus_message_new_signal("/Test/Signal/Object", "Test.Signal.Send", "first"); if(!msg) { std_log(LOG_FILENAME_LINE,"msg is NULL"); create_xml(1); return 1; } if(!dbus_message_append_args(msg, DBUS_TYPE_STRING, &str, DBUS_TYPE_INVALID)) { std_log(LOG_FILENAME_LINE, "Fail to append args"); create_xml(1); return 1; } dbus_bus_add_match(connection, "type='signal',interface='Test.Signal.Send1'",&error); if(dbus_error_is_set(&error)) return handle_error(&error); std_log(LOG_FILENAME_LINE, "Registering path"); if(!dbus_connection_register_object_path (connection, "/Test/Signal/Object1", &vtable, NULL)) { std_log(LOG_FILENAME_LINE, "Registering path fail"); create_xml(1); return 1; } std_log(LOG_FILENAME_LINE, "Requesting name"); if(!dbus_bus_request_name (connection, "test.Signal.Send1", DBUS_NAME_FLAG_ALLOW_REPLACEMENT, &error) == -1) { std_log(LOG_FILENAME_LINE, "Requesting name fail"); create_xml(1); return 1; } dbus_connection_send(connection, msg, NULL); dbus_connection_flush(connection); dbus_message_unref(msg); str = ""; std_log(LOG_FILENAME_LINE, "First part over"); cnt=0; while(TRUE) { dbus_connection_read_write(connection, 0); msg = dbus_connection_pop_message(connection); if(msg == NULL) { continue; } std_log(LOG_FILENAME_LINE, "Message Detected"); if(dbus_message_is_signal(msg, "Test.Signal.Send1", "second")) { if(!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &str, DBUS_TYPE_INVALID)) { std_log(LOG_FILENAME_LINE, "Error while retriving arguments :: %s", error.name); dbus_error_free(&error); create_xml(1); return 1; } std_log(LOG_FILENAME_LINE, "Got %d MSG : %s", cnt, str); cnt++; if(cnt==MAX_SIGNALS) break; } dbus_message_unref(msg); } dbus_connection_unref(connection); for(cnt=0;cnt<MAX_SIGNALS;cnt++) if(fp[cnt]) pclose(fp[cnt]); std_log(LOG_FILENAME_LINE, "Test Successful"); create_xml(0); return 0; }