void
translate_sending_chat_message_cb(const gchar *original_phrase, const gchar *translated_phrase, const gchar *detected_language, gpointer userdata)
{
struct TranslateConvMessage *convmsg = userdata;
gchar *html_text;
int err = 0;
html_text = purple_strdup_withhtml(translated_phrase);
err = serv_chat_send(purple_account_get_connection(convmsg->account), purple_conv_chat_get_id(PURPLE_CONV_CHAT(convmsg->conv)), html_text, convmsg->flags);
g_free(html_text);
html_text = purple_strdup_withhtml(original_phrase);
//if (err > 0)
//{
// purple_conversation_write(convmsg->conv, convmsg->sender, html_text, convmsg->flags, time(NULL));
//}
purple_signal_emit(purple_conversations_get_handle(), "sent-chat-msg",
convmsg->account, html_text,
purple_conv_chat_get_id(PURPLE_CONV_CHAT(convmsg->conv)));
g_free(html_text);
g_free(convmsg->sender);
g_free(convmsg);
}
static int waprpl_send_chat(PurpleConnection * gc, int id, const char *message, PurpleMessageFlags flags)
{
whatsapp_connection *wconn = purple_connection_get_protocol_data(gc);
PurpleAccount *account = purple_connection_get_account(gc);
PurpleConversation *convo = purple_find_chat(gc, id);
PurpleChat *ch = blist_find_chat_by_convo(gc, id);
GHashTable *hasht = purple_chat_get_components(ch);
char *chat_id = g_hash_table_lookup(hasht, "id");
char *plain;
purple_markup_html_to_xhtml(message, NULL, &plain);
char msgid[128];
waAPI_getmsgid(wconn->waAPI, msgid);
purple_signal_emit(purple_connection_get_prpl(gc), "whatsapp-sending-message", gc, msgid, chat_id, message);
waAPI_sendchat(wconn->waAPI, msgid, chat_id, plain);
g_free(plain);
waprpl_check_output(gc);
const char *me = purple_account_get_string(account, "nick", "");
purple_conv_chat_write(PURPLE_CONV_CHAT(convo), me, message, PURPLE_MESSAGE_SEND, time(NULL));
return 1;
}
static void
hide_conv(PidginConversation *gtkconv, gboolean closetimer)
{
GList *list;
purple_signal_emit(pidgin_conversations_get_handle(),
"conversation-hiding", gtkconv);
for (list = g_list_copy(gtkconv->convs); list; list = g_list_delete_link(list, list)) {
PurpleConversation *conv = list->data;
if (closetimer) {
guint timer = GPOINTER_TO_INT(purple_conversation_get_data(conv, "close-timer"));
if (timer)
purple_timeout_remove(timer);
timer = purple_timeout_add_seconds(CLOSE_CONV_TIMEOUT_SECS, close_already, conv);
purple_conversation_set_data(conv, "close-timer", GINT_TO_POINTER(timer));
}
#if 0
/* I will miss you */
purple_conversation_set_ui_ops(conv, NULL);
#else
pidgin_conv_window_remove_gtkconv(gtkconv->win, gtkconv);
pidgin_conv_window_add_gtkconv(hidden_convwin, gtkconv);
#endif
}
}
void
purple_keyring_unregister(PurpleKeyring *keyring)
{
PurpleKeyring *inuse;
PurpleKeyring *fallback;
const gchar *keyring_id;
g_return_if_fail(keyring != NULL);
keyring_id = purple_keyring_get_id(keyring);
purple_debug_info("keyring", "Unregistering keyring: %s.\n",
keyring_id);
purple_signal_emit(purple_keyring_get_handle(), "keyring-unregister",
keyring_id, keyring);
PURPLE_DBUS_UNREGISTER_POINTER(keyring);
inuse = purple_keyring_get_inuse();
fallback = purple_keyring_find_keyring_by_id(PURPLE_DEFAULT_KEYRING);
if (inuse == keyring) {
if (inuse != fallback) {
purple_keyring_set_inuse(fallback, TRUE, NULL, NULL);
} else {
fallback = NULL;
purple_keyring_set_inuse(NULL, TRUE, NULL, NULL);
}
}
purple_keyring_keyrings = g_list_remove(purple_keyring_keyrings,
keyring);
}
void
purple_prpl_got_user_login_time(PurpleAccount *account, const char *name,
time_t login_time)
{
GSList *list;
PurplePresence *presence;
g_return_if_fail(account != NULL);
g_return_if_fail(name != NULL);
if ((list = purple_find_buddies(account, name)) == NULL)
return;
if (login_time == 0)
login_time = time(NULL);
while (list) {
PurpleBuddy *buddy = list->data;
presence = purple_buddy_get_presence(buddy);
list = g_slist_delete_link(list, list);
if (purple_presence_get_login_time(presence) != login_time)
{
purple_presence_set_login_time(presence, login_time);
purple_signal_emit(purple_blist_get_handle(), "buddy-got-login-time", buddy);
}
}
}
void
purple_prpl_got_media_caps(PurpleAccount *account, const char *name)
{
#ifdef USE_VV
GSList *list;
g_return_if_fail(account != NULL);
g_return_if_fail(name != NULL);
if ((list = purple_find_buddies(account, name)) == NULL)
return;
while (list) {
PurpleBuddy *buddy = list->data;
PurpleMediaCaps oldcaps = purple_buddy_get_media_caps(buddy);
PurpleMediaCaps newcaps = 0;
const gchar *bname = purple_buddy_get_name(buddy);
list = g_slist_delete_link(list, list);
newcaps = purple_prpl_get_media_caps(account, bname);
purple_buddy_set_media_caps(buddy, newcaps);
if (oldcaps == newcaps)
continue;
purple_signal_emit(purple_blist_get_handle(),
"buddy-caps-changed", buddy,
newcaps, oldcaps);
}
#endif
}
PurpleStoredImage *
purple_imgstore_unref(PurpleStoredImage *img)
{
if (img == NULL)
return NULL;
g_return_val_if_fail(img->refcount > 0, NULL);
img->refcount--;
if (img->refcount == 0)
{
purple_signal_emit(purple_imgstore_get_handle(),
"image-deleting", img);
if (img->id)
g_hash_table_remove(imgstore, &img->id);
g_free(img->data);
g_free(img->filename);
PURPLE_DBUS_UNREGISTER_POINTER(img);
g_free(img);
img = NULL;
}
return img;
}
void
purple_prpl_change_account_status(PurpleAccount *account,
PurpleStatus *old_status, PurpleStatus *new_status)
{
g_return_if_fail(account != NULL);
g_return_if_fail(new_status != NULL);
g_return_if_fail(!purple_status_is_exclusive(new_status) || old_status != NULL);
purple_signal_emit(purple_accounts_get_handle(), "account-status-changing",
account, old_status, new_status);
do_prpl_change_account_status(account, old_status, new_status);
purple_signal_emit(purple_accounts_get_handle(), "account-status-changed",
account, old_status, new_status);
}
int irc_cmd_ctcp_action(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
{
PurpleConnection *gc = purple_account_get_connection(irc->account);
char *action, *escaped, *dst, **newargs;
const char *src;
char *msg;
PurpleConversation *convo;
PurpleMessage *pmsg;
if (!args || !args[0] || !gc)
return 0;
convo = purple_conversations_find_with_account(target, irc->account);
msg = g_strdup_printf("/me %s", args[0]);
/* XXX: we'd prefer to keep this in conversation.c */
if (PURPLE_IS_IM_CONVERSATION(convo)) {
pmsg = purple_message_new_outgoing(
purple_conversation_get_name(convo), msg, 0);
purple_signal_emit(purple_conversations_get_handle(),
"sending-im-msg", irc->account, pmsg);
} else {
pmsg = purple_message_new_outgoing(NULL, msg, 0);
purple_signal_emit(purple_conversations_get_handle(),
"sending-chat-msg", irc->account, pmsg,
purple_chat_conversation_get_id(PURPLE_CHAT_CONVERSATION(convo)));
}
g_free(msg);
if (purple_message_is_empty(pmsg))
return 0;
msg = g_strdup(purple_message_get_contents(pmsg)); /* XXX: is it really necessary? */
if (strncmp(msg, "/me ", 4) != 0) {
newargs = g_new0(char *, 2);
newargs[0] = g_strdup(target);
newargs[1] = msg;
irc_cmd_privmsg(irc, cmd, target, (const char **)newargs);
g_free(newargs[0]);
g_free(newargs);
} else {
static void
purple_prpl_attention(PurpleConversation *conv, const char *who,
guint type, PurpleMessageFlags flags, time_t mtime)
{
PurpleAccount *account = purple_conversation_get_account(conv);
purple_signal_emit(purple_conversations_get_handle(),
flags == PURPLE_MESSAGE_SEND ? "sent-attention" : "got-attention",
account, who, conv, type);
}
void
purple_prpl_got_account_actions(PurpleAccount *account)
{
g_return_if_fail(account != NULL);
g_return_if_fail(purple_account_is_connected(account));
purple_signal_emit(purple_accounts_get_handle(), "account-actions-changed",
account);
}
static void
purple_xfer_set_status(PurpleXfer *xfer, PurpleXferStatusType status)
{
g_return_if_fail(xfer != NULL);
if (purple_debug_is_verbose())
purple_debug_info("xfer", "Changing status of xfer %p from %s to %s\n",
xfer, purple_xfer_status_type_to_string(xfer->status),
purple_xfer_status_type_to_string(status));
if (xfer->status == status)
return;
xfer->status = status;
if(xfer->type == PURPLE_XFER_SEND) {
switch(status) {
case PURPLE_XFER_STATUS_ACCEPTED:
purple_signal_emit(purple_xfers_get_handle(), "file-send-accept", xfer);
break;
case PURPLE_XFER_STATUS_STARTED:
purple_signal_emit(purple_xfers_get_handle(), "file-send-start", xfer);
break;
case PURPLE_XFER_STATUS_DONE:
purple_signal_emit(purple_xfers_get_handle(), "file-send-complete", xfer);
break;
case PURPLE_XFER_STATUS_CANCEL_LOCAL:
case PURPLE_XFER_STATUS_CANCEL_REMOTE:
purple_signal_emit(purple_xfers_get_handle(), "file-send-cancel", xfer);
break;
default:
break;
}
} else if(xfer->type == PURPLE_XFER_RECEIVE) {
switch(status) {
case PURPLE_XFER_STATUS_ACCEPTED:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-accept", xfer);
break;
case PURPLE_XFER_STATUS_STARTED:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-start", xfer);
break;
case PURPLE_XFER_STATUS_DONE:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-complete", xfer);
break;
case PURPLE_XFER_STATUS_CANCEL_LOCAL:
case PURPLE_XFER_STATUS_CANCEL_REMOTE:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-cancel", xfer);
break;
default:
break;
}
}
}
static void log_select_cb(GtkTreeSelection *sel, PidginLogViewer *viewer) {
GtkTreeIter iter;
GValue val;
GtkTreeModel *model = GTK_TREE_MODEL(viewer->treestore);
PurpleLog *log = NULL;
PurpleLogReadFlags flags;
char *read = NULL;
if (!gtk_tree_selection_get_selected(sel, &model, &iter))
return;
val.g_type = 0;
gtk_tree_model_get_value (model, &iter, 1, &val);
log = g_value_get_pointer(&val);
g_value_unset(&val);
if (log == NULL)
return;
pidgin_set_cursor(viewer->window, GDK_WATCH);
if (log->type != PURPLE_LOG_SYSTEM) {
char *title;
if (log->type == PURPLE_LOG_CHAT)
title = g_strdup_printf(_("<span size='larger' weight='bold'>Conversation in %s on %s</span>"),
log->name, log_get_date(log));
else
title = g_strdup_printf(_("<span size='larger' weight='bold'>Conversation with %s on %s</span>"),
log->name, log_get_date(log));
gtk_label_set_markup(GTK_LABEL(viewer->label), title);
g_free(title);
}
read = purple_log_read(log, &flags);
viewer->flags = flags;
gtk_imhtml_clear(GTK_IMHTML(viewer->imhtml));
gtk_imhtml_set_protocol_name(GTK_IMHTML(viewer->imhtml),
purple_account_get_protocol_name(log->account));
purple_signal_emit(pidgin_log_get_handle(), "log-displaying", viewer, log);
gtk_imhtml_append_text(GTK_IMHTML(viewer->imhtml), read,
GTK_IMHTML_NO_COMMENTS | GTK_IMHTML_NO_TITLE | GTK_IMHTML_NO_SCROLL |
((flags & PURPLE_LOG_READ_NO_NEWLINE) ? GTK_IMHTML_NO_NEWLINE : 0));
g_free(read);
if (viewer->search != NULL) {
gtk_imhtml_search_clear(GTK_IMHTML(viewer->imhtml));
g_idle_add(search_find_cb, viewer);
}
pidgin_clear_cursor(viewer->window);
}
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);
}
GList *
purple_blist_node_get_extended_menu(PurpleBlistNode *n)
{
GList *menu = NULL;
g_return_val_if_fail(n != NULL, NULL);
purple_signal_emit(purple_blist_get_handle(), "blist-node-extended-menu",
n, &menu);
return menu;
}
int irc_send_len(struct irc_conn *irc, const char *buf, int buflen)
{
int ret;
char *tosend = g_strdup(buf);
purple_signal_emit(_irc_plugin, "irc-sending-text", purple_account_get_connection(irc->account), &tosend);
if (tosend == NULL)
return 0;
if (!purple_strequal(tosend, buf)) {
buflen = strlen(tosend);
}
if (purple_debug_is_verbose()) {
char *clean = purple_utf8_salvage(tosend);
clean = g_strstrip(clean);
purple_debug_misc("irc", "<< %s\n", clean);
g_free(clean);
}
/* If we're not buffering writes, try to send immediately */
if (!irc->writeh)
ret = do_send(irc, tosend, buflen);
else {
ret = -1;
errno = EAGAIN;
}
/* purple_debug(PURPLE_DEBUG_MISC, "irc", "sent%s: %s",
irc->gsc ? " (ssl)" : "", tosend); */
if (ret <= 0 && errno != EAGAIN) {
PurpleConnection *gc = purple_account_get_connection(irc->account);
gchar *tmp = g_strdup_printf(_("Lost connection with server: %s"),
g_strerror(errno));
purple_connection_error_reason (gc,
PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
g_free(tmp);
} else if (ret < buflen) {
if (ret < 0)
ret = 0;
if (!irc->writeh)
irc->writeh = purple_input_add(
irc->gsc ? irc->gsc->fd : irc->fd,
PURPLE_INPUT_WRITE, irc_send_cb, irc);
purple_circ_buffer_append(irc->outbuf, tosend + ret,
buflen - ret);
}
g_free(tosend);
return ret;
}
static void
purple_xfer_set_status(PurpleXfer *xfer, PurpleXferStatusType status)
{
g_return_if_fail(xfer != NULL);
if (xfer->status == status)
return;
xfer->status = status;
if(xfer->type == PURPLE_XFER_SEND) {
switch(status) {
case PURPLE_XFER_STATUS_ACCEPTED:
purple_signal_emit(purple_xfers_get_handle(), "file-send-accept", xfer);
break;
case PURPLE_XFER_STATUS_STARTED:
purple_signal_emit(purple_xfers_get_handle(), "file-send-start", xfer);
break;
case PURPLE_XFER_STATUS_DONE:
purple_signal_emit(purple_xfers_get_handle(), "file-send-complete", xfer);
break;
case PURPLE_XFER_STATUS_CANCEL_LOCAL:
case PURPLE_XFER_STATUS_CANCEL_REMOTE:
purple_signal_emit(purple_xfers_get_handle(), "file-send-cancel", xfer);
break;
default:
break;
}
} else if(xfer->type == PURPLE_XFER_RECEIVE) {
switch(status) {
case PURPLE_XFER_STATUS_ACCEPTED:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-accept", xfer);
break;
case PURPLE_XFER_STATUS_STARTED:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-start", xfer);
break;
case PURPLE_XFER_STATUS_DONE:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-complete", xfer);
break;
case PURPLE_XFER_STATUS_CANCEL_LOCAL:
case PURPLE_XFER_STATUS_CANCEL_REMOTE:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-cancel", xfer);
break;
default:
break;
}
}
}
void
purple_connection_error_reason (PurpleConnection *gc,
PurpleConnectionError reason,
const char *description)
{
PurpleConnectionUiOps *ops;
g_return_if_fail(gc != NULL);
/* This sanity check relies on PURPLE_CONNECTION_ERROR_OTHER_ERROR
* being the last member of the PurpleConnectionError enum in
* connection.h; if other reasons are added after it, this check should
* be updated.
*/
if (reason > PURPLE_CONNECTION_ERROR_OTHER_ERROR) {
purple_debug_error("connection",
"purple_connection_error_reason: reason %u isn't a "
"valid reason\n", reason);
reason = PURPLE_CONNECTION_ERROR_OTHER_ERROR;
}
if (description == NULL) {
purple_debug_error("connection", "purple_connection_error_reason called with NULL description\n");
description = _("Unknown error");
}
/* If we've already got one error, we don't need any more */
if (gc->disconnect_timeout > 0)
return;
gc->wants_to_die = purple_connection_error_is_fatal (reason);
purple_debug_info("connection", "Connection error on %p (reason: %u description: %s)\n",
gc, reason, description);
ops = purple_connections_get_ui_ops();
if (ops != NULL)
{
if (ops->report_disconnect_reason != NULL)
ops->report_disconnect_reason (gc, reason, description);
if (ops->report_disconnect != NULL)
ops->report_disconnect (gc, description);
}
purple_signal_emit(purple_connections_get_handle(), "connection-error",
gc, reason, description);
gc->disconnect_timeout = purple_timeout_add(0, purple_connection_disconnect_cb,
purple_connection_get_account(gc));
}
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);
}
void *
purple_notify_emails(void *handle, size_t count, gboolean detailed,
const char **subjects, const char **froms,
const char **tos, const char **urls,
PurpleNotifyCloseCallback cb, gpointer user_data)
{
PurpleNotifyUiOps *ops;
if (count == 1) {
return purple_notify_email(handle,
(subjects == NULL ? NULL : *subjects),
(froms == NULL ? NULL : *froms),
(tos == NULL ? NULL : *tos),
(urls == NULL ? NULL : *urls),
cb, user_data);
}
ops = purple_notify_get_ui_ops();
if (ops != NULL && ops->notify_emails != NULL) {
void *ui_handle;
purple_signal_emit(purple_notify_get_handle(), "displaying-emails-notification",
subjects, froms, tos, urls, count);
ui_handle = ops->notify_emails(handle, count, detailed, subjects,
froms, tos, urls);
if (ui_handle != NULL) {
PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
info->type = PURPLE_NOTIFY_EMAILS;
info->handle = handle;
info->ui_handle = ui_handle;
info->cb = cb;
info->cb_user_data = user_data;
handles = g_list_append(handles, info);
return info->ui_handle;
}
}
if (cb != NULL)
cb(user_data);
return NULL;
}
void qq_sys_msg_write(qq_account* ac, LwqqMsgType m_t, const char* serv_id,
const char* msg, PurpleMessageFlags type, time_t t)
{
// ac->qq->dispatch(vp_func_2p,(CALLBACK_FUNC)sys_msg_write,ac->qq,system_msg_new(m_t,serv_id,ac,msg,type,t));
const char* local_id;
PurpleConversation* conv = find_conversation(m_t, serv_id, ac, &local_id);
if (conv) {
purple_conversation_write(conv, NULL, msg, type, t);
const char* signal = (m_t == LWQQ_MS_BUDDY_MSG || m_t == LWQQ_MS_SESS_MSG)
? "received-im-msg"
: "recieved-chat-msg";
purple_signal_emit(purple_conversations_get_handle(), signal, ac->account,
conv->name, msg, conv, type);
}
}
gboolean
purple_ciphers_unregister_cipher(PurpleCipher *cipher) {
g_return_val_if_fail(cipher, FALSE);
g_return_val_if_fail(cipher->ref == 0, FALSE);
purple_signal_emit(purple_ciphers_get_handle(), "cipher-removed", cipher);
ciphers = g_list_remove(ciphers, cipher);
g_free(cipher->name);
PURPLE_DBUS_UNREGISTER_POINTER(cipher);
g_free(cipher);
return TRUE;
}
void gaym_fetch_thumbnail_cb(PurpleUtilFetchUrlData *url_data, void *user_data, const gchar *pic_data,
gsize len, const gchar* error_message)
{
if (!user_data)
return;
struct gaym_fetch_thumbnail_data *d = user_data;
if (!pic_data) {
return;
}
if (!d->gc)
return;
if (len && !g_strrstr_len(pic_data, len, "Server Error")) {
purple_debug_misc("gaym","Setting buddy icon for %s\n",d->who);
//if(len<1024)
// len=1024;
void* new_pic_data=NULL;
purple_debug_misc("gaym","Short icon file, padding to 1024\n");
new_pic_data=g_malloc0(len);
memcpy(new_pic_data, pic_data, len);
purple_buddy_icon_new(d->gc->account, d->who, (void*)new_pic_data, len, NULL);
//g_free(new_pic_data);
//PurpleBuddyIcon *icon=purple_buddy_icons_find(d->gc->account,d->who, NULL);
//guint len;
//const guchar* data=purple_buddy_icon_get_data(icon, &len);
}
if (PURPLE_CONNECTION_IS_VALID(d->gc) && len) {
purple_signal_emit(purple_accounts_get_handle(), "info-updated",
d->gc->account, d->who);
/* if (purple_find_conversation_with_account(d->who, d->gc->account)) {
purple_debug_misc("fetch_thumbnail_cb","setting buddy icon\n");
purple_buddy_icons_set_for_user(purple_connection_get_account
(d->gc), d->who,
(void *) pic_data, len);
}*/
} else {
purple_debug_error("gaym", "Fetching buddy icon failed.\n");
}
g_free(d->who);
g_free(d);
purple_debug_misc("gaym","Finished buddy icon set callback\n");
}
gboolean
purple_privacy_permit_remove(PurpleAccount *account, const char *who,
gboolean local_only)
{
GSList *l;
const char *name;
PurpleBuddy *buddy;
char *del;
g_return_val_if_fail(account != NULL, FALSE);
g_return_val_if_fail(who != NULL, FALSE);
name = purple_normalize(account, who);
for (l = account->permit; l != NULL; l = l->next) {
if (!purple_utf8_strcasecmp(name, (char *)l->data))
break;
}
if (l == NULL)
return FALSE;
/* We should not free l->data just yet. There can be occasions where
* l->data == who. In such cases, freeing l->data here can cause crashes
* later when who is used. */
del = l->data;
account->permit = g_slist_delete_link(account->permit, l);
if (!local_only && purple_account_is_connected(account))
serv_rem_permit(purple_account_get_connection(account), who);
if (privacy_ops != NULL && privacy_ops->permit_removed != NULL)
privacy_ops->permit_removed(account, who);
purple_blist_schedule_save();
buddy = purple_find_buddy(account, name);
if (buddy != NULL) {
purple_signal_emit(purple_blist_get_handle(),
"buddy-privacy-changed", buddy);
}
g_free(del);
return TRUE;
}
static int waprpl_send_im(PurpleConnection * gc, const char *who, const char *message, PurpleMessageFlags flags)
{
whatsapp_connection *wconn = purple_connection_get_protocol_data(gc);
char *plain;
purple_markup_html_to_xhtml(message, NULL, &plain);
char msgid[128];
waAPI_getmsgid(wconn->waAPI, msgid);
purple_signal_emit(purple_connection_get_prpl(gc), "whatsapp-sending-message", gc, msgid, who, message);
waAPI_sendim(wconn->waAPI, msgid, who, plain);
g_free(plain);
waprpl_check_output(gc);
return 1;
}
gboolean
purple_privacy_deny_remove(PurpleAccount *account, const char *who,
gboolean local_only)
{
GSList *l;
const char *normalized;
char *name;
PurpleBuddy *buddy;
g_return_val_if_fail(account != NULL, FALSE);
g_return_val_if_fail(who != NULL, FALSE);
normalized = purple_normalize(account, who);
for (l = account->deny; l != NULL; l = l->next) {
if (!purple_utf8_strcasecmp(normalized, (char *)l->data))
break;
}
buddy = purple_find_buddy(account, normalized);
if (l == NULL)
return FALSE;
name = l->data;
account->deny = g_slist_delete_link(account->deny, l);
if (!local_only && purple_account_is_connected(account))
serv_rem_deny(purple_account_get_connection(account), name);
if (privacy_ops != NULL && privacy_ops->deny_removed != NULL)
privacy_ops->deny_removed(account, who);
if (buddy != NULL) {
purple_signal_emit(purple_blist_get_handle(),
"buddy-privacy-changed", buddy);
}
g_free(name);
purple_blist_schedule_save();
return TRUE;
}
gboolean
purple_privacy_permit_add(PurpleAccount *account, const char *who,
gboolean local_only)
{
GSList *l;
char *name;
PurpleBuddy *buddy;
g_return_val_if_fail(account != NULL, FALSE);
g_return_val_if_fail(who != NULL, FALSE);
name = g_strdup(purple_normalize(account, who));
for (l = account->permit; l != NULL; l = l->next) {
if (!purple_utf8_strcasecmp(name, (char *)l->data))
break;
}
if (l != NULL)
{
g_free(name);
return FALSE;
}
account->permit = g_slist_append(account->permit, name);
if (!local_only && purple_account_is_connected(account))
serv_add_permit(purple_account_get_connection(account), who);
if (privacy_ops != NULL && privacy_ops->permit_added != NULL)
privacy_ops->permit_added(account, who);
purple_blist_schedule_save();
/* This lets the UI know a buddy has had its privacy setting changed */
buddy = purple_find_buddy(account, name);
if (buddy != NULL) {
purple_signal_emit(purple_blist_get_handle(),
"buddy-privacy-changed", buddy);
}
return TRUE;
}
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;
}
void
purple_xfer_request(PurpleXfer *xfer)
{
g_return_if_fail(xfer != NULL);
g_return_if_fail(xfer->ops.init != NULL);
purple_xfer_ref(xfer);
if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE)
{
purple_signal_emit(purple_xfers_get_handle(), "file-recv-request", xfer);
if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL)
{
/* The file-transfer was cancelled by a plugin */
purple_xfer_cancel_local(xfer);
}
else if (purple_xfer_get_filename(xfer) ||
purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_ACCEPTED)
{
gchar* message = NULL;
PurpleBuddy *buddy = purple_find_buddy(xfer->account, xfer->who);
message = g_strdup_printf(_("%s is offering to send file %s"),
buddy ? purple_buddy_get_alias(buddy) : xfer->who, purple_xfer_get_filename(xfer));
purple_xfer_conversation_write_with_thumbnail(xfer, message);
g_free(message);
/* Ask for a filename to save to if it's not already given by a plugin */
if (xfer->local_filename == NULL)
purple_xfer_ask_recv(xfer);
}
else
{
purple_xfer_ask_accept(xfer);
}
}
else
{
purple_xfer_choose_file(xfer);
}
}
int irc_send(struct irc_conn *irc, const char *buf)
{
int ret, buflen;
char *tosend= g_strdup(buf);
purple_signal_emit(_irc_plugin, "irc-sending-text", purple_account_get_connection(irc->account), &tosend);
if (tosend == NULL)
return 0;
buflen = strlen(tosend);
/* If we're not buffering writes, try to send immediately */
if (!irc->writeh)
ret = do_send(irc, tosend, buflen);
else {
ret = -1;
errno = EAGAIN;
}
/* purple_debug(PURPLE_DEBUG_MISC, "irc", "sent%s: %s",
irc->gsc ? " (ssl)" : "", tosend); */
if (ret <= 0 && errno != EAGAIN) {
purple_connection_error(purple_account_get_connection(irc->account),
_("Server has disconnected"));
} else if (ret < buflen) {
if (ret < 0)
ret = 0;
if (!irc->writeh)
irc->writeh = purple_input_add(
irc->gsc ? irc->gsc->fd : irc->fd,
PURPLE_INPUT_WRITE, irc_send_cb, irc);
purple_circ_buffer_append(irc->outbuf, tosend + ret,
buflen - ret);
}
g_free(tosend);
return ret;
}
