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;
}
