NS_METHOD
csTpStatusSpec::Create(gpointer aGLibItem, void **aResult)
{
guint type;
gboolean may_set_on_self;
gboolean exclusive;
GHashTable *parameter_types;
GValue structure = { 0 };
g_value_init(&structure, TP_STRUCT_TYPE_STATUS_SPEC);
g_value_set_static_boxed(&structure, aGLibItem);
if (!dbus_g_type_struct_get(&structure,
0, &type, 1, &may_set_on_self, 2, &exclusive, 3, ¶meter_types,
G_MAXUINT))
return NS_ERROR_FAILURE;
nsCOMPtr<nsIArray> cParameterTypes;
csTpStringStringMap::Create((gpointer)parameter_types, getter_AddRefs(cParameterTypes));
csITpStatusSpec *it = new csTpStatusSpec(type, may_set_on_self, exclusive, cParameterTypes);
if (!it)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(it);
nsresult rv = it->QueryInterface(NS_GET_IID(csITpStatusSpec), aResult);
NS_RELEASE(it);
return rv;
}
NS_METHOD
csTpTubeInfo::Create(gpointer aGLibItem, void **aResult)
{
guint identifier;
guint initiator;
guint type;
const gchar *service;
GHashTable *parameters;
guint state;
GValue structure = { 0 };
g_value_init(&structure, TP_STRUCT_TYPE_TUBE_INFO);
g_value_set_static_boxed(&structure, aGLibItem);
if (!dbus_g_type_struct_get(&structure,
0, &identifier, 1, &initiator, 2, &type, 3, &service, 4, ¶meters, 5, &state,
G_MAXUINT))
return NS_ERROR_FAILURE;
nsCString cService = nsDependentCString(service);
nsCOMPtr<nsIArray> cParameters;
csTpStringVariantMap::Create((gpointer)parameters, getter_AddRefs(cParameters));
csITpTubeInfo *it = new csTpTubeInfo(identifier, initiator, type, cService, cParameters, state);
if (!it)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(it);
nsresult rv = it->QueryInterface(NS_GET_IID(csITpTubeInfo), aResult);
NS_RELEASE(it);
return rv;
}
NS_METHOD
csTpLastActivityAndStatuses::Create(gpointer aGLibItem, void **aResult)
{
guint last_activity;
GHashTable *statuses;
GValue structure = { 0 };
g_value_init(&structure, TP_STRUCT_TYPE_LAST_ACTIVITY_AND_STATUSES);
g_value_set_static_boxed(&structure, aGLibItem);
if (!dbus_g_type_struct_get(&structure,
0, &last_activity, 1, &statuses,
G_MAXUINT))
return NS_ERROR_FAILURE;
nsCOMPtr<nsIArray> cStatuses;
csTpMultipleStatusMap::Create((gpointer)statuses, getter_AddRefs(cStatuses));
csITpLastActivityAndStatuses *it = new csTpLastActivityAndStatuses(last_activity, cStatuses);
if (!it)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(it);
nsresult rv = it->QueryInterface(NS_GET_IID(csITpLastActivityAndStatuses), aResult);
NS_RELEASE(it);
return rv;
}
NS_METHOD
csTpSocketNetmaskIPv6::Create(gpointer aGLibItem, void **aResult)
{
const gchar *address;
guchar prefix_length;
GValue structure = { 0 };
g_value_init(&structure, TP_STRUCT_TYPE_SOCKET_NETMASK_IPV6);
g_value_set_static_boxed(&structure, aGLibItem);
if (!dbus_g_type_struct_get(&structure,
0, &address, 1, &prefix_length,
G_MAXUINT))
return NS_ERROR_FAILURE;
nsCString cAddress = nsDependentCString(address);
csITpSocketNetmaskIPv6 *it = new csTpSocketNetmaskIPv6(cAddress, prefix_length);
if (!it)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(it);
nsresult rv = it->QueryInterface(NS_GET_IID(csITpSocketNetmaskIPv6), aResult);
NS_RELEASE(it);
return rv;
}
NS_METHOD
csTpLocalPendingInfo::Create(gpointer aGLibItem, void **aResult)
{
guint to_be_added;
guint actor;
guint reason;
const gchar *message;
GValue structure = { 0 };
g_value_init(&structure, TP_STRUCT_TYPE_LOCAL_PENDING_INFO);
g_value_set_static_boxed(&structure, aGLibItem);
if (!dbus_g_type_struct_get(&structure,
0, &to_be_added, 1, &actor, 2, &reason, 3, &message,
G_MAXUINT))
return NS_ERROR_FAILURE;
nsCString cMessage = nsDependentCString(message);
csITpLocalPendingInfo *it = new csTpLocalPendingInfo(to_be_added, actor, reason, cMessage);
if (!it)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(it);
nsresult rv = it->QueryInterface(NS_GET_IID(csITpLocalPendingInfo), aResult);
NS_RELEASE(it);
return rv;
}
NS_METHOD
csTpDBusTubeMember::Create(gpointer aGLibItem, void **aResult)
{
guint handle;
const gchar *unique_name;
GValue structure = { 0 };
g_value_init(&structure, TP_STRUCT_TYPE_DBUS_TUBE_MEMBER);
g_value_set_static_boxed(&structure, aGLibItem);
if (!dbus_g_type_struct_get(&structure,
0, &handle, 1, &unique_name,
G_MAXUINT))
return NS_ERROR_FAILURE;
nsCString cUniqueName = nsDependentCString(unique_name);
csITpDBusTubeMember *it = new csTpDBusTubeMember(handle, cUniqueName);
if (!it)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(it);
nsresult rv = it->QueryInterface(NS_GET_IID(csITpDBusTubeMember), aResult);
NS_RELEASE(it);
return rv;
}
NS_METHOD
csTpMediaStreamInfo::Create(gpointer aGLibItem, void **aResult)
{
guint identifier;
guint contact;
guint type;
guint state;
guint direction;
guint pending_send_flags;
GValue structure = { 0 };
g_value_init(&structure, TP_STRUCT_TYPE_MEDIA_STREAM_INFO);
g_value_set_static_boxed(&structure, aGLibItem);
if (!dbus_g_type_struct_get(&structure,
0, &identifier, 1, &contact, 2, &type, 3, &state, 4, &direction, 5, &pending_send_flags,
G_MAXUINT))
return NS_ERROR_FAILURE;
csITpMediaStreamInfo *it = new csTpMediaStreamInfo(identifier, contact, type, state, direction, pending_send_flags);
if (!it)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(it);
nsresult rv = it->QueryInterface(NS_GET_IID(csITpMediaStreamInfo), aResult);
NS_RELEASE(it);
return rv;
}
static gboolean
sig_match_conn (TpStreamTubeChannel *self,
SigWaitingConn *sig,
ConnWaitingSig *c)
{
if (self->priv->access_control == TP_SOCKET_ACCESS_CONTROL_PORT)
{
/* Use the port to identify the connection */
guint port;
GSocketAddress *address;
GError *error = NULL;
address = g_socket_connection_get_remote_address (c->conn, &error);
if (address == NULL)
{
DEBUG ("Failed to get connection address: %s", error->message);
g_error_free (error);
return FALSE;
}
dbus_g_type_struct_get (sig->param, 1, &port, G_MAXINT);
if (port == g_inet_socket_address_get_port (
G_INET_SOCKET_ADDRESS (address)))
{
DEBUG ("Identified connection %u using port %u",
port, sig->connection_id);
g_object_unref (address);
return TRUE;
}
g_object_unref (address);
}
else if (self->priv->access_control == TP_SOCKET_ACCESS_CONTROL_CREDENTIALS)
{
guchar byte;
byte = g_value_get_uchar (sig->param);
return byte == c->byte;
}
else
{
DEBUG ("Can't properly identify connection as we are using "
"access control %u. Assume it's the head of the list",
self->priv->access_control);
return TRUE;
}
return FALSE;
}
static void remmina_tp_channel_handler_accept(TpChannel *channel, const GValue *address, const GError *error,
gpointer user_data, GObject *weak_object)
{
RemminaTpChannelHandler *chandler = (RemminaTpChannelHandler *) user_data;
if (error != NULL)
{
g_print("remmina_tp_channel_handler_accept: %s", error->message);
remmina_tp_channel_handler_free(chandler);
return;
}
dbus_g_type_struct_get(address, 0, &chandler->host, 1, &chandler->port, G_MAXUINT);
tp_cli_dbus_properties_call_get(channel, -1, TP_IFACE_CHANNEL_TYPE_STREAM_TUBE, "Service",
remmina_tp_channel_handler_get_service, chandler, NULL, NULL);
}
static void __bluetooth_ptr_array_free(gpointer data)
{
GValue value = { 0, };
gchar *name = NULL;
gchar *type = NULL;
if(data == NULL)
return;
g_value_init(&value, DBUS_STRUCT_STRING_STRING);
g_value_set_boxed(&value, data);
dbus_g_type_struct_get(&value,
0, &name,
1, &type,
G_MAXUINT);
g_free(name);
g_free(type);
}
static void
tp_tube_accept_stream_cb (TpProxy *proxy,
const GValue *address,
const GError *error,
gpointer user_data,
GObject *weak_object)
{
EmpathyTpTube *tube = EMPATHY_TP_TUBE (weak_object);
EmpathyTpTubeAcceptData *data = (EmpathyTpTubeAcceptData *)user_data;
EmpathyTpTubeAddress eaddress;
eaddress.type = data->type;
if (error)
{
DEBUG ("Error accepting tube: %s", error->message);
data->callback (tube, NULL, error, data->user_data);
return;
}
switch (eaddress.type)
{
case TP_SOCKET_ADDRESS_TYPE_UNIX:
case TP_SOCKET_ADDRESS_TYPE_ABSTRACT_UNIX:
eaddress.a.socket.path = g_value_get_boxed (address);
break;
case TP_SOCKET_ADDRESS_TYPE_IPV4:
case TP_SOCKET_ADDRESS_TYPE_IPV6:
dbus_g_type_struct_get (address,
0, &eaddress.a.inet.hostname,
1, &eaddress.a.inet.port, G_MAXUINT);
break;
}
data->callback (tube, &eaddress, NULL, data->user_data);
}
static void
GotParamsForNewConnection(TpConnectionManager *cm, const GPtrArray *arr,
const GError *error, gpointer user_data, GObject *unused)
{
Get_Params_For_Connection* cb_struct = (Get_Params_For_Connection*)user_data;
csITpConnectionManagerRequestConnectionCB *cb = cb_struct->connectionCB;
nsCString aProtocol = cb_struct->protocolName;
nsIArray *aParameters = cb_struct->parameters;
if (error != NULL) {
if (cb) {
cb->OnRequestConnectionError(nsDependentCString(g_quark_to_string(error->domain)),
error->code, nsDependentCString(error->message));
}
return;
}
PRUint32 parametersCount;
nsresult rv = aParameters->GetLength(¶metersCount);
if (NS_FAILED(rv))
return;
// Put all the passed parameters in a hash.
// XXX: Copy of this code exists in CallRequestConnection.
nsInterfaceHashtable<nsCStringHashKey, nsIVariant> parameters;
parameters.Init();
for (PRUint32 i=0; i<parametersCount; i++) {
nsCOMPtr<csITpStringVariantMap> param = do_QueryElementAt(aParameters, i);
nsCOMPtr<nsIVariant> value;
nsCString key;
rv = param->GetKey(key);
if (NS_FAILED(rv))
continue;
rv = param->GetValue(getter_AddRefs(value));
if (NS_FAILED(rv))
continue;
if (value)
parameters.Put(key, value);
}
PRUint32 length = arr->len;
GHashTable *hash = g_hash_table_new(g_str_hash, g_str_equal);
for (PRUint32 i=0; i<length; i++) {
GValue structure = {0};
TpConnectionManagerParam *tpparam = g_new0(TpConnectionManagerParam, 1);
g_value_init(&structure, TP_STRUCT_TYPE_PARAM_SPEC);
g_value_set_static_boxed(&structure, g_ptr_array_index(arr, i));
if (dbus_g_type_struct_get(&structure,
0, &tpparam->name, 1, &tpparam->flags,
2, &tpparam->dbus_signature, G_MAXUINT)) {
nsCOMPtr<nsIVariant> variant;
if (parameters.Get(nsDependentCString(tpparam->name), getter_AddRefs(variant))) {
GValue *value = VariantToGValueWithSignature(variant, tpparam->dbus_signature);
g_hash_table_insert(hash, g_strdup(tpparam->name), value);
}
}
}
NS_IF_ADDREF(cb);
tp_cli_connection_manager_call_request_connection(cm, -1,
nsCString(aProtocol).get(), hash,
cb? RequestConnectionResponse: NULL,
cb? cb: NULL, NULL, NULL);
NS_IF_RELEASE(cb);
NS_IF_RELEASE(aParameters);
}
/**
* tp_properties_mixin_set_properties:
* @obj: An object with this mixin
* @properties: An array of D-Bus structures containing property ID and value
* @context: A D-Bus method invocation context for the SetProperties method
*
* Start to change properties in response to user request via D-Bus.
*/
void
tp_properties_mixin_set_properties (GObject *obj,
const GPtrArray *properties,
DBusGMethodInvocation *context)
{
TpPropertiesMixin *mixin = TP_PROPERTIES_MIXIN (obj);
TpPropertiesMixinClass *mixin_cls = TP_PROPERTIES_MIXIN_CLASS (
G_OBJECT_GET_CLASS (obj));
TpPropertiesContext *ctx = &mixin->priv->context;
GError *error = NULL;
GType value_type = TP_STRUCT_TYPE_PROPERTY_VALUE;
guint i;
/* Is another SetProperties request already in progress? */
if (ctx->dbus_ctx)
{
error = g_error_new (TP_ERRORS, TP_ERROR_NOT_AVAILABLE,
"A SetProperties request is already in progress");
dbus_g_method_return_error (context, error);
g_error_free (error);
return;
}
ctx->dbus_ctx = context;
ctx->remaining = tp_intset_new ();
error = NULL;
if (properties->len == 0)
{
DEBUG ("immediately returning from SetProperties with 0 properties");
tp_properties_context_return (ctx, NULL);
return;
}
/* Check input property identifiers */
for (i = 0; i < properties->len; i++)
{
GValue val_struct = { 0, };
guint prop_id;
GValue *prop_val;
g_value_init (&val_struct, value_type);
g_value_set_static_boxed (&val_struct,
g_ptr_array_index (properties, i));
dbus_g_type_struct_get (&val_struct,
0, &prop_id,
1, &prop_val,
G_MAXUINT);
/* Valid? */
if (prop_id >= mixin_cls->num_props)
{
g_value_unset (prop_val);
error = g_error_new (TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
"invalid property identifier %d", prop_id);
goto ERROR;
}
/* Store the value in the context */
tp_intset_add (ctx->remaining, prop_id);
ctx->values[prop_id] = prop_val;
/* Permitted? */
if (!tp_properties_mixin_is_writable (obj, prop_id))
{
error = g_error_new (TP_ERRORS, TP_ERROR_PERMISSION_DENIED,
"permission denied for property identifier %d",
prop_id);
goto ERROR;
}
/* Compatible type? */
if (!g_value_type_compatible (G_VALUE_TYPE (prop_val),
mixin_cls->signatures[prop_id].type))
{
error = g_error_new (TP_ERRORS, TP_ERROR_NOT_AVAILABLE,
"incompatible value type for property "
"identifier %d", prop_id);
goto ERROR;
}
}
if (mixin_cls->set_properties)
{
if (mixin_cls->set_properties (obj, ctx, &error))
return;
}
else
{
tp_properties_context_return (ctx, NULL);
return;
}
ERROR:
tp_properties_context_return (ctx, error);
}
/**
*
* Method GetData on /org/freedesktop/DeviceKit/Power/Wakeups
*
* <method name="GetData">
* <arg name="data" type="a(budss)" direction="out"/> (1)
* </method>
* (1): array | boolean Wheter the proceess on userspace
* | uint PID
* | double Wakeups value
* | string command line
* | string details
**/
static void
xfpm_info_update_wakeups (XfpmInfo *info)
{
GtkListStore *store;
GError *error = NULL;
static GType collection_type = G_TYPE_INVALID;
static GType struct_type = G_TYPE_INVALID;
GPtrArray *array = NULL;
gboolean ret;
guint i;
if ( G_UNLIKELY (collection_type == G_TYPE_INVALID ) )
{
struct_type = dbus_g_type_get_struct ("GValueArray",
G_TYPE_BOOLEAN,
G_TYPE_UINT,
G_TYPE_DOUBLE,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INVALID);
collection_type = dbus_g_type_get_collection ("GPtrArray", struct_type);
}
ret = dbus_g_proxy_call (info->wakeups_proxy, "GetData", &error,
G_TYPE_INVALID,
collection_type, &array,
NULL);
if ( !ret )
{
g_warning ("GetData Failed on %s : %s", UPOWER_PATH_WAKEUPS, error->message);
g_error_free (error);
return;
}
store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (info->wakeups)));
gtk_list_store_clear (GTK_LIST_STORE (store));
for ( i = 0; i < array->len; i++ )
{
GValue elem = { 0 };
GtkTreeIter iter;
gboolean userspace;
guint pid;
gdouble value;
gchar *cmd;
gchar *formatted_cmd;
gchar *details;
gchar *formatted_details;
gchar *pid_str;
gchar *value_str;
const gchar *icon;
g_value_init (&elem, struct_type);
g_value_set_static_boxed (&elem, g_ptr_array_index (array, i));
dbus_g_type_struct_get (&elem,
0, &userspace,
1, &pid,
2, &value,
3, &cmd,
4, &details,
G_MAXUINT);
if ( userspace )
{
pid_str = g_strdup_printf ("%i", pid);
}
else
{
if ( pid < 0xff0 )
{
pid_str = g_strdup_printf ("IRQ%i", pid);
}
else
{
pid_str = g_strdup("IRQx");
}
}
value_str = g_strdup_printf ("%.1f", value);
icon = userspace ? "application-x-executable" : "applications-system";
formatted_cmd = gpm_stats_format_cmdline (cmd, userspace);
formatted_details = gpm_stats_format_details (details);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COL_WAKEUPS_TYPE, icon,
COL_WAKEUPS_PID, pid_str,
COL_WAKEUPS_VALUE, value_str,
COL_WAKEUPS_CMD, formatted_cmd,
COL_WAKEUPS_DETAILS, formatted_details,
-1);
g_free (cmd);
g_free (details);
g_free (formatted_cmd);
g_free (formatted_details);
g_value_unset (&elem);
}
g_ptr_array_free (array, TRUE);
}
