static PurpleBuddyIcon *
purple_buddy_icon_create(PurpleAccount *account, const char *username)
{
PurpleBuddyIcon *icon;
GHashTable *icon_cache;
/* This does not zero. See purple_buddy_icon_new() for
* information on which function allocates which member. */
icon = g_slice_new(PurpleBuddyIcon);
PURPLE_DBUS_REGISTER_POINTER(icon, PurpleBuddyIcon);
icon->account = account;
icon->username = g_strdup(username);
icon->checksum = NULL;
icon->ref_count = 1;
icon_cache = g_hash_table_lookup(account_cache, account);
if (icon_cache == NULL)
{
icon_cache = g_hash_table_new(g_str_hash, g_str_equal);
g_hash_table_insert(account_cache, account, icon_cache);
}
g_hash_table_insert(icon_cache,
(char *)purple_buddy_icon_get_username(icon), icon);
return icon;
}
void
_purple_connection_new_unregister(PurpleAccount *account, const char *password, PurpleAccountUnregistrationCb cb, void *user_data)
{
/* Lots of copy/pasted code to avoid API changes. You might want to integrate that into the previous function when posssible. */
PurpleConnection *gc;
PurplePlugin *prpl;
PurplePluginProtocolInfo *prpl_info;
g_return_if_fail(account != NULL);
prpl = purple_find_prpl(purple_account_get_protocol_id(account));
if (prpl != NULL)
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
else {
gchar *message;
message = g_strdup_printf(_("Missing protocol plugin for %s"),
purple_account_get_username(account));
purple_notify_error(NULL, _("Unregistration Error"), message, NULL);
g_free(message);
return;
}
if (!purple_account_is_disconnected(account)) {
prpl_info->unregister_user(account, cb, user_data);
return;
}
if (((password == NULL) || (*password == '\0')) &&
!(prpl_info->options & OPT_PROTO_NO_PASSWORD) &&
!(prpl_info->options & OPT_PROTO_PASSWORD_OPTIONAL))
{
purple_debug_error("connection", "Cannot connect to account %s without "
"a password.\n", purple_account_get_username(account));
return;
}
gc = g_new0(PurpleConnection, 1);
PURPLE_DBUS_REGISTER_POINTER(gc, PurpleConnection);
gc->prpl = prpl;
if ((password != NULL) && (*password != '\0'))
gc->password = g_strdup(password);
purple_connection_set_account(gc, account);
purple_connection_set_state(gc, PURPLE_CONNECTING);
connections = g_list_append(connections, gc);
purple_account_set_connection(account, gc);
purple_signal_emit(purple_connections_get_handle(), "signing-on", gc);
purple_debug_info("connection", "Unregistering. gc = %p\n", gc);
prpl_info->unregister_user(account, cb, user_data);
}
PurpleNotifyUserInfo *
purple_notify_user_info_new()
{
PurpleNotifyUserInfo *user_info;
user_info = g_new0(PurpleNotifyUserInfo, 1);
PURPLE_DBUS_REGISTER_POINTER(user_info, PurpleNotifyUserInfo);
g_queue_init(&user_info->entries);
return user_info;
}
static xmlnode*
new_node(const char *name, XMLNodeType type)
{
xmlnode *node = g_new0(xmlnode, 1);
node->name = g_strdup(name);
node->type = type;
PURPLE_DBUS_REGISTER_POINTER(node, xmlnode);
return node;
}
PurpleNotifyUserInfoEntry *
purple_notify_user_info_entry_new(const char *label, const char *value)
{
PurpleNotifyUserInfoEntry *user_info_entry;
user_info_entry = g_new0(PurpleNotifyUserInfoEntry, 1);
PURPLE_DBUS_REGISTER_POINTER(user_info_entry, PurpleNotifyUserInfoEntry);
user_info_entry->label = g_strdup(label);
user_info_entry->value = g_strdup(value);
user_info_entry->type = PURPLE_NOTIFY_USER_INFO_ENTRY_PAIR;
return user_info_entry;
}
static void
purple_smiley_list_init(GTypeInstance *instance, gpointer klass)
{
PurpleSmileyList *sl = PURPLE_SMILEY_LIST(instance);
PurpleSmileyListPrivate *priv = PURPLE_SMILEY_LIST_GET_PRIVATE(sl);
priv->trie = purple_trie_new();
priv->path_map = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, NULL);
priv->shortcut_map = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, NULL);
PURPLE_DBUS_REGISTER_POINTER(sl, PurpleSmileyList);
}
PurplePlugin *
purple_plugin_new(gboolean native, const char *path)
{
PurplePlugin *plugin;
plugin = g_new0(PurplePlugin, 1);
plugin->native_plugin = native;
plugin->path = g_strdup(path);
PURPLE_DBUS_REGISTER_POINTER(plugin, PurplePlugin);
return plugin;
}
void
purple_keyring_register(PurpleKeyring *keyring)
{
const gchar *keyring_id;
g_return_if_fail(keyring != NULL);
keyring_id = purple_keyring_get_id(keyring);
purple_debug_info("keyring", "Registering keyring: %s\n",
keyring_id ? keyring_id : "(null)");
if (purple_keyring_get_id(keyring) == NULL ||
purple_keyring_get_name(keyring) == NULL ||
purple_keyring_get_read_password(keyring) == NULL ||
purple_keyring_get_save_password(keyring) == NULL)
{
purple_debug_error("keyring", "Cannot register %s, some "
"required fields are missing.\n",
keyring_id ? keyring_id : "(null)");
return;
}
if (purple_keyring_find_keyring_by_id(keyring_id) != NULL) {
purple_debug_error("keyring",
"Keyring is already registered.\n");
return;
}
/* If this is the configured keyring, use it. */
if (purple_keyring_inuse == NULL &&
g_strcmp0(keyring_id, purple_keyring_to_use) == 0)
{
purple_debug_misc("keyring", "Keyring %s matches keyring to "
"use, using it.", keyring_id);
purple_keyring_set_inuse(keyring, TRUE, NULL, NULL);
}
PURPLE_DBUS_REGISTER_POINTER(keyring, PurpleKeyring);
purple_signal_emit(purple_keyring_get_handle(), "keyring-register",
keyring_id, keyring);
if (purple_debug_is_verbose()) {
purple_debug_info("keyring", "Registered keyring: %s.\n",
keyring_id);
}
purple_keyring_keyrings = g_list_prepend(purple_keyring_keyrings,
keyring);
}
PurpleXfer *
purple_xfer_new(PurpleAccount *account, PurpleXferType type, const char *who)
{
PurpleXfer *xfer;
PurpleXferUiOps *ui_ops;
PurpleXferPrivData *priv;
g_return_val_if_fail(type != PURPLE_XFER_UNKNOWN, NULL);
g_return_val_if_fail(account != NULL, NULL);
g_return_val_if_fail(who != NULL, NULL);
xfer = g_new0(PurpleXfer, 1);
PURPLE_DBUS_REGISTER_POINTER(xfer, PurpleXfer);
xfer->ref = 1;
xfer->type = type;
xfer->account = account;
xfer->who = g_strdup(who);
xfer->ui_ops = ui_ops = purple_xfers_get_ui_ops();
xfer->message = NULL;
xfer->current_buffer_size = FT_INITIAL_BUFFER_SIZE;
xfer->fd = -1;
priv = g_new0(PurpleXferPrivData, 1);
priv->ready = PURPLE_XFER_READY_NONE;
if (ui_ops && ui_ops->data_not_sent) {
/* If the ui will handle unsent data no need for buffer */
priv->buffer = NULL;
} else {
priv->buffer = g_byte_array_sized_new(FT_INITIAL_BUFFER_SIZE);
}
g_hash_table_insert(xfers_data, xfer, priv);
ui_ops = purple_xfer_get_ui_ops(xfer);
if (ui_ops != NULL && ui_ops->new_xfer != NULL)
ui_ops->new_xfer(xfer);
xfers = g_list_prepend(xfers, xfer);
if (purple_debug_is_verbose())
purple_debug_info("xfer", "new %p [%d]\n", xfer, xfer->ref);
return xfer;
}
PurpleStoredImage *
purple_imgstore_add(gpointer data, size_t size, const char *filename)
{
PurpleStoredImage *img;
g_return_val_if_fail(data != NULL, NULL);
g_return_val_if_fail(size > 0, NULL);
img = g_new(PurpleStoredImage, 1);
PURPLE_DBUS_REGISTER_POINTER(img, PurpleStoredImage);
img->data = data;
img->size = size;
img->filename = g_strdup(filename);
img->refcount = 1;
img->id = 0;
return img;
}
PurpleCipher *
purple_ciphers_register_cipher(const gchar *name, PurpleCipherOps *ops) {
PurpleCipher *cipher = NULL;
g_return_val_if_fail(name, NULL);
g_return_val_if_fail(ops, NULL);
g_return_val_if_fail(!purple_ciphers_find_cipher(name), NULL);
cipher = g_new0(PurpleCipher, 1);
PURPLE_DBUS_REGISTER_POINTER(cipher, PurpleCipher);
cipher->name = g_strdup(name);
cipher->ops = ops;
ciphers = g_list_append(ciphers, cipher);
purple_signal_emit(purple_ciphers_get_handle(), "cipher-added", cipher);
return cipher;
}
static gboolean
plugin_load(PurplePlugin *plugin)
{
PURPLE_DBUS_RETURN_FALSE_IF_DISABLED(plugin);
/* First, we have to register our four exported functions with the
main purple dbus loop. Without this statement, the purple dbus
code wouldn't know about our functions. */
PURPLE_DBUS_REGISTER_BINDINGS(plugin);
/* Then, we register the hello object of type PurpleText. Note that
pointer registrations / unregistrations are completely dynamic;
they don't have to be made when the plugin is loaded /
unloaded. Without this statement the dbus purple code wouldn't
know about the hello object. */
PURPLE_DBUS_REGISTER_POINTER(&hello, PurpleText);
hello.text = g_strdup("Hello.");
return TRUE;
}
PurpleXfer *
purple_xfer_new(PurpleAccount *account, PurpleXferType type, const char *who)
{
PurpleXfer *xfer;
PurpleXferUiOps *ui_ops;
PurpleXferPrivData *priv;
g_return_val_if_fail(type != PURPLE_XFER_UNKNOWN, NULL);
g_return_val_if_fail(account != NULL, NULL);
g_return_val_if_fail(who != NULL, NULL);
xfer = g_new0(PurpleXfer, 1);
PURPLE_DBUS_REGISTER_POINTER(xfer, PurpleXfer);
xfer->ref = 1;
xfer->type = type;
xfer->account = account;
xfer->who = g_strdup(who);
xfer->ui_ops = purple_xfers_get_ui_ops();
xfer->message = NULL;
xfer->current_buffer_size = FT_INITIAL_BUFFER_SIZE;
xfer->fd = -1;
priv = g_new0(PurpleXferPrivData, 1);
priv->ready = PURPLE_XFER_READY_NONE;
g_hash_table_insert(xfers_data, xfer, priv);
ui_ops = purple_xfer_get_ui_ops(xfer);
if (ui_ops != NULL && ui_ops->new_xfer != NULL)
ui_ops->new_xfer(xfer);
xfers = g_list_prepend(xfers, xfer);
return xfer;
}
static void
purple_smiley_init(GTypeInstance *instance, gpointer klass)
{
PurpleSmiley *smiley = PURPLE_SMILEY(instance);
PURPLE_DBUS_REGISTER_POINTER(smiley, PurpleSmiley);
}
void
_purple_connection_new(PurpleAccount *account, gboolean regist, const char *password)
{
PurpleConnection *gc;
PurplePlugin *prpl;
PurplePluginProtocolInfo *prpl_info;
g_return_if_fail(account != NULL);
if (!purple_account_is_disconnected(account))
return;
prpl = purple_find_prpl(purple_account_get_protocol_id(account));
if (prpl != NULL)
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
else {
gchar *message;
message = g_strdup_printf(_("Missing protocol plugin for %s"),
purple_account_get_username(account));
purple_notify_error(NULL, regist ? _("Registration Error") :
_("Connection Error"), message, NULL);
g_free(message);
return;
}
if (regist)
{
if (prpl_info->register_user == NULL)
return;
}
else
{
if (((password == NULL) || (*password == '\0')) &&
!(prpl_info->options & OPT_PROTO_NO_PASSWORD) &&
!(prpl_info->options & OPT_PROTO_PASSWORD_OPTIONAL))
{
purple_debug_error("connection", "Cannot connect to account %s without "
"a password.\n", purple_account_get_username(account));
return;
}
}
gc = g_new0(PurpleConnection, 1);
PURPLE_DBUS_REGISTER_POINTER(gc, PurpleConnection);
gc->prpl = prpl;
if ((password != NULL) && (*password != '\0'))
gc->password = g_strdup(password);
purple_connection_set_account(gc, account);
purple_connection_set_state(gc, PURPLE_CONNECTING);
connections = g_list_append(connections, gc);
purple_account_set_connection(account, gc);
purple_signal_emit(purple_connections_get_handle(), "signing-on", gc);
if (regist)
{
purple_debug_info("connection", "Registering. gc = %p\n", gc);
/* set this so we don't auto-reconnect after registering */
gc->wants_to_die = TRUE;
prpl_info->register_user(account);
}
else
{
purple_debug_info("connection", "Connecting. gc = %p\n", gc);
purple_signal_emit(purple_accounts_get_handle(), "account-connecting", account);
prpl_info->login(account);
}
}
/**************************************************************************
* GObject stuff
**************************************************************************/
static void
purple_protocol_init(GTypeInstance *instance, gpointer klass)
{
PURPLE_DBUS_REGISTER_POINTER(PURPLE_PROTOCOL(instance), PurpleProtocol);
}
