static gboolean kindling_roomlist_manager_get_channel(TpChannelManager *manager,
gpointer request_token,
GHashTable *request_properties,
gboolean require_new) {
KindlingRoomlistManagerPrivate *priv = KINDLING_ROOMLIST_MANAGER_GET_PRIVATE(manager);
TpExportableChannel *channel;
g_printf("get channel %s\n", tp_asv_get_string (request_properties,TP_IFACE_CHANNEL ".ChannelType"));
if (tp_strdiff (tp_asv_get_string (request_properties, TP_IFACE_CHANNEL".ChannelType"),
TP_IFACE_CHANNEL_TYPE_ROOM_LIST)) {
return FALSE;
}
if (priv->channels->len > 0 && !require_new) {
tp_channel_manager_emit_request_already_satisfied (manager, request_token, TP_EXPORTABLE_CHANNEL(g_ptr_array_index (priv->channels,0)));
return TRUE;
}
channel = g_object_new(KINDLING_TYPE_ROOMLIST_CHANNEL, "connection", priv->conn, NULL);
g_signal_connect (channel, "closed", (GCallback) roomlist_channel_closed_cb, manager);
g_ptr_array_add(priv->channels, channel);
GSList *request_tokens = g_slist_prepend (NULL, request_token);
tp_channel_manager_emit_new_channel (manager,
TP_EXPORTABLE_CHANNEL(channel),
request_tokens);
g_slist_free (request_tokens);
return TRUE;
}
gboolean
_capabilities_has_stream_tube (TpCapabilities *caps)
{
GPtrArray *classes;
guint i;
if (caps == NULL)
return FALSE;
classes = tp_capabilities_get_channel_classes (caps);
for (i = 0; i < classes->len; i++)
{
GValueArray *arr = g_ptr_array_index (classes, i);
GHashTable *fixed;
const gchar *chan_type;
const gchar *service;
TpHandleType handle_type;
fixed = g_value_get_boxed (g_value_array_get_nth (arr, 0));
chan_type = tp_asv_get_string (fixed, TP_PROP_CHANNEL_CHANNEL_TYPE);
service = tp_asv_get_string (fixed,
TP_PROP_CHANNEL_TYPE_STREAM_TUBE_SERVICE);
handle_type = tp_asv_get_uint32 (fixed,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, NULL);
if (!tp_strdiff (chan_type, TP_IFACE_CHANNEL_TYPE_STREAM_TUBE) &&
handle_type == TP_HANDLE_TYPE_CONTACT &&
(!tp_capabilities_is_specific_to_contact (caps) ||
!tp_strdiff (service, TUBE_SERVICE)))
return TRUE;
}
return FALSE;
}
static void
send_message (GObject *object,
TpMessage *message,
TpMessageSendingFlags flags)
{
FetionImChannel *self = FETION_IM_CHANNEL (object);
TpBaseChannel *base = TP_BASE_CHANNEL (self);
if (tp_asv_get_string (tp_message_peek (message, 0), "interface") != NULL)
{
/* this message is interface-specific - let's not echo it */
goto finally;
}
FetionConnection *conn =
FETION_CONNECTION (tp_base_channel_get_connection(base));
HybridAccount *account = conn->priv->account;
TpHandle from = tp_base_channel_get_target_handle (base);
const GHashTable *input = tp_message_peek (message, 1);
const gchar *send_message = tp_asv_get_string (input, "content");
HybridBuddy *buddy = hybrid_blist_find_buddy_by_handle(account, from);
hybrid_conv_send_message(account,buddy,send_message);
finally:
/* "OK, we've sent the message" (after calling this, message must not be
* dereferenced) */
tp_message_mixin_sent (object, message, flags, "", NULL);
}
static TpBaseConnection *
new_connection (TpBaseProtocol *protocol,
GHashTable *asv,
GError **error)
{
DurkaConnection *conn;
const gchar *account;
const gchar *password;
const gchar *token;
account = tp_asv_get_string (asv, "account");
password = tp_asv_get_string (asv, "password");
token = tp_asv_get_string (asv, "token");
/* telepathy-glib checked this for us */
g_assert (account != NULL);
conn = DURKA_CONNECTION (
g_object_new (DURKA_TYPE_CONNECTION,
"account", account,
"protocol", tp_base_protocol_get_name (protocol),
"password", password,
"token", token,
NULL));
return (TpBaseConnection *) conn;
}
/** start send message **/
static void
send_message (GObject *object,
TpMessage *message,
TpMessageSendingFlags flags)
{
LwqqChannel* self = LWQQ_CHANNEL(object);
TpBaseChannel *base = TP_BASE_CHANNEL (self);
if (tp_asv_get_string (tp_message_peek (message, 0), "interface") != NULL)
{
/* this message is interface-specific - let's not echo it */
goto finally;
}
LwqqConnection *conn =
LWQQ_CONNECTION(tp_base_channel_get_connection(base));
LwqqClient* lc = conn->lc;
TpHandle to = tp_base_channel_get_target_handle (base);
const GHashTable *input = tp_message_peek (message, 1);
const gchar *send_message = tp_asv_get_string (input, "content");
LwqqBuddy* buddy = lwqq_find_buddy_by_handle(conn, to);
lwqq_msg_send_text(lc, LWQQ_MS_BUDDY_MSG, buddy->uin, send_message);
finally:
/* "OK, we've sent the message" (after calling this, message must not be
* dereferenced) */
tp_message_mixin_sent (object, message, flags, "", NULL);
}
static void
iterate_on_channels (EmpathyTpContactList *list,
const GPtrArray *channels)
{
guint i;
for (i = 0; i < channels->len ; i++) {
GValueArray *arr = g_ptr_array_index (channels, i);
const gchar *path;
GHashTable *properties;
TpHandleType handle_type;
path = g_value_get_boxed (g_value_array_get_nth (arr, 0));
properties = g_value_get_boxed (g_value_array_get_nth (arr, 1));
if (tp_strdiff (tp_asv_get_string (properties,
TP_IFACE_CHANNEL ".ChannelType"),
TP_IFACE_CHANNEL_TYPE_CONTACT_LIST))
continue;
if (tp_asv_get_string (properties, TP_IFACE_CHANNEL ".TargetID") == NULL)
continue;
handle_type = tp_asv_get_uint32 (properties,
TP_IFACE_CHANNEL ".TargetHandleType", NULL);
if (handle_type != TP_HANDLE_TYPE_GROUP)
continue;
tp_contact_list_group_add_channel (list, path, properties);
}
}
static void
empathy_tube_dispatch_constructed (GObject *object)
{
EmpathyTubeDispatch *self = EMPATHY_TUBE_DISPATCH (object);
EmpathyTubeDispatchPriv *priv = GET_PRIV (self);
TpChannel *channel;
GHashTable *properties;
const gchar *service;
const gchar *channel_type;
TpTubeType type;
priv->dbus = tp_dbus_daemon_new (tp_get_bus());
channel = empathy_dispatch_operation_get_channel (priv->operation);
properties = tp_channel_borrow_immutable_properties (channel);
channel_type = tp_asv_get_string (properties,
TP_IFACE_CHANNEL ".ChannelType");
if (channel_type == NULL)
goto failed;
if (!tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_STREAM_TUBE))
{
type = TP_TUBE_TYPE_STREAM;
service = tp_asv_get_string (properties,
EMP_IFACE_CHANNEL_TYPE_STREAM_TUBE ".Service");
}
else if (!tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_DBUS_TUBE))
{
type = TP_TUBE_TYPE_DBUS;
service = tp_asv_get_string (properties,
EMP_IFACE_CHANNEL_TYPE_DBUS_TUBE ".ServiceName");
}
else
{
goto failed;
}
if (service == NULL)
goto failed;
priv->bus_name = empathy_tube_handler_build_bus_name (type, service);
priv->object_path = empathy_tube_handler_build_object_path (type, service);
priv->service = g_strdup (service);
DEBUG ("Look for tube handler %s\n", priv->bus_name);
tp_cli_dbus_daemon_call_name_has_owner (priv->dbus, -1, priv->bus_name,
empathy_tube_dispatch_name_has_owner_cb, NULL, NULL, G_OBJECT (self));
return;
failed:
empathy_tube_dispatch_set_ability (self,
EMPATHY_TUBE_DISPATCHABILITY_IMPOSSIBLE);
}
static void
uoa_session_process_cb (SignonAuthSession *session,
GHashTable *session_data,
const GError *error,
gpointer user_data)
{
GSimpleAsyncResult *result = user_data;
const gchar *password;
if (error != NULL)
{
g_simple_async_result_set_from_error (result, error);
goto out;
}
password = tp_asv_get_string (session_data, "Secret");
if (tp_str_empty (password))
{
g_simple_async_result_set_error (result, TP_ERROR,
TP_ERROR_DOES_NOT_EXIST, "Password not found");
goto out;
}
g_simple_async_result_set_op_res_gpointer (result, g_strdup (password),
g_free);
out:
/* libaccounts-glib API does not guarantee the callback happens after
* reentering mainloop */
g_simple_async_result_complete_in_idle (result);
g_object_unref (result);
g_object_unref (session);
}
static void tls_certificate_got_all_handler(TpProxy *proxy,
GHashTable *properties, const GError *error,
gpointer user_data, GObject *weak_object)
{
HevImpathyTLSCertificate *self = HEV_IMPATHY_TLS_CERTIFICATE(weak_object);
HevImpathyTLSCertificatePrivate *priv =
HEV_IMPATHY_TLS_CERTIFICATE_GET_PRIVATE(self);
GPtrArray *cert_data = NULL;
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
if(NULL != error)
{
g_simple_async_result_set_from_error(priv->async_prepare_res, error);
g_simple_async_result_complete(priv->async_prepare_res);
tp_clear_object(&priv->async_prepare_res);
return;
}
priv->cert_type = g_strdup(tp_asv_get_string(properties,
"CertificateType"));
priv->state = tp_asv_get_uint32(properties, "State", NULL);
cert_data = tp_asv_get_boxed(properties, "CertificateChainData",
TP_ARRAY_TYPE_UCHAR_ARRAY_LIST);
g_assert(NULL != cert_data);
priv->cert_data = g_boxed_copy(TP_ARRAY_TYPE_UCHAR_ARRAY_LIST,
cert_data);
priv->is_prepared = TRUE;
g_simple_async_result_complete(priv->async_prepare_res);
tp_clear_object(&priv->async_prepare_res);
}
static gboolean
example_csh_room_manager_request (ExampleCSHRoomManager *self,
gpointer request_token,
GHashTable *request_properties,
gboolean require_new)
{
TpHandle handle;
ExampleCSHRoomChannel *chan;
GError *error = NULL;
if (tp_strdiff (tp_asv_get_string (request_properties,
TP_PROP_CHANNEL_CHANNEL_TYPE),
TP_IFACE_CHANNEL_TYPE_TEXT))
{
return FALSE;
}
if (tp_asv_get_uint32 (request_properties,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, NULL) != TP_HANDLE_TYPE_ROOM)
{
return FALSE;
}
handle = tp_asv_get_uint32 (request_properties,
TP_PROP_CHANNEL_TARGET_HANDLE, NULL);
g_assert (handle != 0);
if (tp_channel_manager_asv_has_unknown_properties (request_properties,
fixed_properties, allowed_properties, &error))
{
goto error;
}
chan = g_hash_table_lookup (self->priv->channels, GUINT_TO_POINTER (handle));
if (chan == NULL)
{
new_channel (self, handle, self->priv->conn->self_handle,
request_token);
}
else if (require_new)
{
g_set_error (&error, TP_ERRORS, TP_ERROR_NOT_AVAILABLE,
"A Text channel for room #%u already exists", handle);
goto error;
}
else
{
tp_channel_manager_emit_request_already_satisfied (self,
request_token, TP_EXPORTABLE_CHANNEL (chan));
}
return TRUE;
error:
tp_channel_manager_emit_request_failed (self, request_token,
error->domain, error->code, error->message);
g_error_free (error);
return TRUE;
}
static TpChannel *
create_channel_impl (TpSimpleClientFactory *self,
TpConnection *conn,
const gchar *object_path,
const GHashTable *properties,
GError **error)
{
const gchar *chan_type;
ChannelTypeMapping *m;
chan_type = tp_asv_get_string (properties, TP_PROP_CHANNEL_CHANNEL_TYPE);
for (m = channel_type_mapping; m->channel_type != NULL; m++)
{
if (tp_strdiff (chan_type, m->channel_type))
continue;
if (m->check_properties != NULL &&
!m->check_properties (object_path, properties))
break;
return m->new_func (self, conn, object_path, properties, error);
}
/* Chainup on parent implementation as fallback */
return chainup->create_channel (self, conn, object_path, properties, error);
}
/**
* tp_stream_tube_channel_get_service:
* @self: a #TpStreamTubeChannel
*
* Return the #TpStreamTubeChannel:service property
*
* Returns: (transfer none): the value of #TpStreamTubeChannel:service
*
* Since: 0.13.2
*/
const gchar *
tp_stream_tube_channel_get_service (TpStreamTubeChannel *self)
{
GHashTable *props;
props = _tp_channel_get_immutable_properties (TP_CHANNEL (self));
return tp_asv_get_string (props, TP_PROP_CHANNEL_TYPE_STREAM_TUBE_SERVICE);
}
static void
file_transfer_channel_ready (TpChannel *channel,
const GError *in_error,
gpointer user_data)
{
GError *error = NULL;
handle_error (in_error);
GHashTable *map = tp_channel_borrow_immutable_properties (channel);
const char *filename = tp_asv_get_string (map,
TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_FILENAME);
guint64 size = tp_asv_get_uint64 (map,
TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_SIZE, NULL);
g_print ("New file transfer to %s -- `%s' (%llu bytes)\n",
tp_channel_get_identifier (channel),
filename, size);
/* File transfers in Telepathy work by opening a socket to the
* Connection Manager and streaming the file over that socket.
* Let's find out what manner of sockets are supported by this CM */
GHashTable *sockets = tp_asv_get_boxed (map,
TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_AVAILABLE_SOCKET_TYPES,
TP_HASH_TYPE_SUPPORTED_SOCKET_MAP);
/* let's try for IPv4 */
if (g_hash_table_lookup (sockets,
GINT_TO_POINTER (TP_SOCKET_ADDRESS_TYPE_IPV4)))
{
g_print ("ipv4 supported\n");
}
else if (g_hash_table_lookup (sockets,
GINT_TO_POINTER (TP_SOCKET_ADDRESS_TYPE_UNIX)))
{
struct ft_state *state = g_slice_new0 (struct ft_state);
state->sa.sun_family = AF_UNIX;
tp_cli_channel_type_file_transfer_connect_to_file_transfer_state_changed (
channel, file_transfer_unix_state_changed_cb,
state, NULL, NULL, &error);
handle_error (error);
GValue *value = tp_g_value_slice_new_static_string ("");
/* set up the socket for providing the file */
tp_cli_channel_type_file_transfer_call_provide_file (
channel, -1, TP_SOCKET_ADDRESS_TYPE_UNIX,
TP_SOCKET_ACCESS_CONTROL_LOCALHOST,
value, file_transfer_unix_cb,
state, NULL, NULL);
tp_g_value_slice_free (value);
}
}
static gboolean
gabble_im_factory_requestotron (GabbleImFactory *self,
gpointer request_token,
GHashTable *request_properties,
gboolean require_new)
{
TpHandle handle;
GError *error = NULL;
TpExportableChannel *channel;
if (tp_strdiff (tp_asv_get_string (request_properties,
TP_IFACE_CHANNEL ".ChannelType"), TP_IFACE_CHANNEL_TYPE_TEXT))
return FALSE;
if (tp_asv_get_uint32 (request_properties,
TP_IFACE_CHANNEL ".TargetHandleType", NULL) != TP_HANDLE_TYPE_CONTACT)
return FALSE;
/* validity already checked by TpBaseConnection */
handle = tp_asv_get_uint32 (request_properties,
TP_IFACE_CHANNEL ".TargetHandle", NULL);
g_assert (handle != 0);
if (tp_channel_manager_asv_has_unknown_properties (request_properties,
im_channel_fixed_properties, im_channel_allowed_properties,
&error))
goto error;
channel = g_hash_table_lookup (self->priv->channels,
GUINT_TO_POINTER (handle));
if (channel == NULL)
{
new_im_channel (self, handle, request_token);
return TRUE;
}
if (require_new)
{
g_set_error (&error, TP_ERROR, TP_ERROR_NOT_AVAILABLE,
"Already chatting with contact #%u in another channel", handle);
goto error;
}
tp_channel_manager_emit_request_already_satisfied (self, request_token,
channel);
return TRUE;
error:
tp_channel_manager_emit_request_failed (self, request_token,
error->domain, error->code, error->message);
g_error_free (error);
return TRUE;
}
static void
on_group_contacts_changed (TpChannel *channel,
GPtrArray *added,
GPtrArray *removed,
GPtrArray *local_pending,
GPtrArray *remote_pending,
TpContact *actor,
GHashTable *details,
gpointer user_data)
{
TpChannelGroupChangeReason reason;
const char *message;
int i;
reason = tp_asv_get_uint32 (details, "change-reason", NULL);
message = tp_asv_get_string (details, "message");
switch (reason)
{
case TP_CHANNEL_GROUP_CHANGE_REASON_RENAMED:
g_signal_emit (user_data, signals[MEMBER_RENAMED], 0,
g_ptr_array_index (removed, 0),
g_ptr_array_index (added, 0));
break;
case TP_CHANNEL_GROUP_CHANGE_REASON_OFFLINE:
for (i = 0; i < removed->len; i++)
g_signal_emit (user_data, signals[MEMBER_DISCONNECTED], 0,
g_ptr_array_index (removed, i), message);
break;
case TP_CHANNEL_GROUP_CHANGE_REASON_KICKED:
for (i = 0; i < removed->len; i++)
g_signal_emit (user_data, signals[MEMBER_KICKED], 0,
g_ptr_array_index (removed, i), actor);
break;
case TP_CHANNEL_GROUP_CHANGE_REASON_BANNED:
for (i = 0; i < removed->len; i++)
g_signal_emit (user_data, signals[MEMBER_BANNED], 0,
g_ptr_array_index (removed, i), actor);
break;
case TP_CHANNEL_GROUP_CHANGE_REASON_NONE:
for (i = 0; i < removed->len; i++)
g_signal_emit (user_data, signals[MEMBER_LEFT], 0,
g_ptr_array_index (removed, i), message);
for (i = 0; i < added->len; i++)
g_signal_emit (user_data, signals[MEMBER_JOINED], 0,
g_ptr_array_index (added, i));
break;
}
g_signal_emit (user_data, signals[MEMBERS_CHANGED], 0);
}
static EmpathyCapabilities
channel_classes_to_capabilities (GPtrArray *classes,
gboolean audio_video)
{
EmpathyCapabilities capabilities = 0;
guint i;
for (i = 0; i < classes->len; i++) {
GValueArray *class_struct;
GHashTable *fixed_prop;
GStrv allowed_prop;
TpHandleType handle_type;
const gchar *chan_type;
class_struct = g_ptr_array_index (classes, i);
fixed_prop = g_value_get_boxed (g_value_array_get_nth (class_struct, 0));
allowed_prop = g_value_get_boxed (g_value_array_get_nth (class_struct, 1));
handle_type = tp_asv_get_uint32 (fixed_prop,
TP_IFACE_CHANNEL ".TargetHandleType", NULL);
if (handle_type != TP_HANDLE_TYPE_CONTACT)
continue;
chan_type = tp_asv_get_string (fixed_prop,
TP_IFACE_CHANNEL ".ChannelType");
if (!tp_strdiff (chan_type, TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER)) {
capabilities |= EMPATHY_CAPABILITIES_FT;
}
else if (!tp_strdiff (chan_type, TP_IFACE_CHANNEL_TYPE_STREAM_TUBE)) {
capabilities |= EMPATHY_CAPABILITIES_STREAM_TUBE;
}
else if (audio_video && !tp_strdiff (chan_type,
TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA)) {
guint j;
for (j = 0; allowed_prop[j] != NULL; j++) {
if (!tp_strdiff (allowed_prop[j],
TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA ".InitialAudio"))
capabilities |= EMPATHY_CAPABILITIES_AUDIO;
else if (!tp_strdiff (allowed_prop[j],
TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA ".InitialVideo"))
capabilities |= EMPATHY_CAPABILITIES_VIDEO;
}
}
}
return capabilities;
}
static void
update_subject (PolariRoom *room,
GHashTable *properties)
{
PolariRoomPrivate *priv = room->priv;
const char *subject;
subject = tp_asv_get_string (properties, "Subject");
if (subject == NULL || g_strcmp0 (priv->topic, subject) == 0)
return;
g_free (priv->topic);
priv->topic = *subject ? g_strdup (subject) : NULL;
g_object_notify_by_pspec (G_OBJECT (room), props[PROP_TOPIC]);
}
static void
import_widget_add_account (EmpathyImportWidget *self,
EmpathyImportAccountData *data)
{
TpAccountManager *account_manager;
gchar *display_name = NULL;
GHashTable *properties;
GValue *username;
account_manager = tp_account_manager_dup ();
DEBUG ("connection_manager: %s\n", data->connection_manager);
/* Set the display name of the account */
username = g_hash_table_lookup (data->settings, "account");
if (!tp_strdiff (data->protocol, "irc"))
{
const gchar *server;
server = tp_asv_get_string (data->settings, "server");
if (server != NULL)
display_name = g_strdup_printf ("%s on %s",
g_value_get_string (username), server);
}
if (display_name == NULL)
{
display_name = g_strdup_printf ("%s (%s)",
data->protocol, g_value_get_string (username));
}
DEBUG ("display name: %s\n", display_name);
properties = tp_asv_new (NULL, NULL);
tp_asv_set_boolean (properties, TP_IFACE_ACCOUNT ".Enabled", data->enabled);
tp_account_manager_create_account_async (account_manager,
(const gchar*) data->connection_manager, data->protocol, display_name,
data->settings, properties, import_widget_create_account_cb,
g_object_ref (self));
g_hash_table_unref (properties);
g_free (display_name);
g_object_unref (account_manager);
}
static TpChannel *
create_channel (TpSimpleClientFactory *self,
TpConnection *conn,
const gchar *object_path,
const GHashTable *properties,
GError **error)
{
const gchar *channel_type;
channel_type = tp_asv_get_string (properties, TP_PROP_CHANNEL_CHANNEL_TYPE);
if (g_strcmp0 (channel_type, TP_IFACE_CHANNEL_TYPE_TEXT) == 0) {
return TP_CHANNEL (tmc_text_channel_new (self, conn, object_path, properties, error));
} else {
g_debug ("Unknown channel type: %s", channel_type);
return TP_SIMPLE_CLIENT_FACTORY_CLASS (tmc_client_factory_parent_class)->create_channel (self, conn, object_path, properties, error);
}
}
static gboolean
import_widget_account_id_in_list (GList *accounts,
const gchar *account_id)
{
GList *l;
for (l = accounts; l; l = l->next)
{
TpAccount *account = l->data;
const GHashTable *parameters;
parameters = tp_account_get_parameters (account);
if (!tp_strdiff (tp_asv_get_string (parameters, "account"), account_id))
return TRUE;
}
return FALSE;
}
static gboolean
handle_subject (WockyNode *parent_node,
GHashTable *mail)
{
gboolean dirty = FALSE;
WockyNode *node;
node = wocky_node_get_child (parent_node, "subject");
if (node != NULL)
{
if (tp_strdiff (node->content, tp_asv_get_string (mail, "subject")))
{
dirty = TRUE;
tp_asv_set_string (mail, "subject", node->content);
}
}
return dirty;
}
static void
on_immediate_message (ModemSMSService *sms,
gchar const *message,
GHashTable *info,
gpointer _self)
{
RingTextManager *self = RING_TEXT_MANAGER (_self);
char const *sender;
RingTextChannel *channel;
g_return_if_fail (info != NULL);
g_return_if_fail (message != NULL);
sender = tp_asv_get_string (info, "Sender");
g_return_if_fail (sender != NULL);
channel = get_text_channel (self, sender, 0, 0);
g_return_if_fail (channel != NULL);
receive_text (self, channel, message, info, 0);
}
static void
channel_prepared_cb (
GObject *source,
GAsyncResult *result,
gpointer user_data)
{
TpFileTransferChannel *channel = TP_FILE_TRANSFER_CHANNEL (source);
CallbacksData *cb_data = user_data;
EmpathyFTHandler *handler = cb_data->handler;
EmpathyFTHandlerPriv *priv = handler->priv;
GHashTable *properties;
GError *error = NULL;
if (!tp_proxy_prepare_finish (channel, result, &error))
{
if (!g_cancellable_is_cancelled (priv->cancellable))
g_cancellable_cancel (priv->cancellable);
cb_data->callback (handler, error, cb_data->user_data);
g_clear_error (&error);
callbacks_data_free (cb_data);
return;
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
properties = tp_channel_borrow_immutable_properties (TP_CHANNEL (channel));
#pragma GCC diagnostic pop
priv->content_hash = g_strdup (
tp_asv_get_string (properties, "ContentHash"));
priv->content_hash_type = tp_asv_get_uint32 (
properties, "ContentHashType", NULL);
priv->contact = g_object_ref (tp_channel_get_target_contact (TP_CHANNEL (channel)));
cb_data->callback (handler, NULL, cb_data->user_data);
}
static void
receive_text (RingTextManager *self,
RingTextChannel *channel,
gchar const *message,
GHashTable *info,
guint32 sms_class)
{
char const *sent;
char *token;
gint64 message_sent;
gint64 message_received = (gint64) time(NULL);
sent = tp_asv_get_string (info, "SentTime");
if (sent)
message_sent = modem_sms_parse_time (sent);
else
message_sent = message_received;
token = generate_token ();
ring_text_channel_receive_text (channel,
token, message, message_sent, message_received, sms_class);
g_free (token);
}
static void
tls_certificate_got_all_cb (TpProxy *proxy,
GHashTable *properties,
const GError *error,
gpointer user_data,
GObject *weak_object)
{
GPtrArray *cert_data;
EmpathyTLSCertificate *self = EMPATHY_TLS_CERTIFICATE (weak_object);
EmpathyTLSCertificatePriv *priv = GET_PRIV (self);
if (error != NULL)
{
g_simple_async_result_set_from_error (priv->async_prepare_res, error);
g_simple_async_result_complete (priv->async_prepare_res);
tp_clear_object (&priv->async_prepare_res);
return;
}
priv->cert_type = g_strdup (tp_asv_get_string (properties,
"CertificateType"));
priv->state = tp_asv_get_uint32 (properties, "State", NULL);
cert_data = tp_asv_get_boxed (properties, "CertificateChainData",
TP_ARRAY_TYPE_UCHAR_ARRAY_LIST);
g_assert (cert_data != NULL);
priv->cert_data = g_boxed_copy (TP_ARRAY_TYPE_UCHAR_ARRAY_LIST, cert_data);
DEBUG ("Got a certificate chain long %u, of type %s",
priv->cert_data->len, priv->cert_type);
priv->is_prepared = TRUE;
g_simple_async_result_complete (priv->async_prepare_res);
tp_clear_object (&priv->async_prepare_res);
}
static TpBaseConnection *
new_connection (TpBaseProtocol *protocol,
GHashTable *asv,
GError **error)
{
ExampleContactListConnection *conn;
const gchar *account;
guint sim_delay;
account = tp_asv_get_string (asv, "account");
/* telepathy-glib checked this for us */
g_assert (account != NULL);
sim_delay = tp_asv_get_uint32 (asv, "simulation-delay", NULL);
conn = EXAMPLE_CONTACT_LIST_CONNECTION (
g_object_new (EXAMPLE_TYPE_CONTACT_LIST_CONNECTION,
"account", account,
"protocol", tp_base_protocol_get_name (protocol),
"simulation-delay", sim_delay,
NULL));
return (TpBaseConnection *) conn;
}
static gboolean
set_content_hash_type_from_classes (EmpathyFTHandler *handler,
GPtrArray *classes)
{
GArray *possible_values;
guint value;
gboolean valid;
EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
gboolean support_ft = FALSE;
guint i;
possible_values = g_array_new (TRUE, TRUE, sizeof (guint));
for (i = 0; i < classes->len; i++)
{
GHashTable *fixed;
GStrv allowed;
const gchar *chan_type;
tp_value_array_unpack (g_ptr_array_index (classes, i), 2,
&fixed, &allowed);
chan_type = tp_asv_get_string (fixed, TP_PROP_CHANNEL_CHANNEL_TYPE);
if (tp_strdiff (chan_type, TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER))
continue;
if (tp_asv_get_uint32 (fixed, TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, NULL) !=
TP_HANDLE_TYPE_CONTACT)
continue;
support_ft = TRUE;
value = tp_asv_get_uint32
(fixed, TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_CONTENT_HASH_TYPE,
&valid);
if (valid)
g_array_append_val (possible_values, value);
}
if (!support_ft)
{
g_array_free (possible_values, TRUE);
return FALSE;
}
if (possible_values->len == 0)
{
/* there are no channel classes with hash support, disable it. */
priv->use_hash = FALSE;
priv->content_hash_type = TP_FILE_HASH_TYPE_NONE;
goto out;
}
priv->use_hash = TRUE;
if (possible_values->len == 1)
{
priv->content_hash_type = g_array_index (possible_values, guint, 0);
}
else
{
/* order the array and pick the first non zero, so that MD5
* is the preferred value.
*/
g_array_sort (possible_values, empathy_uint_compare);
if (g_array_index (possible_values, guint, 0) == 0)
priv->content_hash_type = g_array_index (possible_values, guint, 1);
else
priv->content_hash_type = g_array_index (possible_values, guint, 0);
}
out:
g_array_free (possible_values, TRUE);
DEBUG ("Hash enabled %s; setting content hash type as %u",
priv->use_hash ? "True" : "False", priv->content_hash_type);
return TRUE;
}
static gchar *
reason_to_string (EmpathyTLSDialog *self)
{
GString *str;
const gchar *reason_str;
EmpTLSCertificateRejectReason reason;
GHashTable *details;
EmpathyTLSDialogPriv *priv = GET_PRIV (self);
str = g_string_new (NULL);
reason = priv->reason;
details = priv->details;
g_string_append (str, _("The identity provided by the chat server cannot be "
"verified."));
g_string_append (str, "\n\n");
switch (reason)
{
case EMP_TLS_CERTIFICATE_REJECT_REASON_UNTRUSTED:
reason_str = _("The certificate is not signed by a Certification "
"Authority.");
break;
case EMP_TLS_CERTIFICATE_REJECT_REASON_EXPIRED:
reason_str = _("The certificate has expired.");
break;
case EMP_TLS_CERTIFICATE_REJECT_REASON_NOT_ACTIVATED:
reason_str = _("The certificate hasn't yet been activated.");
break;
case EMP_TLS_CERTIFICATE_REJECT_REASON_FINGERPRINT_MISMATCH:
reason_str = _("The certificate does not have the expected fingerprint.");
break;
case EMP_TLS_CERTIFICATE_REJECT_REASON_HOSTNAME_MISMATCH:
reason_str = _("The hostname verified by the certificate doesn't match "
"the server name.");
break;
case EMP_TLS_CERTIFICATE_REJECT_REASON_SELF_SIGNED:
reason_str = _("The certificate is self-signed.");
break;
case EMP_TLS_CERTIFICATE_REJECT_REASON_REVOKED:
reason_str = _("The certificate has been revoked by the issuing "
"Certification Authority.");
break;
case EMP_TLS_CERTIFICATE_REJECT_REASON_INSECURE:
reason_str = _("The certificate is cryptographically weak.");
break;
case EMP_TLS_CERTIFICATE_REJECT_REASON_LIMIT_EXCEEDED:
reason_str = _("The certificate length exceeds verifiable limits.");
break;
case EMP_TLS_CERTIFICATE_REJECT_REASON_UNKNOWN:
default:
reason_str = _("The certificate is malformed.");
break;
}
g_string_append (str, reason_str);
/* add more information in case of HOSTNAME_MISMATCH */
if (reason == EMP_TLS_CERTIFICATE_REJECT_REASON_HOSTNAME_MISMATCH)
{
const gchar *expected_hostname, *certificate_hostname;
expected_hostname = tp_asv_get_string (details, "expected-hostname");
certificate_hostname = tp_asv_get_string (details,
"certificate-hostname");
if (expected_hostname != NULL && certificate_hostname != NULL)
{
g_string_append (str, "\n\n");
g_string_append_printf (str, _("Expected hostname: %s"),
expected_hostname);
g_string_append (str, "\n");
g_string_append_printf (str, _("Certificate hostname: %s"),
certificate_hostname);
}
}
return g_string_free (str, FALSE);
}
static void
preferences_themes_setup (EmpathyPreferences *preferences)
{
EmpathyPreferencesPriv *priv = GET_PRIV (preferences);
GtkComboBox *combo;
GtkCellLayout *cell_layout;
GtkCellRenderer *renderer;
GtkListStore *store;
const gchar **themes;
GList *adium_themes;
gint i;
preferences_theme_variants_setup (preferences);
combo = GTK_COMBO_BOX (priv->combobox_chat_theme);
cell_layout = GTK_CELL_LAYOUT (combo);
/* Create the model */
store = gtk_list_store_new (COL_THEME_COUNT,
G_TYPE_STRING, /* Display name */
G_TYPE_STRING, /* Theme name */
G_TYPE_BOOLEAN, /* Is an Adium theme */
G_TYPE_STRING, /* Adium theme path */
G_TYPE_HASH_TABLE); /* Adium theme info */
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
COL_THEME_VISIBLE_NAME, GTK_SORT_ASCENDING);
/* Fill the model */
themes = empathy_theme_manager_get_themes ();
for (i = 0; themes[i]; i += 2) {
gtk_list_store_insert_with_values (store, NULL, -1,
COL_THEME_VISIBLE_NAME, _(themes[i + 1]),
COL_THEME_NAME, themes[i],
COL_THEME_IS_ADIUM, FALSE,
-1);
}
adium_themes = empathy_theme_manager_get_adium_themes ();
while (adium_themes != NULL) {
GHashTable *info;
const gchar *name;
const gchar *path;
info = adium_themes->data;
name = tp_asv_get_string (info, "CFBundleName");
path = tp_asv_get_string (info, "path");
if (name != NULL && path != NULL) {
gtk_list_store_insert_with_values (store, NULL, -1,
COL_THEME_VISIBLE_NAME, name,
COL_THEME_NAME, "adium",
COL_THEME_IS_ADIUM, TRUE,
COL_THEME_ADIUM_PATH, path,
COL_THEME_ADIUM_INFO, info,
-1);
}
g_hash_table_unref (info);
adium_themes = g_list_delete_link (adium_themes, adium_themes);
}
/* Add cell renderer */
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (cell_layout, renderer, TRUE);
gtk_cell_layout_set_attributes (cell_layout, renderer,
"text", COL_THEME_VISIBLE_NAME, NULL);
gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store));
g_object_unref (store);
g_signal_connect (combo, "changed",
G_CALLBACK (preferences_theme_changed_cb),
preferences);
/* Select the theme from the GSetting key and track changes */
preferences_theme_notify_cb (priv->gsettings_chat,
EMPATHY_PREFS_CHAT_THEME,
preferences);
g_signal_connect (priv->gsettings_chat,
"changed::" EMPATHY_PREFS_CHAT_THEME,
G_CALLBACK (preferences_theme_notify_cb),
preferences);
g_signal_connect (priv->gsettings_chat,
"changed::" EMPATHY_PREFS_CHAT_ADIUM_PATH,
G_CALLBACK (preferences_theme_notify_cb),
preferences);
}
void idle_text_send(GObject *obj, TpMessage *message, TpMessageSendingFlags flags, const gchar *recipient, IdleConnection *conn) {
GError *error = NULL;
const GHashTable *part;
TpChannelTextMessageType type = TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL;
gboolean result = TRUE;
const gchar *content_type, *text;
guint n_parts;
GStrv messages;
GStrv bodies;
gsize msg_len;
guint i;
#define INVALID_ARGUMENT(msg, ...) \
G_STMT_START { \
IDLE_DEBUG (msg , ## __VA_ARGS__); \
g_set_error (&error, TP_ERROR, TP_ERROR_INVALID_ARGUMENT, \
msg , ## __VA_ARGS__); \
goto failed; \
} G_STMT_END
g_return_if_fail (recipient != NULL);
part = tp_message_peek (message, 0);
if (tp_asv_lookup (part, "message-type") != NULL)
type = tp_asv_get_uint32 (part, "message-type", &result);
if (!result)
INVALID_ARGUMENT ("message-type must be a 32-bit unsigned integer");
if (type >= NUM_TP_CHANNEL_TEXT_MESSAGE_TYPES)
INVALID_ARGUMENT ("invalid message type: %u", type);
n_parts = tp_message_count_parts (message);
if (n_parts != 2)
INVALID_ARGUMENT ("message must contain exactly 1 part, not %u", (n_parts - 1));
part = tp_message_peek (message, 1);
content_type = tp_asv_get_string (part, "content-type");
text = tp_asv_get_string (part, "content");
if (tp_strdiff (content_type, "text/plain"))
INVALID_ARGUMENT ("message must be text/plain");
if (tp_str_empty (text))
INVALID_ARGUMENT ("content must be a UTF-8 string");
/* Okay, it's valid. Let's send it. */
msg_len = idle_connection_get_max_message_length(conn);
messages = idle_text_encode_and_split(type, recipient, text, msg_len, &bodies, &error);
if (messages == NULL)
goto failed;
for(i = 0; messages[i] != NULL; i++) {
g_assert(bodies[i] != NULL);
idle_connection_send(conn, messages[i]);
}
g_strfreev(messages);
g_strfreev(bodies);
tp_message_mixin_sent (obj, message, flags, "", NULL);
return;
failed:
g_assert (error != NULL);
tp_message_mixin_sent (obj, message, 0, NULL, error);
g_error_free (error);
}