bool FCodeLiteSourceCodeAccessor::OpenSourceFiles(const TArray<FString>& AbsoluteSourcePaths)
{
FString CodeLitePath;
if(!CanRunCodeLite(CodeLitePath))
{
UE_LOG(LogCodeLiteAccessor, Warning, TEXT("FCodeLiteSourceCodeAccessor::OpenSourceFiles: Cannot find CodeLite binary"));
return false;
}
#ifdef USE_DBUS
for(const auto& SourcePath : AbsoluteSourcePaths)
{
DBusMessage* message = nullptr;
DBusMessageIter args;
// Create new message.
message = dbus_message_new_signal ("/org/codelite/command", "org.codelite.command", "OpenFile");
char* fileName = TCHAR_TO_ANSI(*SourcePath);
// Add parameters to the message.
dbus_message_iter_init_append(message, &args);
if(!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &fileName)) {
UE_LOG(LogCodeLiteAccessor, Warning, TEXT("Sdbus_message_iter_append_basic failed."));
return false;
}
// Send the message.
dbus_connection_send(DBusConnection, message, nullptr);
if(dbus_error_is_set(&DBusError))
{
UE_LOG(LogCodeLiteAccessor, Warning, TEXT("dbus_connection_send failed: %s"), DBusError.message);
return false;
}
// Free the message resources.
dbus_message_unref(message);
}
dbus_connection_flush(DBusConnection);
return true;
#else
for(const auto& SourcePath : AbsoluteSourcePaths)
{
const FString Path = FString::Printf(TEXT("\"%s\""), *SourcePath);
FProcHandle Proc = FPlatformProcess::CreateProc(*CodeLitePath, *Path, true, false, false, nullptr, 0, nullptr, nullptr);
if(Proc.IsValid())
{
UE_LOG(LogCodeLiteAccessor, Warning, TEXT("CodeLiteSourceCodeAccessor::OpenSourceFiles: %s"), *Path);
FPlatformProcess::CloseProc(Proc);
return true;
}
}
#endif
return false;
}
static dbus_bool_t
GalagoNotification_notifyAppendArgs(
JNIEnv *env, DBusMessage *message, jstring appName, jlong replacesId,
jobject icon, jstring summary, jstring body, jint expireTimeout)
{
DBusMessageIter iter;
dbus_uint32_t _replacesId;
DBusMessageIter subIter;
dbus_int32_t _expireTimeout;
dbus_message_iter_init_append(message, &iter);
if (!GalagoNotification_messageAppendString(env, &iter, appName))
return FALSE;
_replacesId = replacesId;
if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &_replacesId))
return FALSE;
if (!GalagoNotification_messageAppendString(env, &iter, NULL))
return FALSE;
if (!GalagoNotification_messageAppendString(env, &iter, summary))
return FALSE;
if (!GalagoNotification_messageAppendString(env, &iter, body))
return FALSE;
if (!dbus_message_iter_open_container(
&iter,
DBUS_TYPE_ARRAY,
DBUS_TYPE_STRING_AS_STRING,
&subIter))
return FALSE;
if (!dbus_message_iter_close_container(&iter, &subIter))
return FALSE;
if (!dbus_message_iter_open_container(
&iter,
DBUS_TYPE_ARRAY,
"{sv}",
&subIter))
return FALSE;
if (icon)
{
Image _icon;
_icon.jdata = NULL;
_icon.data = NULL;
if (GalagoNotification_jobject2Image(env, icon, &_icon))
{
dbus_bool_t success;
success
= GalagoNotification_messageAppendIconHint(&subIter, &_icon);
if (_icon.jdata && _icon.data)
(*env)
->ReleaseIntArrayElements(
env,
_icon.jdata,
_icon.data,
JNI_ABORT);
if (!success)
return FALSE;
}
}
if (!dbus_message_iter_close_container(&iter, &subIter))
return FALSE;
_expireTimeout = expireTimeout;
if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &_expireTimeout))
return FALSE;
return TRUE;
}
DBusMessage * wbmd_dbus_interface_show_wbridge_mint_info(DBusConnection *conn, DBusMessage *msg, void *user_data){
DBusMessage* reply;
DBusMessageIter iter;
DBusMessageIter iter_array;
DBusMessageIter iter_sub_array;
DBusMessageIter iter_sub_struct;
unsigned int num=0;
DBusError err;
int ret = WBMD_DBUS_SUCCESS;
dbus_error_init(&err);
int i=0;
int j = 0;
int WBID;
char *name = NULL;
struct wbridge_info *wb[WBRIDGE_NUM];
dbus_error_init(&err);
if (!(dbus_message_get_args ( msg, &err,
DBUS_TYPE_UINT32,&WBID,
DBUS_TYPE_INVALID))){
printf("Unable to get input args\n");
if (dbus_error_is_set(&err)) {
printf("%s raised: %s",err.name,err.message);
dbus_error_free(&err);
}
return NULL;
}
if(WBID == 0){
while(i<WBRIDGE_NUM){
if(wBridge[i] != NULL)
{
wb[num] = wBridge[i];
num++;
}
i++;
}
}else{
if(wBridge[WBID] != NULL){
wb[num] = wBridge[WBID];
num++;
}
}
if(num == 0)
ret = WBMD_DBUS_ID_NO_EXIST;
reply = dbus_message_new_method_return(msg);
dbus_message_iter_init_append (reply, &iter);
dbus_message_iter_append_basic (&iter,
DBUS_TYPE_UINT32,
&ret);
if(ret == WBMD_DBUS_SUCCESS){
name = (char *)malloc(DEFAULT_LEN);
memset(name, 0, DEFAULT_LEN);
dbus_message_iter_append_basic (&iter,
DBUS_TYPE_UINT32,
&num);
dbus_message_iter_open_container (&iter,
DBUS_TYPE_ARRAY,
DBUS_STRUCT_BEGIN_CHAR_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_ARRAY_AS_STRING
DBUS_STRUCT_BEGIN_CHAR_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_STRUCT_END_CHAR_AS_STRING
DBUS_STRUCT_END_CHAR_AS_STRING,
&iter_array);
for(i = 0; i < num; i++){
DBusMessageIter iter_struct;
dbus_message_iter_open_container (&iter_array,
DBUS_TYPE_STRUCT,
NULL,
&iter_struct);
dbus_message_iter_append_basic
(&iter_struct,
DBUS_TYPE_UINT32,
&(wb[i]->WBID));
dbus_message_iter_append_basic
(&iter_struct,
DBUS_TYPE_UINT32,
&(wb[i]->IP));
dbus_message_iter_append_basic
(&iter_struct,
DBUS_TYPE_UINT32,
&(wb[i]->WBState));
dbus_message_iter_open_container (&iter_struct,
DBUS_TYPE_ARRAY,
DBUS_STRUCT_BEGIN_CHAR_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_STRUCT_END_CHAR_AS_STRING,
&iter_sub_array);
for(j = 0;j < 1; j++)
{
dbus_message_iter_open_container (&iter_sub_array,
DBUS_TYPE_STRUCT,
NULL,
&iter_sub_struct);
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_BYTE ,&(wb[i]->WBMintNode.netAddress[0]));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_BYTE ,&(wb[i]->WBMintNode.netAddress[1]));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_BYTE ,&(wb[i]->WBMintNode.netAddress[2]));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_BYTE ,&(wb[i]->WBMintNode.netAddress[3]));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_BYTE ,&(wb[i]->WBMintNode.netAddress[4]));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_BYTE ,&(wb[i]->WBMintNode.netAddress[5]));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.nodeType));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.nodeMode));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.linksCount));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.nodesCount));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.nodeInterfaceId));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.protocolEnabled));
memset(name, 0, DEFAULT_LEN);
strcpy(name, wb[i]->WBMintNode.nodeName);
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_STRING ,&name);
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.autoBitrateEnable));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.autoBitrateAddition));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.autoBitrateMinLevel));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.extraCost));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.fixedCost));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.nodeID));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.ampLow));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.ampHigh));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.authMode));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.authRelay));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.crypt));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.compress));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.overTheAirUpgradeEnable));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.overTheAirUpgradeSpeed));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.roaming));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.polling));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.mintBroadcastRate));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBMintNode.noiseFloor));
memset(name, 0, DEFAULT_LEN);
strcpy(name, wb[i]->WBMintNode.secretKey);
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_STRING ,&name);
dbus_message_iter_close_container (&iter_sub_array, &iter_sub_struct);
}
dbus_message_iter_close_container (&iter_struct, &iter_sub_array);
dbus_message_iter_close_container (&iter_array, &iter_struct);
}
dbus_message_iter_close_container (&iter, &iter_array);
if(name)
free(name);
}
return reply;
}
static int request_input(struct vpn_provider *provider,
request_cb_t callback, const char *dbus_sender,
void *user_data)
{
DBusMessage *message;
const char *path, *agent_sender, *agent_path;
DBusMessageIter iter;
DBusMessageIter dict;
struct request_input_reply *l2tp_reply;
int err;
void *agent;
agent = connman_agent_get_info(dbus_sender, &agent_sender,
&agent_path);
if (!provider || !agent || !agent_path || !callback)
return -ESRCH;
message = dbus_message_new_method_call(agent_sender, agent_path,
VPN_AGENT_INTERFACE,
"RequestInput");
if (!message)
return -ENOMEM;
dbus_message_iter_init_append(message, &iter);
path = vpn_provider_get_path(provider);
dbus_message_iter_append_basic(&iter,
DBUS_TYPE_OBJECT_PATH, &path);
connman_dbus_dict_open(&iter, &dict);
vpn_agent_append_user_info(&dict, provider, "L2TP.User");
vpn_agent_append_host_and_name(&dict, provider);
connman_dbus_dict_close(&iter, &dict);
l2tp_reply = g_try_new0(struct request_input_reply, 1);
if (!l2tp_reply) {
dbus_message_unref(message);
return -ENOMEM;
}
l2tp_reply->provider = provider;
l2tp_reply->callback = callback;
l2tp_reply->user_data = user_data;
err = connman_agent_queue_message(provider, message,
connman_timeout_input_request(),
request_input_reply, l2tp_reply, agent);
if (err < 0 && err != -EBUSY) {
DBG("error %d sending agent request", err);
dbus_message_unref(message);
g_free(l2tp_reply);
return err;
}
dbus_message_unref(message);
return -EINPROGRESS;
}
/**
* 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;
}
static char * /* O - Device path or NULL */
colord_find_device(
const char *device_id) /* I - Device ID string */
{
DBusMessage *message = NULL; /* D-Bus request */
DBusMessage *reply = NULL; /* D-Bus reply */
DBusMessageIter args; /* D-Bus method arguments */
DBusError error; /* D-Bus error */
const char *device_path_tmp; /* Device object path */
char *device_path = NULL; /* Device object path */
message = dbus_message_new_method_call(COLORD_DBUS_SERVICE,
COLORD_DBUS_PATH,
COLORD_DBUS_INTERFACE,
"FindDeviceById");
dbus_message_iter_init_append(message, &args);
dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &device_id);
/*
* Send the FindDeviceById request synchronously...
*/
dbus_error_init(&error);
cupsdLogMessage(CUPSD_LOG_DEBUG, "Calling FindDeviceById(%s)", device_id);
reply = dbus_connection_send_with_reply_and_block(colord_con, message,
COLORD_DBUS_TIMEOUT,
&error);
if (!reply)
{
cupsdLogMessage(CUPSD_LOG_DEBUG, "FindDeviceById failed: %s:%s",
error.name, error.message);
dbus_error_free(&error);
goto out;
}
/*
* Get reply data...
*/
dbus_message_iter_init(reply, &args);
if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_OBJECT_PATH)
{
cupsdLogMessage(CUPSD_LOG_WARN,
"FindDeviceById failed: Incorrect reply type.");
goto out;
}
dbus_message_iter_get_basic(&args, &device_path_tmp);
if (device_path_tmp)
device_path = strdup(device_path_tmp);
out:
if (message)
dbus_message_unref(message);
if (reply)
dbus_message_unref(reply);
return (device_path);
}
int sss_sudo_make_request(struct sudo_result_contents ** sudo_result_out)
{
char ** command_array,**ui;
int err_status,count;
dbus_uint32_t header,command_array_out_size;
struct sudo_result_contents * sudo_result = NULL;
DBusConnection* conn;
DBusError err;
DBusMessage* dbus_msg;
DBusMessage* dbus_reply;
DBusMessageIter msg_iter;
dbus_bool_t ret = -1;
fprintf(stdout,"Sending message\n");
if(validate_message_content() != SSS_SUDO_VALIDATION_SUCCESS) {
return SSS_SUDO_VALIDATION_ERR;
}
err_status = create_env_hash_table(msg.user_env,&msg.env_table);
if(err_status != HASH_SUCCESS) {
fprintf(stderr, "ccouldn't create table: %s\n", hash_error_string(err_status));
return SSS_SUDO_MESSAGE_ERR;
}
err_status = create_settings_hash_table(&msg.settings_table);
if(err_status != HASH_SUCCESS) {
fprintf(stderr, "ccouldn't create table: %s\n", hash_error_string(err_status));
return SSS_SUDO_MESSAGE_ERR;
}
/* initialise the errors */
dbus_error_init(&err);
/* connect to the system bus and check for errors */
conn = dbus_connection_open_private(SSS_SUDO_SERVICE_PIPE, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error (%s)\n", err.message);
dbus_error_free(&err);
return SSS_SUDO_CONNECTION_ERR;
}
if (NULL == conn) {
return SSS_SUDO_CONNECTION_ERR;
}
/* create a new method call and check for errors */
dbus_msg = dbus_message_new_method_call( NULL, /* target */
SUDO_SERVER_PATH, /* object */
SUDO_SERVER_INTERFACE, /* interface */
SUDO_METHOD_QUERY); /* method name */
if (NULL == dbus_msg) {
fprintf(stderr, "Message Null\n");
free_connection(conn,&err,msg.settings_table,(DBusMessage *)NULL,(DBusMessage *)NULL);
return SSS_SUDO_MESSAGE_ERR;
}
/* append arguments */
dbus_message_iter_init_append(dbus_msg, &msg_iter);
if(dbus_error_is_set(&err)){
fprintf(stderr, "Failed to initialize the iterator.\n");
free_connection(conn,&err,msg.settings_table,dbus_msg,(DBusMessage *)NULL);
return SSS_SUDO_MESSAGE_ERR;
}
ret = frame_sudo_message(conn,
&err,
dbus_msg,
&msg,
&msg_iter);
if( ret != SSS_SUDO_MESSAGE_OK){
sudo_log(SUDO_CONV_ERROR_MSG,"Failed to frame the message to sssd - Fatal (Access denied)\n");
free_connection(conn,&err,(hash_table_t *)NULL,dbus_msg,(DBusMessage *)NULL);
return SSS_SUDO_MESSAGE_ERR;
}
/* send message and get a handle for a reply */
dbus_reply = dbus_connection_send_with_reply_and_block (conn,dbus_msg,
SUDO_CLIENT_TIMEOUT,
&err);
fprintf(stdout,"Request Sent\n");
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection send-reply Error (%s)\n", err.message);
free_connection(conn,&err,(hash_table_t *)NULL,dbus_msg,(DBusMessage *)NULL);
return SSS_SUDO_REPLY_ERR;
}
if (NULL == dbus_reply) {
fprintf(stderr, "reply failed\n");
free_connection(conn,&err,(hash_table_t *)NULL,dbus_msg,(DBusMessage *)NULL);
return SSS_SUDO_REPLY_ERR;
}
sudo_result= (struct sudo_result_contents *)malloc(sizeof(struct sudo_result_contents));
ret = get_reply_message(conn,
&err,
dbus_msg,
dbus_reply,
sudo_result,
&msg_iter);
if(ret != SSS_SUDO_REPLY_OK){
}
/* free connection now */
free_connection(conn,&err,(hash_table_t *)NULL,dbus_msg,dbus_reply);
*sudo_result_out = sudo_result;
return SSS_SUDO_SEND_AND_RECIEVE_OK;
}
static gboolean
dbus_client_query_end_session (GsmClient *client,
GsmClientEndSessionFlag flags,
GError **error)
{
GsmDBusClient *dbus_client = (GsmDBusClient *) client;
DBusMessage *message;
DBusMessageIter iter;
gboolean ret;
ret = FALSE;
if (dbus_client->priv->bus_name == NULL) {
g_set_error (error,
GSM_CLIENT_ERROR,
GSM_CLIENT_ERROR_NOT_REGISTERED,
"Client is not registered");
return FALSE;
}
g_debug ("GsmDBusClient: sending QueryEndSession signal to %s", dbus_client->priv->bus_name);
/* unicast the signal to only the registered bus name */
message = dbus_message_new_signal (gsm_client_peek_id (client),
SM_DBUS_CLIENT_PRIVATE_INTERFACE,
"QueryEndSession");
if (message == NULL) {
g_set_error (error,
GSM_CLIENT_ERROR,
GSM_CLIENT_ERROR_NOT_REGISTERED,
"Unable to send QueryEndSession message");
goto out;
}
if (!dbus_message_set_destination (message, dbus_client->priv->bus_name)) {
g_set_error (error,
GSM_CLIENT_ERROR,
GSM_CLIENT_ERROR_NOT_REGISTERED,
"Unable to send QueryEndSession message");
goto out;
}
dbus_message_iter_init_append (message, &iter);
dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &flags);
if (!dbus_connection_send (dbus_client->priv->connection, message, NULL)) {
g_set_error (error,
GSM_CLIENT_ERROR,
GSM_CLIENT_ERROR_NOT_REGISTERED,
"Unable to send QueryEndSession message");
goto out;
}
ret = TRUE;
out:
if (message != NULL) {
dbus_message_unref (message);
}
return ret;
}
//! CSL method: call(app, model, method, (arg0, arg1, ...))
static PyObject *
c_call(PyObject *self, PyObject *args)
{
/*!
* This method can be used in CSL scripts to call Comar methods
* internally.
*
* @return Called method's reply
*/
PyObject *ret, *tuple = NULL;
char *app, *model, *method, *interface, *path;
int size, i;
if (!PyArg_ParseTuple(args, "sss|O", &app, &model, &method, &tuple))
return NULL;
if (!tuple) {
tuple = PyTuple_New(0);
}
DBusConnection *conn;
DBusError err;
DBusMessage *msg, *reply;
DBusMessageIter iter;
dbus_error_init(&err);
conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
PyErr_SetString(PyExc_Exception, "Unable to open connection for call() method.");
dbus_error_free(&err);
return NULL;
}
size = strlen(cfg_bus_interface) + 1 + strlen(model) + 1;
interface = malloc(size);
snprintf(interface, size, "%s.%s", cfg_bus_interface, model);
interface[size - 1] = '\0';
size = strlen("/package/") + strlen(app) + 1;
path = malloc(size);
snprintf(path, size, "/package/%s", app);
path[size - 1] = '\0';
msg = dbus_message_new_method_call(cfg_bus_name, path, interface, method);
free(interface);
free(path);
dbus_message_iter_init_append(msg, &iter);
if (PyTuple_Check(tuple)) {
if (PyTuple_Size(tuple) > 0) {
for (i = 0; i < PyTuple_Size(tuple); i++) {
if (dbus_py_export(&iter, PyTuple_GetItem(tuple, i)) != 0) {
return NULL;
}
}
}
}
else {
if (dbus_py_export(&iter, tuple) != 0) {
return NULL;
}
}
reply = dbus_connection_send_with_reply_and_block(conn, msg, -1, &err);
dbus_message_unref(msg);
dbus_connection_close(conn);
dbus_connection_unref(conn);
if (dbus_error_is_set(&err)) {
PyErr_Format(PyExc_Exception, "Unable to call method: %s", err.message);
dbus_error_free(&err);
return NULL;
}
switch (dbus_message_get_type(reply)) {
case DBUS_MESSAGE_TYPE_METHOD_RETURN:
ret = PyList_AsTuple(dbus_py_import(reply));
if (PyTuple_Size(ret) == 1) {
ret = PyTuple_GetItem(ret, 0);
}
dbus_message_unref(reply);
return ret;
case DBUS_MESSAGE_TYPE_ERROR:
PyErr_SetString(PyExc_Exception, dbus_message_get_error_name(reply));
dbus_message_unref(reply);
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
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);
}
VIR_MOCK_IMPL_RET_ARGS(dbus_connection_send_with_reply_and_block,
DBusMessage *,
DBusConnection *, connection,
DBusMessage *, message,
int, timeout_milliseconds,
DBusError *, error)
{
DBusMessage *reply = NULL;
const char *service = dbus_message_get_destination(message);
const char *member = dbus_message_get_member(message);
VIR_MOCK_IMPL_INIT_REAL(dbus_connection_send_with_reply_and_block);
if (STREQ(service, "org.freedesktop.machine1")) {
if (getenv("FAIL_BAD_SERVICE")) {
dbus_set_error_const(error,
"org.freedesktop.systemd.badthing",
"Something went wrong creating the machine");
} else {
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
}
} else if (STREQ(service, "org.freedesktop.login1")) {
char *supported = getenv("RESULT_SUPPORT");
DBusMessageIter iter;
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
dbus_message_iter_init_append(reply, &iter);
if (!dbus_message_iter_append_basic(&iter,
DBUS_TYPE_STRING,
&supported))
goto error;
} else if (STREQ(service, "org.freedesktop.DBus") &&
STREQ(member, "ListActivatableNames")) {
const char *svc1 = "org.foo.bar.wizz";
const char *svc2 = "org.freedesktop.machine1";
const char *svc3 = "org.freedesktop.login1";
DBusMessageIter iter;
DBusMessageIter sub;
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
"s", &sub);
if (!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc1))
goto error;
if (!getenv("FAIL_NO_SERVICE") &&
!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc2))
goto error;
if (!getenv("FAIL_NO_SERVICE") &&
!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc3))
goto error;
dbus_message_iter_close_container(&iter, &sub);
} else if (STREQ(service, "org.freedesktop.DBus") &&
STREQ(member, "ListNames")) {
const char *svc1 = "org.foo.bar.wizz";
const char *svc2 = "org.freedesktop.systemd1";
const char *svc3 = "org.freedesktop.login1";
DBusMessageIter iter;
DBusMessageIter sub;
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
"s", &sub);
if (!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc1))
goto error;
if ((!getenv("FAIL_NO_SERVICE") && !getenv("FAIL_NOT_REGISTERED")) &&
!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc2))
goto error;
if ((!getenv("FAIL_NO_SERVICE") && !getenv("FAIL_NOT_REGISTERED")) &&
!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc3))
goto error;
dbus_message_iter_close_container(&iter, &sub);
} else {
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
}
return reply;
error:
dbus_message_unref(reply);
return NULL;
}
gboolean
upstart_job_exec(svc_action_t * op, gboolean synchronous)
{
char *job = NULL;
int arg_wait = TRUE;
const char *arg_env = "pacemaker=1";
const char *action = op->action;
DBusError error;
DBusMessage *msg = NULL;
DBusMessage *reply = NULL;
DBusMessageIter iter, array_iter;
op->rc = PCMK_OCF_UNKNOWN_ERROR;
CRM_ASSERT(upstart_init());
if (safe_str_eq(op->action, "meta-data")) {
op->stdout_data = upstart_job_metadata(op->agent);
op->rc = PCMK_OCF_OK;
goto cleanup;
}
if(!upstart_job_by_name(op->agent, &job, op->timeout)) {
crm_debug("Could not obtain job named '%s' to %s", op->agent, action);
if (!g_strcmp0(action, "stop")) {
op->rc = PCMK_OCF_OK;
} else {
op->rc = PCMK_OCF_NOT_INSTALLED;
op->status = PCMK_LRM_OP_NOT_INSTALLED;
}
goto cleanup;
}
if (safe_str_eq(op->action, "monitor") || safe_str_eq(action, "status")) {
char *path = get_first_instance(job, op->timeout);
op->rc = PCMK_OCF_NOT_RUNNING;
if(path) {
DBusPendingCall *pending = NULL;
char *state = pcmk_dbus_get_property(
upstart_proxy, BUS_NAME, path, UPSTART_06_API ".Instance", "state",
op->synchronous?NULL:upstart_job_check, op,
op->synchronous?NULL:&pending, op->timeout);
free(job);
free(path);
if(op->synchronous) {
upstart_job_check("state", state, op);
free(state);
return op->rc == PCMK_OCF_OK;
} else if (pending) {
services_set_op_pending(op, pending);
return TRUE;
}
return FALSE;
}
goto cleanup;
} else if (!g_strcmp0(action, "start")) {
action = "Start";
} else if (!g_strcmp0(action, "stop")) {
action = "Stop";
} else if (!g_strcmp0(action, "restart")) {
action = "Restart";
} else {
op->rc = PCMK_OCF_UNIMPLEMENT_FEATURE;
goto cleanup;
}
crm_debug("Calling %s for %s on %s", action, op->rsc, job);
msg = dbus_message_new_method_call(BUS_NAME, // target for the method call
job, // object to call on
UPSTART_JOB_IFACE, // interface to call on
action); // method name
CRM_ASSERT(msg != NULL);
dbus_message_iter_init_append (msg, &iter);
CRM_LOG_ASSERT(dbus_message_iter_open_container (&iter,
DBUS_TYPE_ARRAY,
DBUS_TYPE_STRING_AS_STRING,
&array_iter));
CRM_LOG_ASSERT(dbus_message_iter_append_basic (&array_iter, DBUS_TYPE_STRING, &arg_env));
CRM_LOG_ASSERT(dbus_message_iter_close_container (&iter, &array_iter));
CRM_LOG_ASSERT(dbus_message_append_args(msg, DBUS_TYPE_BOOLEAN, &arg_wait, DBUS_TYPE_INVALID));
if (op->synchronous == FALSE) {
DBusPendingCall* pending = pcmk_dbus_send(msg, upstart_proxy, upstart_async_dispatch, op, op->timeout);
free(job);
if(pending) {
services_set_op_pending(op, pending);
return TRUE;
}
return FALSE;
}
dbus_error_init(&error);
reply = pcmk_dbus_send_recv(msg, upstart_proxy, &error, op->timeout);
if(error.name) {
if(!upstart_mask_error(op, error.name)) {
crm_err("Could not issue %s for %s: %s (%s)", action, op->rsc, error.name, job);
}
} else if (!g_strcmp0(op->action, "stop")) {
/* No return vaue */
op->rc = PCMK_OCF_OK;
} else if(!pcmk_dbus_type_check(reply, NULL, DBUS_TYPE_OBJECT_PATH, __FUNCTION__, __LINE__)) {
crm_warn("Call to %s passed but return type was unexpected", op->action);
op->rc = PCMK_OCF_OK;
} else {
const char *path = NULL;
dbus_message_get_args (reply, NULL,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
crm_info("Call to %s passed: %s", op->action, path);
op->rc = PCMK_OCF_OK;
}
cleanup:
free(job);
if(msg) {
dbus_message_unref(msg);
}
if(reply) {
dbus_message_unref(reply);
}
if (op->synchronous == FALSE) {
operation_finalize(op);
return TRUE;
}
return op->rc == PCMK_OCF_OK;
}
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;
}
}
/**
* Creates the HealthApplication's by calling BlueZ
*
* @param is_sink TRUE if data type is Sink role
* @param data_type Specialization or data type
*/
gboolean create_health_application(gboolean is_sink, guint16 data_type)
{
/* Create HealthApplication */
// Need to use non-GLib code here because GLib still does not have
// the G_TYPE_UINT16 type.
DBusMessage *msg, *reply;
DBusError err;
DBusMessageIter iter, array, entry, variant;
guint16 value;
const char *svalue;
const char *key;
char *app_path;
app_object *app;
msg = dbus_message_new_method_call("org.bluez", "/org/bluez",
"org.bluez.HealthManager", "CreateApplication");
if (!msg) {
DEBUG(" network:dbus Can't allocate new method call");
return FALSE;
}
dbus_message_iter_init_append(msg, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &array);
key = "DataType";
value = data_type;
dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "q", &variant);
dbus_message_iter_append_basic(&variant, DBUS_TYPE_UINT16, &value);
dbus_message_iter_close_container(&entry, &variant);
dbus_message_iter_close_container(&array, &entry);
key = "Role";
svalue = (is_sink ? "Sink" : "Source");
dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "s", &variant);
dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &svalue);
dbus_message_iter_close_container(&entry, &variant);
dbus_message_iter_close_container(&array, &entry);
key = "Description";
svalue = "healthd";
dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "s", &variant);
dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &svalue);
dbus_message_iter_close_container(&entry, &variant);
dbus_message_iter_close_container(&array, &entry);
dbus_message_iter_close_container(&iter, &array);
dbus_error_init(&err);
reply = dbus_connection_send_with_reply_and_block(
dbus_g_connection_get_connection(conn),
msg, -1, &err);
dbus_message_unref(msg);
if (!reply) {
DEBUG(" network:dbus Can't create application");
if (dbus_error_is_set(&err)) {
ERROR("%s", err.message);
dbus_error_free(&err);
}
return FALSE;
}
if (!dbus_message_get_args(reply, &err,
DBUS_TYPE_OBJECT_PATH, &app_path,
DBUS_TYPE_INVALID)) {
DEBUG(" network:dbus Can't get reply arguments");
if (dbus_error_is_set(&err)) {
ERROR("%s", err.message);
dbus_error_free(&err);
}
return FALSE;
}
app = g_new0(app_object, 1);
app->path = g_strdup(app_path);
app->data_type = data_type;
app->is_sink = is_sink;
llist_add(apps(), app);
dbus_message_unref(reply);
DEBUG("Created health application: %s", (char *) app->path);
return TRUE;
}
void
gconf_database_dbus_notify_listeners (GConfDatabase *db,
GConfSources *modified_sources,
const gchar *key,
const GConfValue *value,
gboolean is_default,
gboolean is_writable,
gboolean notify_others)
{
char *dir, *sep;
GList *l;
NotificationData *notification;
DBusMessage *message;
gboolean last;
dir = g_strdup (key);
/* Lookup the key in the namespace hierarchy, start with the full key and then
* remove the leaf, lookup again, remove the leaf, and so on until a match is
* found. Notify the clients (identified by their base service) that
* correspond to the found namespace.
*/
last = FALSE;
while (1)
{
notification = g_hash_table_lookup (db->notifications, dir);
if (notification)
{
for (l = notification->clients; l; l = l->next)
{
const char *base_service = l->data;
DBusMessageIter iter;
message = dbus_message_new_method_call (base_service,
GCONF_DBUS_CLIENT_OBJECT,
GCONF_DBUS_CLIENT_INTERFACE,
"Notify");
dbus_message_append_args (message,
DBUS_TYPE_STRING, &db->object_path,
DBUS_TYPE_STRING, &dir,
DBUS_TYPE_INVALID);
dbus_message_iter_init_append (message, &iter);
gconf_dbus_utils_append_entry_values (&iter,
key,
value,
is_default,
is_writable,
NULL);
dbus_message_set_no_reply (message, TRUE);
dbus_connection_send (gconfd_dbus_get_connection (), message, NULL);
dbus_message_unref (message);
}
}
if (last)
break;
sep = strrchr (dir, '/');
/* Special case to catch notifications on the root. */
if (sep == dir)
{
last = TRUE;
sep[1] = '\0';
}
else
*sep = '\0';
}
g_free (dir);
if (modified_sources)
{
if (notify_others)
gconfd_notify_other_listeners (db, modified_sources, key);
g_list_free (modified_sources->sources);
g_free (modified_sources);
}
}
/*****************************************************
** DISCRIPTION:
** copy file of the specific path from slotA to slotB
** INPUT:
**
** OUTPUT:
**
** RETURN:
**
** CREATOR:
** <*****@*****.**>
** DATE:
** 2011-08-11
*****************************************************/
DBusMessage * bsd_copy_files_between_boards(DBusConnection *conn, DBusMessage *msg, void *user_data){
DBusMessage* reply;
DBusMessageIter iter;
DBusError err;
int ret = BSD_DBUS_SUCCESS;
unsigned int slotid = 0;
int tar_switch = 0;
char *src_path = NULL;
char *des_path = NULL;
int op = 0;
DIR *source = NULL;
int curr_event_id = 0;
char *tmp_md5 = NULL;
int len = 0;
dbus_error_init(&err);
if (!(dbus_message_get_args ( msg, &err,
DBUS_TYPE_UINT32,&slotid,
DBUS_TYPE_STRING,&src_path,
DBUS_TYPE_STRING,&des_path,
DBUS_TYPE_UINT32,&tar_switch, //book add, 2011-08-16
DBUS_TYPE_UINT32,&op, //book add, 2011-10-26
DBUS_TYPE_INVALID))) {
bsd_syslog_err("copy files between boards:Unable to get input args ");
if (dbus_error_is_set(&err)) {
bsd_syslog_err("copy files failed %s raised: %s",err.name,err.message);
dbus_error_free(&err);
}
return NULL;
}
if((ret != 0) && (BSD_BOARD[slotid]->state != BSD_FILE_UNKNOWN)) {
BSD_BOARD[slotid]->state = BSD_FILE_UNKNOWN;
}
else {
source = opendir(src_path);
if(source == NULL) { // copy single file
if(op == BSD_TYPE_NORMAL)
op = BSD_TYPE_SINGLE;
if(g_unEventId == MAX_EVENT_ID)
g_unEventId = 0;
g_unEventId++;
curr_event_id = g_unEventId;
bsd_syslog_debug_debug(BSD_DEFAULT, "111 op = %d, slotid = %d, src_path = %s, des_path = %s\n",op,slotid,src_path,des_path);
ret = BSDHandleFileOp(slotid, src_path, des_path, op, curr_event_id);
tarFlag = 0;
} else {// copy folder
bsd_syslog_debug_debug(BSD_DEFAULT, "copy other files\n");
tarFlag = tar_switch;
ret = BSDCopyFile(slotid, src_path, des_path, op);
tarFlag = 0;
closedir(source);
}
if((ret != 0) && (BSD_BOARD[slotid]->state != BSD_FILE_UNKNOWN)) {
BSD_BOARD[slotid]->state = BSD_FILE_UNKNOWN;
}
}
/* add for AXSSZFI-1563 */
len = strnlen(g_rePrintMd5, BSD_PATH_LEN);
//bsd_syslog_debug_debug(BSD_DEFAULT, "g_rePrintMd5 len = %d", len);
if(len > 0) {
tmp_md5 = (char*)malloc(len+1);
memset(tmp_md5, 0, len+1);
memcpy(tmp_md5, g_rePrintMd5, len);
memset(g_rePrintMd5, 0, BSD_PATH_LEN);
}
else {
tmp_md5 = (char*)malloc(5);
memset(tmp_md5, 0, 5);
strcpy(tmp_md5, "none");
}
bsd_syslog_debug_debug(BSD_DEFAULT, "ret = %d\n", ret);
reply = dbus_message_new_method_return(msg);
if(NULL == reply) {
bsd_syslog_err("vrrp set hansi profile dbus reply null!\n");
return reply;
}
dbus_message_iter_init_append (reply, &iter);
dbus_message_iter_append_basic (&iter,DBUS_TYPE_UINT32,&ret);
dbus_message_iter_append_basic (&iter,DBUS_TYPE_STRING,&tmp_md5);
if(tmp_md5 != NULL) {
free(tmp_md5);
tmp_md5 = NULL;
}
return reply;
}
static void
colord_create_profile(
cups_array_t *profiles, /* I - Profiles array */
const char *printer_name, /* I - Printer name */
const char *qualifier, /* I - Profile qualifier */
const char *colorspace, /* I - Profile colorspace */
char **format, /* I - Profile qualifier format */
const char *iccfile, /* I - ICC filename */
const char *scope) /* I - The scope of the profile, e.g.
'normal', 'temp' or 'disk' */
{
DBusMessage *message = NULL; /* D-Bus request */
DBusMessage *reply = NULL; /* D-Bus reply */
DBusMessageIter args; /* D-Bus method arguments */
DBusMessageIter dict; /* D-Bus method arguments */
DBusError error; /* D-Bus error */
char *idstr; /* Profile ID string */
size_t idstrlen; /* Profile ID allocated length */
const char *profile_path; /* Device object path */
char format_str[1024]; /* Qualifier format as a string */
/*
* Create the profile...
*/
message = dbus_message_new_method_call(COLORD_DBUS_SERVICE,
COLORD_DBUS_PATH,
COLORD_DBUS_INTERFACE,
"CreateProfile");
idstrlen = strlen(printer_name) + 1 + strlen(qualifier) + 1;
if ((idstr = malloc(idstrlen)) == NULL)
goto out;
snprintf(idstr, idstrlen, "%s-%s", printer_name, qualifier);
cupsdLogMessage(CUPSD_LOG_DEBUG, "Using profile ID \"%s\".", idstr);
dbus_message_iter_init_append(message, &args);
dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &idstr);
dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &scope);
snprintf(format_str, sizeof(format_str), "%s.%s.%s", format[0], format[1],
format[2]);
dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "{ss}", &dict);
colord_dict_add_strings(&dict, "Qualifier", qualifier);
colord_dict_add_strings(&dict, "Format", format_str);
colord_dict_add_strings(&dict, "Colorspace", colorspace);
if (iccfile)
colord_dict_add_strings(&dict, "Filename", iccfile);
dbus_message_iter_close_container(&args, &dict);
/*
* Send the CreateProfile request synchronously...
*/
dbus_error_init(&error);
cupsdLogMessage(CUPSD_LOG_DEBUG, "Calling CreateProfile(%s,%s)", idstr,
scope);
reply = dbus_connection_send_with_reply_and_block(colord_con, message,
COLORD_DBUS_TIMEOUT,
&error);
if (!reply)
{
cupsdLogMessage(CUPSD_LOG_WARN, "CreateProfile failed: %s:%s", error.name,
error.message);
dbus_error_free(&error);
goto out;
}
/*
* Get reply data...
*/
dbus_message_iter_init(reply, &args);
if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_OBJECT_PATH)
{
cupsdLogMessage(CUPSD_LOG_WARN,
"CreateProfile failed: Incorrect reply type.");
goto out;
}
dbus_message_iter_get_basic(&args, &profile_path);
cupsdLogMessage(CUPSD_LOG_DEBUG, "Created profile \"%s\".", profile_path);
cupsArrayAdd(profiles, strdup(profile_path));
out:
if (message)
dbus_message_unref(message);
if (reply)
dbus_message_unref(reply);
if (idstr)
free(idstr);
}
int
my_method_sync (const void * parent,
NihDBusProxy * proxy,
const int32_t *value,
size_t value_len)
{
DBusMessage * method_call;
DBusMessageIter iter;
DBusError error;
DBusMessage * reply;
DBusMessageIter value_iter;
nih_assert (proxy != NULL);
nih_assert ((value_len == 0) || (value != NULL));
/* Construct the method call message. */
method_call = dbus_message_new_method_call (proxy->name, proxy->path, "com.netsplit.Nih.Test", "Method");
if (! method_call)
nih_return_no_memory_error (-1);
dbus_message_set_auto_start (method_call, proxy->auto_start);
dbus_message_iter_init_append (method_call, &iter);
/* Marshal an array onto the message */
if (! dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "i", &value_iter)) {
dbus_message_unref (method_call);
nih_return_no_memory_error (-1);
}
for (size_t value_i = 0; value_i < value_len; value_i++) {
int32_t value_element;
value_element = value[value_i];
/* Marshal a int32_t onto the message */
if (! dbus_message_iter_append_basic (&value_iter, DBUS_TYPE_INT32, &value_element)) {
dbus_message_iter_abandon_container (&iter, &value_iter);
dbus_message_unref (method_call);
nih_return_no_memory_error (-1);
}
}
if (! dbus_message_iter_close_container (&iter, &value_iter)) {
dbus_message_unref (method_call);
nih_return_no_memory_error (-1);
}
/* Send the message, and wait for the reply. */
dbus_error_init (&error);
reply = dbus_connection_send_with_reply_and_block (proxy->connection, method_call, -1, &error);
if (! reply) {
dbus_message_unref (method_call);
if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) {
nih_error_raise_no_memory ();
} else {
nih_dbus_error_raise (error.name, error.message);
}
dbus_error_free (&error);
return -1;
}
dbus_message_unref (method_call);
/* Iterate the arguments of the reply */
dbus_message_iter_init (reply, &iter);
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID) {
dbus_message_unref (reply);
nih_return_error (-1, NIH_DBUS_INVALID_ARGS,
_(NIH_DBUS_INVALID_ARGS_STR));
}
dbus_message_unref (reply);
return 0;
}
static void
colord_create_device(
cupsd_printer_t *p, /* I - Printer */
ppd_file_t *ppd, /* I - PPD file */
cups_array_t *profiles, /* I - Profiles array */
const char *colorspace, /* I - Device colorspace, e.g. 'rgb' */
char **format, /* I - Device qualifier format */
const char *relation, /* I - Profile relation, either 'soft'
or 'hard' */
const char *scope) /* I - The scope of the device, e.g.
'normal', 'temp' or 'disk' */
{
DBusMessage *message = NULL; /* D-Bus request */
DBusMessage *reply = NULL; /* D-Bus reply */
DBusMessageIter args; /* D-Bus method arguments */
DBusMessageIter dict; /* D-Bus method arguments */
DBusError error; /* D-Bus error */
const char *device_path; /* Device object path */
const char *profile_path; /* Profile path */
char *default_profile_path = NULL;
/* Default profile path */
char device_id[1024]; /* Device ID as understood by colord */
char format_str[1024]; /* Qualifier format as a string */
/*
* Create the device...
*/
snprintf(device_id, sizeof(device_id), "cups-%s", p->name);
device_path = device_id;
message = dbus_message_new_method_call(COLORD_DBUS_SERVICE,
COLORD_DBUS_PATH,
COLORD_DBUS_INTERFACE,
"CreateDevice");
dbus_message_iter_init_append(message, &args);
dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &device_path);
dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &scope);
snprintf(format_str, sizeof(format_str), "%s.%s.%s", format[0], format[1],
format[2]);
dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "{ss}", &dict);
colord_dict_add_strings(&dict, "Colorspace", colorspace);
colord_dict_add_strings(&dict, "Mode", COLORD_MODE_PHYSICAL);
if (ppd->manufacturer)
colord_dict_add_strings(&dict, "Vendor", ppd->manufacturer);
if (ppd->modelname)
colord_dict_add_strings(&dict, "Model", ppd->modelname);
if (p->sanitized_device_uri)
colord_dict_add_strings(&dict, "Serial", p->sanitized_device_uri);
colord_dict_add_strings(&dict, "Format", format_str);
colord_dict_add_strings(&dict, "Kind", COLORD_KIND_PRINTER);
dbus_message_iter_close_container(&args, &dict);
/*
* Send the CreateDevice request synchronously...
*/
dbus_error_init(&error);
cupsdLogMessage(CUPSD_LOG_DEBUG, "Calling CreateDevice(%s,%s)", device_id,
scope);
reply = dbus_connection_send_with_reply_and_block(colord_con, message,
COLORD_DBUS_TIMEOUT,
&error);
if (!reply)
{
cupsdLogMessage(CUPSD_LOG_WARN, "CreateDevice failed: %s:%s", error.name,
error.message);
dbus_error_free(&error);
goto out;
}
/*
* Get reply data...
*/
dbus_message_iter_init(reply, &args);
if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_OBJECT_PATH)
{
cupsdLogMessage(CUPSD_LOG_WARN,
"CreateDevice failed: Incorrect reply type.");
goto out;
}
dbus_message_iter_get_basic(&args, &device_path);
cupsdLogMessage(CUPSD_LOG_DEBUG, "Created device \"%s\".", device_path);
/*
* Add profiles...
*/
for (profile_path = cupsArrayFirst(profiles);
profile_path;
profile_path = cupsArrayNext(profiles))
{
colord_device_add_profile(device_path, profile_path, relation);
}
out:
if (default_profile_path)
free(default_profile_path);
if (message)
dbus_message_unref(message);
if (reply)
dbus_message_unref(reply);
}
static dbus_bool_t
bus_driver_handle_list_services (DBusConnection *connection,
BusTransaction *transaction,
DBusMessage *message,
DBusError *error)
{
DBusMessage *reply;
int len;
char **services;
BusRegistry *registry;
int i;
DBusMessageIter iter;
DBusMessageIter sub;
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
registry = bus_connection_get_registry (connection);
reply = dbus_message_new_method_return (message);
if (reply == NULL)
{
BUS_SET_OOM (error);
return FALSE;
}
if (!bus_registry_list_services (registry, &services, &len))
{
dbus_message_unref (reply);
BUS_SET_OOM (error);
return FALSE;
}
dbus_message_iter_init_append (reply, &iter);
if (!dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
DBUS_TYPE_STRING_AS_STRING,
&sub))
{
dbus_free_string_array (services);
dbus_message_unref (reply);
BUS_SET_OOM (error);
return FALSE;
}
{
/* Include the bus driver in the list */
const char *v_STRING = DBUS_SERVICE_DBUS;
if (!dbus_message_iter_append_basic (&sub, DBUS_TYPE_STRING,
&v_STRING))
{
dbus_free_string_array (services);
dbus_message_unref (reply);
BUS_SET_OOM (error);
return FALSE;
}
}
i = 0;
while (i < len)
{
if (!dbus_message_iter_append_basic (&sub, DBUS_TYPE_STRING,
&services[i]))
{
dbus_free_string_array (services);
dbus_message_unref (reply);
BUS_SET_OOM (error);
return FALSE;
}
++i;
}
if (!dbus_message_iter_close_container (&iter, &sub))
{
dbus_free_string_array (services);
dbus_message_unref (reply);
BUS_SET_OOM (error);
return FALSE;
}
dbus_free_string_array (services);
if (!bus_transaction_send_from_driver (transaction, connection, reply))
{
dbus_message_unref (reply);
BUS_SET_OOM (error);
return FALSE;
}
else
{
dbus_message_unref (reply);
return TRUE;
}
}
void
gsm_consolekit_set_session_idle (GsmConsolekit *manager,
gboolean is_idle)
{
gboolean res;
GError *error;
char *session_id;
DBusMessage *message;
DBusMessage *reply;
DBusError dbus_error;
DBusMessageIter iter;
error = NULL;
if (!gsm_consolekit_ensure_ck_connection (manager, &error)) {
g_warning ("Could not connect to ConsoleKit: %s",
error->message);
g_error_free (error);
return;
}
session_id = NULL;
res = get_current_session_id (dbus_g_connection_get_connection (manager->priv->dbus_connection),
&session_id);
if (!res) {
goto out;
}
g_debug ("Updating ConsoleKit idle status: %d", is_idle);
message = dbus_message_new_method_call (CK_NAME,
session_id,
CK_SESSION_INTERFACE,
"SetIdleHint");
if (message == NULL) {
g_debug ("Couldn't allocate the D-Bus message");
return;
}
dbus_message_iter_init_append (message, &iter);
dbus_message_iter_append_basic (&iter, DBUS_TYPE_BOOLEAN, &is_idle);
/* FIXME: use async? */
dbus_error_init (&dbus_error);
reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (manager->priv->dbus_connection),
message,
-1,
&dbus_error);
dbus_message_unref (message);
if (reply != NULL) {
dbus_message_unref (reply);
}
if (dbus_error_is_set (&dbus_error)) {
g_debug ("%s raised:\n %s\n\n", dbus_error.name, dbus_error.message);
dbus_error_free (&dbus_error);
}
out:
g_free (session_id);
}
static dbus_bool_t
bus_driver_handle_list_queued_owners (DBusConnection *connection,
BusTransaction *transaction,
DBusMessage *message,
DBusError *error)
{
const char *text;
DBusList *base_names;
DBusList *link;
DBusString str;
BusRegistry *registry;
BusService *service;
DBusMessage *reply;
DBusMessageIter iter, array_iter;
char *dbus_service_name = DBUS_SERVICE_DBUS;
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
registry = bus_connection_get_registry (connection);
base_names = NULL;
text = NULL;
reply = NULL;
if (! dbus_message_get_args (message, error,
DBUS_TYPE_STRING, &text,
DBUS_TYPE_INVALID))
goto failed;
_dbus_string_init_const (&str, text);
service = bus_registry_lookup (registry, &str);
if (service == NULL &&
_dbus_string_equal_c_str (&str, DBUS_SERVICE_DBUS))
{
/* ORG_FREEDESKTOP_DBUS owns itself */
if (! _dbus_list_append (&base_names, dbus_service_name))
goto oom;
}
else if (service == NULL)
{
dbus_set_error (error,
DBUS_ERROR_NAME_HAS_NO_OWNER,
"Could not get owners of name '%s': no such name", text);
goto failed;
}
else
{
if (!bus_service_list_queued_owners (service,
&base_names,
error))
goto failed;
}
_dbus_assert (base_names != NULL);
reply = dbus_message_new_method_return (message);
if (reply == NULL)
goto oom;
dbus_message_iter_init_append (reply, &iter);
if (!dbus_message_iter_open_container (&iter,
DBUS_TYPE_ARRAY,
DBUS_TYPE_STRING_AS_STRING,
&array_iter))
goto oom;
link = _dbus_list_get_first_link (&base_names);
while (link != NULL)
{
char *uname;
_dbus_assert (link->data != NULL);
uname = (char *)link->data;
if (!dbus_message_iter_append_basic (&array_iter,
DBUS_TYPE_STRING,
&uname))
goto oom;
link = _dbus_list_get_next_link (&base_names, link);
}
if (! dbus_message_iter_close_container (&iter, &array_iter))
goto oom;
if (! bus_transaction_send_from_driver (transaction, connection, reply))
goto oom;
dbus_message_unref (reply);
return TRUE;
oom:
BUS_SET_OOM (error);
failed:
_DBUS_ASSERT_ERROR_IS_SET (error);
if (reply)
dbus_message_unref (reply);
if (base_names)
_dbus_list_clear (&base_names);
return FALSE;
}
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;
}
static void process_properties_from_interface(struct generic_data *data,
struct interface_data *iface)
{
GSList *l;
DBusMessage *signal;
DBusMessageIter iter, dict, array;
GSList *invalidated;
if (iface->pending_prop == NULL)
return;
signal = dbus_message_new_signal(data->path,
DBUS_INTERFACE_PROPERTIES, "PropertiesChanged");
if (signal == NULL) {
error("Unable to allocate new " DBUS_INTERFACE_PROPERTIES
".PropertiesChanged signal");
return;
}
iface->pending_prop = g_slist_reverse(iface->pending_prop);
dbus_message_iter_init_append(signal, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &iface->name);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
invalidated = NULL;
for (l = iface->pending_prop; l != NULL; l = l->next) {
GDBusPropertyTable *p = l->data;
if (p->get == NULL)
continue;
if (p->exists != NULL && !p->exists(p, iface->user_data)) {
invalidated = g_slist_prepend(invalidated, p);
continue;
}
append_property(iface, p, &dict);
}
dbus_message_iter_close_container(&iter, &dict);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
DBUS_TYPE_STRING_AS_STRING, &array);
for (l = invalidated; l != NULL; l = g_slist_next(l)) {
GDBusPropertyTable *p = l->data;
dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING,
&p->name);
}
g_slist_free(invalidated);
dbus_message_iter_close_container(&iter, &array);
g_dbus_send_message(data->conn, signal);
g_slist_free(iface->pending_prop);
iface->pending_prop = NULL;
}
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;
}
// Synchronous, should probably be fixed
uint8_t SetHUDDisplayMsgReq(
uint32_t manueverIcon,
uint16_t manueverDistance,
uint8_t manueverDistanceUnit,
uint16_t speedLimit,
uint8_t speedLimitUnit)
{
DBusMessage *msg = dbus_message_new_method_call("com.jci.vbs.navi", "/com/jci/vbs/navi",
"com.jci.vbs.navi","SetHUDDisplayMsgReq");
DBusPendingCall *pending = nullptr;
if (!msg) {
assert(false && "failed to create message");
}
DBusMessageIter iter;
dbus_message_iter_init_append(msg, &iter);
DBusMessageIter sub;
if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_STRUCT, nullptr, &sub)) {
assert(false && "failed to initialize sub-iterator");
}
{
dbus_bool_t result = TRUE;
result &= dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &manueverIcon);
result &= dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT16, &manueverDistance);
result &= dbus_message_iter_append_basic(&sub, DBUS_TYPE_BYTE, &manueverDistanceUnit);
result &= dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT16, &speedLimit);
result &= dbus_message_iter_append_basic(&sub, DBUS_TYPE_BYTE, &speedLimitUnit);
if (!result) {
assert(false && "failed to append arguments to struct");
}
}
if (!dbus_message_iter_close_container(&iter, &sub)) {
assert(false && "failed to close container");
}
if (!dbus_connection_send_with_reply(service_bus, msg, &pending, -1)) {
assert(false && "failed to send message");
}
dbus_connection_flush(service_bus);
dbus_message_unref(msg);
dbus_pending_call_block(pending);
msg = dbus_pending_call_steal_reply(pending);
if (!msg) {
assert(false && "received null reply");
}
uint8_t result;
if (!dbus_message_get_args(msg, nullptr, DBUS_TYPE_BYTE, &result,
DBUS_TYPE_INVALID)) {
assert(false && "failed to get result");
}
dbus_message_unref(msg);
return result;
}
DBusMessage * wbmd_dbus_interface_show_wbridge_basic_info(DBusConnection *conn, DBusMessage *msg, void *user_data){
DBusMessage* reply;
DBusMessageIter iter;
DBusMessageIter iter_array;
DBusMessageIter iter_sub_array;
DBusMessageIter iter_sub_struct;
unsigned int num=0;
DBusError err;
int ret = WBMD_DBUS_SUCCESS;
dbus_error_init(&err);
int i=0;
int j = 0;
int WBID;
char *name = NULL;
struct wbridge_info *wb[WBRIDGE_NUM];
dbus_error_init(&err);
if (!(dbus_message_get_args ( msg, &err,
DBUS_TYPE_UINT32,&WBID,
DBUS_TYPE_INVALID))){
printf("Unable to get input args\n");
if (dbus_error_is_set(&err)) {
printf("%s raised: %s",err.name,err.message);
dbus_error_free(&err);
}
return NULL;
}
if(WBID == 0){
while(i<WBRIDGE_NUM){
if(wBridge[i] != NULL)
{
wb[num] = wBridge[i];
num++;
}
i++;
}
}else{
if(wBridge[WBID] != NULL){
wb[num] = wBridge[WBID];
num++;
}
}
if(num == 0)
ret = WBMD_DBUS_ID_NO_EXIST;
reply = dbus_message_new_method_return(msg);
dbus_message_iter_init_append (reply, &iter);
dbus_message_iter_append_basic (&iter,
DBUS_TYPE_UINT32,
&ret);
if(ret == WBMD_DBUS_SUCCESS){
name = (char *)malloc(16);
memset(name, 0, 16);
dbus_message_iter_append_basic (&iter,
DBUS_TYPE_UINT32,
&num);
dbus_message_iter_open_container (&iter,
DBUS_TYPE_ARRAY,
DBUS_STRUCT_BEGIN_CHAR_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_ARRAY_AS_STRING
DBUS_STRUCT_BEGIN_CHAR_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_STRUCT_END_CHAR_AS_STRING
DBUS_STRUCT_END_CHAR_AS_STRING,
&iter_array);
for(i = 0; i < num; i++){
DBusMessageIter iter_struct;
dbus_message_iter_open_container (&iter_array,
DBUS_TYPE_STRUCT,
NULL,
&iter_struct);
dbus_message_iter_append_basic
(&iter_struct,
DBUS_TYPE_UINT32,
&(wb[i]->WBID));
dbus_message_iter_append_basic
(&iter_struct,
DBUS_TYPE_UINT32,
&(wb[i]->IP));
dbus_message_iter_append_basic
(&iter_struct,
DBUS_TYPE_UINT32,
&(wb[i]->WBState));
dbus_message_iter_append_basic
(&iter_struct,
DBUS_TYPE_UINT32,
&(wb[i]->if_num));
dbus_message_iter_open_container (&iter_struct,
DBUS_TYPE_ARRAY,
DBUS_STRUCT_BEGIN_CHAR_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_STRUCT_END_CHAR_AS_STRING,
&iter_sub_array);
for(j = 0;j < wb[i]->if_num; j++)
{
dbus_message_iter_open_container (&iter_sub_array,
DBUS_TYPE_STRUCT,
NULL,
&iter_sub_struct);
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifIndex));
memset(name, 0, 16);
strcpy(name, wb[i]->WBIF[j].ifDescr);
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_STRING ,&name);
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifType));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifMtu));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifSpeed));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_BYTE ,&(wb[i]->WBIF[j].ifPhysAddress[0]));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_BYTE ,&(wb[i]->WBIF[j].ifPhysAddress[1]));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_BYTE ,&(wb[i]->WBIF[j].ifPhysAddress[2]));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_BYTE ,&(wb[i]->WBIF[j].ifPhysAddress[3]));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_BYTE ,&(wb[i]->WBIF[j].ifPhysAddress[4]));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_BYTE ,&(wb[i]->WBIF[j].ifPhysAddress[5]));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifAdminStatus));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifOperStatus));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifLastChange));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifInOctets));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifInUcastPkts));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifInNUcastPkts));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifInDiscards));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifInErrors));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifInUnknownProtos));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifOutOctets));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifOutUcastPkts));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifOutNUcastPkts));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifOutDiscards));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifOutErrors));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifOutQLen));
dbus_message_iter_append_basic (&iter_sub_struct,DBUS_TYPE_UINT32 ,&(wb[i]->WBIF[j].ifSpecific));
dbus_message_iter_close_container (&iter_sub_array, &iter_sub_struct);
}
dbus_message_iter_close_container (&iter_struct, &iter_sub_array);
dbus_message_iter_close_container (&iter_array, &iter_struct);
}
dbus_message_iter_close_container (&iter, &iter_array);
if(name)
free(name);
}
return reply;
}
void FcitxXkbDBusGetLayouts(FcitxXkbDBus* xkbdbus, DBusMessage* message)
{
DBusMessageIter iter, sub;
dbus_message_iter_init_append(message, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(ssss)", &sub);
FcitxXkbRules* rules = xkbdbus->rules;
FcitxIsoCodes* isocodes = xkbdbus->isocodes;
char* lang = NULL;
#define GET_LANG \
do { \
char** plang = NULL; \
plang = (char**) utarray_front(layoutInfo->languages); \
lang = NULL; \
if (plang) { \
FcitxIsoCodes639Entry* entry = FcitxIsoCodesGetEntry(isocodes, *plang); \
if (entry) { \
lang = entry->iso_639_1_code; \
} \
} \
} while (0)
if (rules) {
FcitxXkbLayoutInfo* layoutInfo;
for (layoutInfo = (FcitxXkbLayoutInfo*) utarray_front(rules->layoutInfos);
layoutInfo != NULL;
layoutInfo = (FcitxXkbLayoutInfo*) utarray_next(rules->layoutInfos, layoutInfo))
{
char* description;
asprintf(&description, "%s",
dgettext("xkeyboard-config", layoutInfo->description));
GET_LANG;
FcitxXkbDBusAppendLayout(&sub, layoutInfo->name, "", description, lang);
free(description);
FcitxXkbVariantInfo* variantInfo;
for (variantInfo = (FcitxXkbVariantInfo*) utarray_front(layoutInfo->variantInfos);
variantInfo != NULL;
variantInfo = (FcitxXkbVariantInfo*) utarray_next(layoutInfo->variantInfos, variantInfo))
{
char* description;
asprintf(&description, "%s - %s",
dgettext("xkeyboard-config", layoutInfo->description),
dgettext("xkeyboard-config", variantInfo->description));
GET_LANG;
FcitxXkbDBusAppendLayout(&sub, layoutInfo->name, variantInfo->name, description, lang);
free(description);
}
}
}
else {
char* description;
asprintf(&description, "%s",
dgettext("xkeyboard-config", "English (US)"));
FcitxXkbDBusAppendLayout(&sub, "us", "", description, "en");
free(description);
}
dbus_message_iter_close_container(&iter, &sub);
}
DBusMessage * wbmd_dbus_interface_show_wbridge_list(DBusConnection *conn, DBusMessage *msg, void *user_data){
DBusMessage* reply;
DBusMessageIter iter;
DBusMessageIter iter_array;
unsigned int num=0;
DBusError err;
int ret = WBMD_DBUS_SUCCESS;
dbus_error_init(&err);
int i=0;
struct wbridge_info *wb[WBRIDGE_NUM];
int WBID;
dbus_error_init(&err);
if (!(dbus_message_get_args ( msg, &err,
DBUS_TYPE_UINT32,&WBID,
DBUS_TYPE_INVALID))){
printf("Unable to get input args\n");
if (dbus_error_is_set(&err)) {
printf("%s raised: %s",err.name,err.message);
dbus_error_free(&err);
}
return NULL;
}
if(WBID == 0){
while(i<WBRIDGE_NUM){
if(wBridge[i] != NULL)
{
wb[num] = wBridge[i];
num++;
}
i++;
}
}else{
if(wBridge[WBID] != NULL){
wb[num] = wBridge[WBID];
num++;
}
}
if(num == 0)
ret = WBMD_DBUS_ID_NO_EXIST;
reply = dbus_message_new_method_return(msg);
dbus_message_iter_init_append (reply, &iter);
dbus_message_iter_append_basic (&iter,
DBUS_TYPE_UINT32,
&ret);
if(ret == WBMD_DBUS_SUCCESS){
dbus_message_iter_append_basic (&iter,
DBUS_TYPE_UINT32,
&num);
dbus_message_iter_open_container (&iter,
DBUS_TYPE_ARRAY,
DBUS_STRUCT_BEGIN_CHAR_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_STRUCT_END_CHAR_AS_STRING,
&iter_array);
for(i = 0; i < num; i++){
DBusMessageIter iter_struct;
dbus_message_iter_open_container (&iter_array,
DBUS_TYPE_STRUCT,
NULL,
&iter_struct);
dbus_message_iter_append_basic
(&iter_struct,
DBUS_TYPE_UINT32,
&(wb[i]->WBID));
dbus_message_iter_append_basic
(&iter_struct,
DBUS_TYPE_UINT32,
&(wb[i]->IP));
dbus_message_iter_append_basic
(&iter_struct,
DBUS_TYPE_UINT32,
&(wb[i]->WBState));
dbus_message_iter_append_basic
(&iter_struct,
DBUS_TYPE_UINT32,
&(wb[i]->access_time));
dbus_message_iter_append_basic
(&iter_struct,
DBUS_TYPE_UINT32,
&(wb[i]->last_access_time));
dbus_message_iter_append_basic
(&iter_struct,
DBUS_TYPE_UINT32,
&(wb[i]->leave_time));
dbus_message_iter_close_container (&iter_array, &iter_struct);
}
dbus_message_iter_close_container (&iter, &iter_array);
}
return reply;
}
/**
* @ingroup DBusMessageInternals
* Unit test for DBusMessage.
*
* @returns #TRUE on success.
*/
dbus_bool_t
_dbus_message_test (const char *test_data_dir)
{
DBusMessage *message, *message_without_unix_fds;
DBusMessageLoader *loader;
int i;
const char *data;
DBusMessage *copy;
const char *name1;
const char *name2;
const dbus_uint32_t our_uint32_array[] =
{ 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
const dbus_int32_t our_int32_array[] =
{ 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
const dbus_uint32_t *v_ARRAY_UINT32 = our_uint32_array;
const dbus_int32_t *v_ARRAY_INT32 = our_int32_array;
#ifdef DBUS_HAVE_INT64
const dbus_uint64_t our_uint64_array[] =
{ 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
const dbus_int64_t our_int64_array[] =
{ 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
const dbus_uint64_t *v_ARRAY_UINT64 = our_uint64_array;
const dbus_int64_t *v_ARRAY_INT64 = our_int64_array;
#endif
const char *our_string_array[] = { "Foo", "bar", "", "woo woo woo woo" };
const char **v_ARRAY_STRING = our_string_array;
const double our_double_array[] = { 0.1234, 9876.54321, -300.0 };
const double *v_ARRAY_DOUBLE = our_double_array;
const unsigned char our_byte_array[] = { 'a', 'b', 'c', 234 };
const unsigned char *v_ARRAY_BYTE = our_byte_array;
const dbus_bool_t our_boolean_array[] = { TRUE, FALSE, TRUE, TRUE, FALSE };
const dbus_bool_t *v_ARRAY_BOOLEAN = our_boolean_array;
char sig[64];
const char *s;
const char *v_STRING;
double v_DOUBLE;
dbus_int16_t v_INT16;
dbus_uint16_t v_UINT16;
dbus_int32_t v_INT32;
dbus_uint32_t v_UINT32;
#ifdef DBUS_HAVE_INT64
dbus_int64_t v_INT64;
dbus_uint64_t v_UINT64;
#endif
unsigned char v_BYTE;
unsigned char v2_BYTE;
dbus_bool_t v_BOOLEAN;
DBusMessageIter iter, array_iter, struct_iter;
#ifdef HAVE_UNIX_FD_PASSING
int v_UNIX_FD;
#endif
char **decomposed;
DBusInitialFDs *initial_fds;
initial_fds = _dbus_check_fdleaks_enter ();
message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
"/org/freedesktop/TestPath",
"Foo.TestInterface",
"TestMethod");
_dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
_dbus_assert (dbus_message_is_method_call (message, "Foo.TestInterface",
"TestMethod"));
_dbus_assert (strcmp (dbus_message_get_path (message),
"/org/freedesktop/TestPath") == 0);
dbus_message_set_serial (message, 1234);
/* string length including nul byte not a multiple of 4 */
if (!dbus_message_set_sender (message, "org.foo.bar1"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (dbus_message_has_sender (message, "org.foo.bar1"));
dbus_message_set_reply_serial (message, 5678);
_dbus_verbose_bytes_of_string (&message->header.data, 0,
_dbus_string_get_length (&message->header.data));
_dbus_verbose_bytes_of_string (&message->body, 0,
_dbus_string_get_length (&message->body));
if (!dbus_message_set_sender (message, NULL))
_dbus_assert_not_reached ("out of memory");
_dbus_verbose_bytes_of_string (&message->header.data, 0,
_dbus_string_get_length (&message->header.data));
_dbus_verbose_bytes_of_string (&message->body, 0,
_dbus_string_get_length (&message->body));
_dbus_assert (!dbus_message_has_sender (message, "org.foo.bar1"));
_dbus_assert (dbus_message_get_serial (message) == 1234);
_dbus_assert (dbus_message_get_reply_serial (message) == 5678);
_dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
_dbus_assert (dbus_message_get_no_reply (message) == FALSE);
dbus_message_set_no_reply (message, TRUE);
_dbus_assert (dbus_message_get_no_reply (message) == TRUE);
dbus_message_set_no_reply (message, FALSE);
_dbus_assert (dbus_message_get_no_reply (message) == FALSE);
/* Set/get some header fields */
if (!dbus_message_set_path (message, "/foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo") == 0);
if (!dbus_message_set_interface (message, "org.Foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo") == 0);
if (!dbus_message_set_member (message, "Bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"Bar") == 0);
/* Set/get them with longer values */
if (!dbus_message_set_path (message, "/foo/bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo/bar") == 0);
if (!dbus_message_set_interface (message, "org.Foo.Bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo.Bar") == 0);
if (!dbus_message_set_member (message, "BarFoo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"BarFoo") == 0);
/* Realloc shorter again */
if (!dbus_message_set_path (message, "/foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo") == 0);
if (!dbus_message_set_interface (message, "org.Foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo") == 0);
if (!dbus_message_set_member (message, "Bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"Bar") == 0);
/* Path decomposing */
dbus_message_set_path (message, NULL);
dbus_message_get_path_decomposed (message, &decomposed);
_dbus_assert (decomposed == NULL);
dbus_free_string_array (decomposed);
dbus_message_set_path (message, "/");
dbus_message_get_path_decomposed (message, &decomposed);
_dbus_assert (decomposed != NULL);
_dbus_assert (decomposed[0] == NULL);
dbus_free_string_array (decomposed);
dbus_message_set_path (message, "/a/b");
dbus_message_get_path_decomposed (message, &decomposed);
_dbus_assert (decomposed != NULL);
_dbus_assert (strcmp (decomposed[0], "a") == 0);
_dbus_assert (strcmp (decomposed[1], "b") == 0);
_dbus_assert (decomposed[2] == NULL);
dbus_free_string_array (decomposed);
dbus_message_set_path (message, "/spam/eggs");
dbus_message_get_path_decomposed (message, &decomposed);
_dbus_assert (decomposed != NULL);
_dbus_assert (strcmp (decomposed[0], "spam") == 0);
_dbus_assert (strcmp (decomposed[1], "eggs") == 0);
_dbus_assert (decomposed[2] == NULL);
dbus_free_string_array (decomposed);
dbus_message_unref (message);
/* Test the vararg functions */
message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
"/org/freedesktop/TestPath",
"Foo.TestInterface",
"TestMethod");
dbus_message_set_serial (message, 1);
dbus_message_set_reply_serial (message, 5678);
v_INT16 = -0x123;
v_UINT16 = 0x123;
v_INT32 = -0x12345678;
v_UINT32 = 0x12300042;
#ifdef DBUS_HAVE_INT64
v_INT64 = DBUS_INT64_CONSTANT (-0x123456789abcd);
v_UINT64 = DBUS_UINT64_CONSTANT (0x123456789abcd);
#endif
v_STRING = "Test string";
v_DOUBLE = 3.14159;
v_BOOLEAN = TRUE;
v_BYTE = 42;
v2_BYTE = 24;
#ifdef HAVE_UNIX_FD_PASSING
v_UNIX_FD = 1;
#endif
dbus_message_append_args (message,
DBUS_TYPE_INT16, &v_INT16,
DBUS_TYPE_UINT16, &v_UINT16,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_UINT32, &v_UINT32,
#ifdef DBUS_HAVE_INT64
DBUS_TYPE_INT64, &v_INT64,
DBUS_TYPE_UINT64, &v_UINT64,
#endif
DBUS_TYPE_STRING, &v_STRING,
DBUS_TYPE_DOUBLE, &v_DOUBLE,
DBUS_TYPE_BOOLEAN, &v_BOOLEAN,
DBUS_TYPE_BYTE, &v_BYTE,
DBUS_TYPE_BYTE, &v2_BYTE,
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &v_ARRAY_UINT32,
_DBUS_N_ELEMENTS (our_uint32_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &v_ARRAY_INT32,
_DBUS_N_ELEMENTS (our_int32_array),
#ifdef DBUS_HAVE_INT64
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &v_ARRAY_UINT64,
_DBUS_N_ELEMENTS (our_uint64_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &v_ARRAY_INT64,
_DBUS_N_ELEMENTS (our_int64_array),
#endif
DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &v_ARRAY_DOUBLE,
_DBUS_N_ELEMENTS (our_double_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &v_ARRAY_BYTE,
_DBUS_N_ELEMENTS (our_byte_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN, &v_ARRAY_BOOLEAN,
_DBUS_N_ELEMENTS (our_boolean_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &v_ARRAY_STRING,
_DBUS_N_ELEMENTS (our_string_array),
DBUS_TYPE_INVALID);
i = 0;
sig[i++] = DBUS_TYPE_INT16;
sig[i++] = DBUS_TYPE_UINT16;
sig[i++] = DBUS_TYPE_INT32;
sig[i++] = DBUS_TYPE_UINT32;
#ifdef DBUS_HAVE_INT64
sig[i++] = DBUS_TYPE_INT64;
sig[i++] = DBUS_TYPE_UINT64;
#endif
sig[i++] = DBUS_TYPE_STRING;
sig[i++] = DBUS_TYPE_DOUBLE;
sig[i++] = DBUS_TYPE_BOOLEAN;
sig[i++] = DBUS_TYPE_BYTE;
sig[i++] = DBUS_TYPE_BYTE;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_UINT32;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_INT32;
#ifdef DBUS_HAVE_INT64
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_UINT64;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_INT64;
#endif
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_DOUBLE;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_BYTE;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_BOOLEAN;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_STRING;
message_without_unix_fds = dbus_message_copy(message);
_dbus_assert(message_without_unix_fds);
#ifdef HAVE_UNIX_FD_PASSING
dbus_message_append_args (message,
DBUS_TYPE_UNIX_FD, &v_UNIX_FD,
DBUS_TYPE_INVALID);
sig[i++] = DBUS_TYPE_UNIX_FD;
#endif
sig[i++] = DBUS_TYPE_INVALID;
_dbus_assert (i < (int) _DBUS_N_ELEMENTS (sig));
_dbus_verbose ("HEADER\n");
_dbus_verbose_bytes_of_string (&message->header.data, 0,
_dbus_string_get_length (&message->header.data));
_dbus_verbose ("BODY\n");
_dbus_verbose_bytes_of_string (&message->body, 0,
_dbus_string_get_length (&message->body));
_dbus_verbose ("Signature expected \"%s\" actual \"%s\"\n",
sig, dbus_message_get_signature (message));
s = dbus_message_get_signature (message);
_dbus_assert (dbus_message_has_signature (message, sig));
_dbus_assert (strcmp (s, sig) == 0);
verify_test_message (message);
copy = dbus_message_copy (message);
_dbus_assert (dbus_message_get_reply_serial (message) ==
dbus_message_get_reply_serial (copy));
_dbus_assert (message->header.padding == copy->header.padding);
_dbus_assert (_dbus_string_get_length (&message->header.data) ==
_dbus_string_get_length (©->header.data));
_dbus_assert (_dbus_string_get_length (&message->body) ==
_dbus_string_get_length (©->body));
verify_test_message (copy);
name1 = dbus_message_get_interface (message);
name2 = dbus_message_get_interface (copy);
_dbus_assert (strcmp (name1, name2) == 0);
name1 = dbus_message_get_member (message);
name2 = dbus_message_get_member (copy);
_dbus_assert (strcmp (name1, name2) == 0);
dbus_message_unref (copy);
/* Message loader test */
dbus_message_lock (message);
loader = _dbus_message_loader_new ();
/* check ref/unref */
_dbus_message_loader_ref (loader);
_dbus_message_loader_unref (loader);
/* Write the header data one byte at a time */
data = _dbus_string_get_const_data (&message->header.data);
for (i = 0; i < _dbus_string_get_length (&message->header.data); i++)
{
DBusString *buffer;
_dbus_message_loader_get_buffer (loader, &buffer);
_dbus_string_append_byte (buffer, data[i]);
_dbus_message_loader_return_buffer (loader, buffer, 1);
}
/* Write the body data one byte at a time */
data = _dbus_string_get_const_data (&message->body);
for (i = 0; i < _dbus_string_get_length (&message->body); i++)
{
DBusString *buffer;
_dbus_message_loader_get_buffer (loader, &buffer);
_dbus_string_append_byte (buffer, data[i]);
_dbus_message_loader_return_buffer (loader, buffer, 1);
}
#ifdef HAVE_UNIX_FD_PASSING
{
int *unix_fds;
unsigned n_unix_fds;
/* Write unix fd */
_dbus_message_loader_get_unix_fds(loader, &unix_fds, &n_unix_fds);
_dbus_assert(n_unix_fds > 0);
_dbus_assert(message->n_unix_fds == 1);
unix_fds[0] = _dbus_dup(message->unix_fds[0], NULL);
_dbus_assert(unix_fds[0] >= 0);
_dbus_message_loader_return_unix_fds(loader, unix_fds, 1);
}
#endif
dbus_message_unref (message);
/* Now pop back the message */
if (!_dbus_message_loader_queue_messages (loader))
_dbus_assert_not_reached ("no memory to queue messages");
if (_dbus_message_loader_get_is_corrupted (loader))
_dbus_assert_not_reached ("message loader corrupted");
message = _dbus_message_loader_pop_message (loader);
if (!message)
_dbus_assert_not_reached ("received a NULL message");
if (dbus_message_get_reply_serial (message) != 5678)
_dbus_assert_not_reached ("reply serial fields differ");
dbus_message_unref (message);
/* ovveride the serial, since it was reset by dbus_message_copy() */
dbus_message_set_serial(message_without_unix_fds, 8901);
dbus_message_lock (message_without_unix_fds);
verify_test_message (message_without_unix_fds);
{
/* Marshal and demarshal the message. */
DBusMessage *message2;
DBusError error = DBUS_ERROR_INIT;
char *marshalled = NULL;
int len = 0;
char garbage_header[DBUS_MINIMUM_HEADER_SIZE] = "xxx";
if (!dbus_message_marshal (message_without_unix_fds, &marshalled, &len))
_dbus_assert_not_reached ("failed to marshal message");
_dbus_assert (len != 0);
_dbus_assert (marshalled != NULL);
_dbus_assert (dbus_message_demarshal_bytes_needed (marshalled, len) == len);
message2 = dbus_message_demarshal (marshalled, len, &error);
_dbus_assert (message2 != NULL);
_dbus_assert (!dbus_error_is_set (&error));
verify_test_message (message2);
dbus_message_unref (message2);
dbus_free (marshalled);
/* Demarshal invalid message. */
message2 = dbus_message_demarshal ("invalid", 7, &error);
_dbus_assert (message2 == NULL);
_dbus_assert (dbus_error_is_set (&error));
dbus_error_free (&error);
/* Demarshal invalid (empty) message. */
message2 = dbus_message_demarshal ("", 0, &error);
_dbus_assert (message2 == NULL);
_dbus_assert (dbus_error_is_set (&error));
dbus_error_free (&error);
/* Bytes needed to demarshal empty message: 0 (more) */
_dbus_assert (dbus_message_demarshal_bytes_needed ("", 0) == 0);
/* Bytes needed to demarshal invalid message: -1 (error). */
_dbus_assert (dbus_message_demarshal_bytes_needed (garbage_header, DBUS_MINIMUM_HEADER_SIZE) == -1);
}
dbus_message_unref (message_without_unix_fds);
_dbus_message_loader_unref (loader);
check_memleaks ();
_dbus_check_fdleaks_leave (initial_fds);
initial_fds = _dbus_check_fdleaks_enter ();
/* Check that we can abandon a container */
message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
"/org/freedesktop/TestPath",
"Foo.TestInterface",
"Method");
dbus_message_iter_init_append (message, &iter);
_dbus_assert (dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
(DBUS_STRUCT_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_STRUCT_END_CHAR_AS_STRING),
&array_iter));
_dbus_assert (dbus_message_iter_open_container (&array_iter, DBUS_TYPE_STRUCT,
NULL, &struct_iter));
s = "peaches";
_dbus_assert (dbus_message_iter_append_basic (&struct_iter, DBUS_TYPE_STRING,
&s));
/* uh-oh, error, try and unwind */
dbus_message_iter_abandon_container (&array_iter, &struct_iter);
dbus_message_iter_abandon_container (&array_iter, &iter);
dbus_message_unref (message);
/* Load all the sample messages from the message factory */
{
DBusMessageDataIter diter;
DBusMessageData mdata;
int count;
reset_validities_seen ();
count = 0;
_dbus_message_data_iter_init (&diter);
while (_dbus_message_data_iter_get_and_next (&diter,
&mdata))
{
if (!dbus_internal_do_not_use_try_message_data (&mdata.data,
mdata.expected_validity))
{
_dbus_warn ("expected validity %d and did not get it\n",
mdata.expected_validity);
_dbus_assert_not_reached ("message data failed");
}
_dbus_message_data_free (&mdata);
count += 1;
}
printf ("%d sample messages tested\n", count);
print_validities_seen (FALSE);
print_validities_seen (TRUE);
}
check_memleaks ();
_dbus_check_fdleaks_leave (initial_fds);
/* Now load every message in test_data_dir if we have one */
if (test_data_dir == NULL)
return TRUE;
initial_fds = _dbus_check_fdleaks_enter ();
if (!dbus_internal_do_not_use_foreach_message_file (test_data_dir,
(DBusForeachMessageFileFunc)
dbus_internal_do_not_use_try_message_file,
NULL))
_dbus_assert_not_reached ("foreach_message_file test failed");
_dbus_check_fdleaks_leave (initial_fds);
return TRUE;
}