void
skypeweb_do_all_the_things(SkypeWebAccount *sa)
{
if (!sa->username) {
skypeweb_get_self_details(sa);
} else
if (sa->registration_token) {
skypeweb_get_self_details(sa);
if (sa->authcheck_timeout)
purple_timeout_remove(sa->authcheck_timeout);
skypeweb_check_authrequests(sa);
sa->authcheck_timeout = purple_timeout_add_seconds(120, (GSourceFunc)skypeweb_check_authrequests, sa);
purple_connection_set_state(sa->pc, PURPLE_CONNECTION_CONNECTED);
skypeweb_get_friend_list(sa);
skypeweb_poll(sa);
skype_web_get_offline_history(sa);
skypeweb_set_status(sa->account, purple_account_get_active_status(sa->account));
} else {
//Too soon!
skypeweb_get_registration_token(sa);
}
}
static gboolean
purple_sound_play_required(const PurpleAccount *account)
{
gint pref_status = purple_prefs_get_int("/purple/sound/while_status");
if (pref_status == PURPLE_SOUND_STATUS_ALWAYS)
{
/* Play sounds: Always */
return TRUE;
}
if (account != NULL)
{
PurpleStatus *status = purple_account_get_active_status(account);
if (purple_status_is_online(status))
{
gboolean available = purple_status_is_available(status);
return (( available && pref_status == PURPLE_SOUND_STATUS_AVAILABLE) ||
(!available && pref_status == PURPLE_SOUND_STATUS_AWAY));
}
}
/* We get here a couple of ways. Either the request has been OK'ed
* by purple_sound_play_event() and we're here because the UI has
* called purple_sound_play_file(), or we're here for something
* not related to an account (like testing a sound). */
return TRUE;
}
gboolean jabber_chat_change_nick(JabberChat *chat, const char *nick)
{
xmlnode *presence;
char *full_jid;
PurpleAccount *account;
PurpleStatus *status;
JabberBuddyState state;
char *msg;
int priority;
if(!chat->muc) {
purple_conv_chat_write(PURPLE_CONV_CHAT(chat->conv), "",
_("Nick changing not supported in non-MUC chatrooms"),
PURPLE_MESSAGE_SYSTEM, time(NULL));
return FALSE;
}
account = purple_connection_get_account(chat->js->gc);
status = purple_account_get_active_status(account);
purple_status_to_jabber(status, &state, &msg, &priority);
presence = jabber_presence_create_js(chat->js, state, msg, priority);
full_jid = g_strdup_printf("%s@%s/%s", chat->room, chat->server, nick);
xmlnode_set_attrib(presence, "to", full_jid);
g_free(full_jid);
g_free(msg);
jabber_send(chat->js, presence);
xmlnode_free(presence);
return TRUE;
}
guint sipe_backend_status(struct sipe_core_public *sipe_public)
{
struct sipe_backend_private *purple_private = sipe_public->backend_private;
PurpleStatus *status = purple_account_get_active_status(purple_private->account);
if (!status) return(SIPE_ACTIVITY_UNSET);
return(sipe_purple_token_to_activity(purple_status_get_id(status)));
}
//gets the text of whatever the user sets the status to. (not necessarily what status is on the server)
//client_text and server_text are freed if it returns false
static gboolean getStatusText(char** client_text, char** server_text, PurpleAccount *account, const char** sid)
{
PurpleStatus* status;
PurpleSavedStatus* savedStatus;
PurpleSavedStatusSub* substat;
const char* statusMessage;
status = purple_account_get_active_status(account);
if (status == NULL)
{
purple_debug_fatal("MusicInfo", "Account with NULL status\n");
return FALSE;
}
*sid = purple_status_get_id(status);
statusMessage = purple_status_get_attr_string(status, "message");
if(statusMessage != NULL)
{
*server_text = g_strdup(statusMessage);
}
else
{
*server_text = g_strdup("\0");
}
savedStatus = purple_savedstatus_get_current();
if (savedStatus == NULL)
{
purple_debug_fatal("MusicInfo", "Account with NULL saved status\n");
g_free(*server_text);
return FALSE;
}
statusMessage = NULL;
if(purple_savedstatus_has_substatuses(savedStatus))
{
substat = purple_savedstatus_get_substatus(savedStatus, account);
if(substat != NULL)
statusMessage = purple_savedstatus_substatus_get_message(substat);
}
if(statusMessage == NULL)
{
statusMessage = purple_savedstatus_get_message(savedStatus);
}
if(statusMessage == NULL)
{
g_free(*server_text);
return FALSE;
}
*client_text = g_strdup(statusMessage);
return TRUE;
}
static gboolean
should_notify_unavailable (PurpleAccount *account)
{
PurpleStatus *status;
if (!purple_prefs_get_bool ("/plugins/gtk/libnotify/only_available"))
return TRUE;
status = purple_account_get_active_status (account);
return purple_status_is_online (status) && purple_status_is_available (status);
}
void
pn_update_personal_message (MsnSession *session)
{
PurpleAccount *account;
PurplePresence *presence;
gchar *current_media;
g_return_if_fail (session);
if (!session->logged_in)
return;
account = msn_session_get_user_data (session);
presence = purple_account_get_presence (account);
current_media = create_current_media_string (presence);
#ifndef PECAN_USE_PSM
const gchar *msg;
msg = purple_account_get_string (account, "personal_message", "");
pn_set_personal_message (session, (gchar *) msg, current_media);
#else
PurpleStatus *status;
const gchar *formatted_msg;
status = purple_account_get_active_status (account);
formatted_msg = purple_status_get_attr_string (status, "message");
if (formatted_msg)
{
gchar *msg;
gchar *tmp;
tmp = purple_markup_strip_html (formatted_msg);
msg = g_markup_escape_text (tmp, -1);
pn_set_personal_message (session, msg, current_media);
g_free (tmp);
g_free (msg);
}
else
{
pn_set_personal_message (session, NULL, current_media);
}
#endif /* PECAN_USE_PSM */
if (current_media)
g_free (current_media);
}
void pending_reads_send_all (struct tgl_state *TLS) {
if (! purple_account_get_bool (tls_get_pa (TLS), TGP_KEY_SEND_READ_NOTIFICATIONS,
TGP_DEFAULT_SEND_READ_NOTIFICATIONS)) {
debug ("automatic read recipes disabled, not sending recipes");
return;
}
if (! p2tgl_status_is_present (purple_account_get_active_status (tls_get_pa (TLS)))) {
debug ("user is not present, not sending recipes");
return;
}
debug ("sending all pending recipes");
g_hash_table_foreach (tls_get_data (TLS)->pending_reads, tgl_do_mark_read_gw, TLS);
g_hash_table_remove_all (tls_get_data (TLS)->pending_reads);
}
/////////////////////////////////////////////////////////////////////////////
// Determines whether Lock'n'Roll should update the status message when the
// workstation is locked. This returns false if the current status is away
// already, invisible, or offline (fixes bug in 1.0.1)
/////////////////////////////////////////////////////////////////////////////
static gboolean lnr_should_change_message(PurpleAccount *acct)
{
PurpleStatusType *activeStatusType = NULL;
activeStatusType = purple_status_get_type(purple_account_get_active_status(acct));
switch (purple_status_type_get_primitive(activeStatusType))
{
case PURPLE_STATUS_AWAY:
case PURPLE_STATUS_EXTENDED_AWAY:
case PURPLE_STATUS_UNAVAILABLE:
case PURPLE_STATUS_INVISIBLE:
case PURPLE_STATUS_OFFLINE:
return FALSE;
default:
return TRUE;
}
}
static gboolean
set_status (PurpleAccount *acnt, const char *loc)
{
// discover the pidgin saved status in use for this account
const char *savedmessage = "";
{
PurpleSavedStatus *savedstatus = purple_savedstatus_get_current();
if (savedstatus)
{
PurpleSavedStatusSub *savedsubstatus = purple_savedstatus_get_substatus(savedstatus, acnt);
if (savedsubstatus)
{
// use account-specific saved status
savedmessage = purple_savedstatus_substatus_get_message(savedsubstatus);
}
else
{
// don't have an account-specific saved status, use the general one
savedmessage = purple_savedstatus_get_message(savedstatus);
}
}
}
/* generate status */
char *msg;
if (savedmessage) {
msg = (char *)malloc(strlen(savedmessage)+strlen(loc)+1);
strcpy(msg, loc);
strcat(msg, savedmessage);
}
else msg = loc;
PurpleStatus *status = purple_account_get_active_status (acnt);
GList *attrs = NULL;
attrs = g_list_append(attrs, "message");
attrs = g_list_append(attrs, (gpointer)msg);
purple_status_set_active_with_attrs_list(status, TRUE, attrs);
g_list_free(attrs);
trace("setup the account(%s) status: %s", acnt->username, msg);
if (savedmessage) {
free(msg);
}
return TRUE;
}
static void
buddy_typing_cb(PurpleAccount *acct, const char *name, void *data) {
PurpleConversation *gconv;
if(purple_prefs_get_bool(PREF_STATUS) &&
! purple_status_is_available(purple_account_get_active_status(acct))) {
purple_debug_info("psychic", "not available, doing nothing\n");
return;
}
if(purple_prefs_get_bool(PREF_BUDDIES) &&
! purple_find_buddy(acct, name)) {
purple_debug_info("psychic", "not in blist, doing nothing\n");
return;
}
if(FALSE == purple_privacy_check(acct, name)) {
purple_debug_info("psychic", "user %s is blocked\n", name);
return;
}
gconv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, name, acct);
if(! gconv) {
purple_debug_info("psychic", "no previous conversation exists\n");
gconv = purple_conversation_new(PURPLE_CONV_TYPE_IM, acct, name);
if(purple_prefs_get_bool(PREF_RAISE)) {
purple_conversation_present(gconv);
}
if(purple_prefs_get_bool(PREF_NOTICE)) {
/* This is a quote from Star Wars. You should probably not
translate it literally. If you can't find a fitting cultural
reference in your language, consider translating something
like this instead: "You feel a new message coming." */
purple_conversation_write(gconv, NULL,
_("You feel a disturbance in the force..."),
PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LOG | PURPLE_MESSAGE_ACTIVE_ONLY,
time(NULL));
}
/* Necessary because we may be creating a new conversation window. */
purple_conv_im_set_typing_state(PURPLE_CONV_IM(gconv), PURPLE_TYPING);
}
}
JabberChat *jabber_join_chat(JabberStream *js, const char *room,
const char *server, const char *handle,
const char *password, GHashTable *data)
{
JabberChat *chat;
PurpleConnection *gc;
PurpleAccount *account;
PurpleStatus *status;
xmlnode *presence, *x;
JabberBuddyState state;
char *msg;
int priority;
char *jid;
chat = jabber_chat_new(js, room, server, handle, password, data);
if (chat == NULL)
return NULL;
gc = js->gc;
account = purple_connection_get_account(gc);
status = purple_account_get_active_status(account);
purple_status_to_jabber(status, &state, &msg, &priority);
presence = jabber_presence_create_js(js, state, msg, priority);
g_free(msg);
jid = g_strdup_printf("%s@%s/%s", room, server, handle);
xmlnode_set_attrib(presence, "to", jid);
g_free(jid);
x = xmlnode_new_child(presence, "x");
xmlnode_set_namespace(x, "http://jabber.org/protocol/muc");
if (password && *password) {
xmlnode *p = xmlnode_new_child(x, "password");
xmlnode_insert_data(p, password, -1);
}
jabber_send(js, presence);
xmlnode_free(presence);
return chat;
}
static void irc_connected(struct irc_conn *irc, const char *nick)
{
PurpleConnection *gc;
PurpleStatus *status;
PurpleBlistNode *gnode, *cnode, *bnode;
if ((gc = purple_account_get_connection(irc->account)) == NULL
|| PURPLE_CONNECTION_IS_CONNECTED(gc))
return;
purple_connection_set_display_name(gc, nick);
purple_connection_set_state(gc, PURPLE_CONNECTED);
/* If we're away then set our away message */
status = purple_account_get_active_status(irc->account);
if (!purple_status_get_type(status) != PURPLE_STATUS_AVAILABLE) {
PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
prpl_info->set_status(irc->account, status);
}
/* this used to be in the core, but it's not now */
for (gnode = purple_get_blist()->root; gnode; gnode = gnode->next) {
if(!PURPLE_BLIST_NODE_IS_GROUP(gnode))
continue;
for(cnode = gnode->child; cnode; cnode = cnode->next) {
if(!PURPLE_BLIST_NODE_IS_CONTACT(cnode))
continue;
for(bnode = cnode->child; bnode; bnode = bnode->next) {
PurpleBuddy *b;
if(!PURPLE_BLIST_NODE_IS_BUDDY(bnode))
continue;
b = (PurpleBuddy *)bnode;
if(b->account == gc->account) {
struct irc_buddy *ib = g_new0(struct irc_buddy, 1);
ib->name = g_strdup(b->name);
g_hash_table_insert(irc->buddies, ib->name, ib);
}
}
}
}
irc_blist_timeout(irc);
if (!irc->timer)
irc->timer = purple_timeout_add_seconds(45, (GSourceFunc)irc_blist_timeout, (gpointer)irc);
}
static void* _background_login(void* data)
{
qq_account* ac=(qq_account*)data;
if(!qq_account_valid(ac)) return NULL;
LwqqClient* lc = ac->qq;
LwqqErrorCode err;
//it would raise a invalid ac when wake up from sleep.
//it would login twice,why?
//so what i can do is disable the invalid one.
if(!lwqq_client_valid(lc)) return NULL;
const char* status = purple_status_get_id(purple_account_get_active_status(ac->account));
lwqq_login(lc,lwqq_status_from_str(status), &err);
if (err == LWQQ_EC_LOGIN_NEED_VC) {
lc->dispatch(vp_func_pi,(CALLBACK_FUNC)extra_async_opt.need_verify,lc,err);
}else{
lc->dispatch(vp_func_pi,(CALLBACK_FUNC)extra_async_opt.login_complete,lc,err);
}
return NULL;
}
gboolean sipe_backend_status_changed(struct sipe_core_public *sipe_public,
guint activity,
const gchar *message)
{
struct sipe_backend_private *purple_private = sipe_public->backend_private;
PurpleStatus *status = purple_account_get_active_status(purple_private->account);
const gchar *status_id = sipe_purple_activity_to_token(activity);
gboolean changed = TRUE;
if (g_str_equal(status_id, purple_status_get_id(status)) &&
sipe_strequal(message,
purple_status_get_attr_string(status,
SIPE_PURPLE_STATUS_ATTR_ID_MESSAGE)))
{
changed = FALSE;
}
if (purple_savedstatus_is_idleaway()) {
changed = FALSE;
}
return(changed);
}
static void msg_received(PurpleAccount *account, char *sender, char *message,
PurpleConversation *conv, PurpleMessageFlags flags)
{
char *topic, *mod, *host, *_port;
int port;
PurpleStatus *status;
topic = (char *) purple_prefs_get_string("/plugins/gtk/"PLUGIN_ID"/topic");
mod = (char *) purple_prefs_get_string("/plugins/gtk/"PLUGIN_ID"/mod");
host = (char *) purple_prefs_get_string("/plugins/gtk/"PLUGIN_ID"/host");
_port = (char *) purple_prefs_get_string("/plugins/gtk/"PLUGIN_ID"/port");
port = atoi(_port);
purple_debug_info(PLUGIN_NAME, sender);
purple_debug_info(PLUGIN_NAME, message);
purple_debug_info(PLUGIN_NAME, topic);
purple_debug_info(PLUGIN_NAME, mod);
status = purple_account_get_active_status(account);
if (status != NULL && !purple_status_is_avaliable(status)) {
msg_send(host, port, (const char *) message, topic, mod);
}
}
std::string get_account_status()
{
std::string result;
// :fixme:
// atm we get the status only for the first account (assuming the status is
// identical forall active accounts - which may not be true)
GList *p_accounts = purple_accounts_get_all_active();
if (p_accounts) {
PurpleStatus *p_status = purple_account_get_active_status(
reinterpret_cast<PurpleAccount*>(g_list_first(p_accounts)->data));
const char *p_status_text = purple_primitive_get_name_from_type(
purple_status_type_get_primitive(purple_status_get_type(p_status)));
if (p_status_text) {
result = p_status_text;
} else {
result = "Unknown";
}
} else {
// no active accounts -> offline
result = "Offline";
}
return result;
}
static void discover_status(PurpleConnection *from, PurpleConnection *to,
gpointer userdata) {
const char *from_username = purple_account_get_username(purple_connection_get_account(from));
const char *to_username = purple_account_get_username(purple_connection_get_account(to));
if (purple_blist_find_buddy(purple_connection_get_account(from), to_username)) {
PurpleStatus *status = purple_account_get_active_status(purple_connection_get_account(to));
const char *status_id = purple_status_get_id(status);
const char *message = purple_status_get_attr_string(status, "message");
if (!strcmp(status_id, NULL_STATUS_ONLINE) ||
!strcmp(status_id, NULL_STATUS_AWAY) ||
!strcmp(status_id, NULL_STATUS_OFFLINE)) {
purple_debug_info("nullprpl", "%s sees that %s is %s: %s\n",
from_username, to_username, status_id, message);
purple_prpl_got_user_status(purple_connection_get_account(from), to_username, status_id,
(message) ? "message" : NULL, message, NULL);
} else {
purple_debug_error("nullprpl",
"%s's buddy %s has an unknown status: %s, %s",
from_username, to_username, status_id, message);
}
}
}
static gboolean
do_signon(gpointer data)
{
PurpleAccount *account = data;
PidginAutoRecon *info;
PurpleStatus *status;
purple_debug_info("autorecon", "do_signon called\n");
g_return_val_if_fail(account != NULL, FALSE);
info = g_hash_table_lookup(auto_reconns, account);
if (info)
info->timeout = 0;
status = purple_account_get_active_status(account);
if (purple_status_is_online(status))
{
purple_debug_info("autorecon", "calling purple_account_connect\n");
purple_account_connect(account);
purple_debug_info("autorecon", "done calling purple_account_connect\n");
}
return FALSE;
}
static void received_im_msg_cb(PurpleAccount *account, char *who, char *buffer,
PurpleConversation *conv, PurpleMessageFlags flags, void *data) {
// A workaround to avoid skipping of the first message as a result on NULL-conv:
if (conv == NULL) conv = purple_conversation_new(PURPLE_CONV_TYPE_IM,
account, who);
PurpleBuddy *buddy = purple_find_buddy(account, who);
PurplePresence *presence = purple_buddy_get_presence(buddy);
msg_metadata_t msg;
//Get message
msg.text = purple_markup_strip_html(buffer);
msg.remote_username = who;
//LOCAL USER:
msg.local_alias = purple_account_get_alias(account);
msg.local_username = (char *) purple_account_get_name_for_display(account);
//REMOTE USER (Buddy):
//Get buddy alias
msg.remote_alias = purple_buddy_get_alias(buddy);
if(msg.remote_alias == NULL) msg.remote_alias = "";
//Get buddy group
PurpleGroup *group = purple_buddy_get_group(buddy);
//return empty string if not in group
msg.remote_from_group = group != NULL ? purple_group_get_name(group) : "";
//Get protocol ID
msg.protocol_id = purple_account_get_protocol_id(account);
//trim out PROTOCOL_PREFIX (eg.: "prpl-irc" => "irc")
if(!strncmp(msg.protocol_id,PROTOCOL_PREFIX,strlen(PROTOCOL_PREFIX)))
msg.protocol_id += strlen(PROTOCOL_PREFIX);
//Get status
PurpleStatus *status = purple_account_get_active_status(account);
PurpleStatusType *type = purple_status_get_type(status);
//remote
PurpleStatus *r_status = purple_presence_get_active_status(presence);
PurpleStatusType *r_status_type = purple_status_get_type(r_status);
//Get status id
msg.local_status_id = NULL;
msg.local_status_id = purple_primitive_get_id_from_type(
purple_status_type_get_primitive(type));
//remote
msg.remote_status_id = NULL;
msg.remote_status_id = purple_primitive_get_id_from_type(
purple_status_type_get_primitive(r_status_type));
//Get status message
msg.local_status_msg = NULL;
if (purple_status_type_get_attr(type, "message") != NULL) {
msg.local_status_msg = purple_status_get_attr_string(status, "message");
} else {
PurpleSavedStatus *savedstatus = purple_savedstatus_get_current();
if(savedstatus)
msg.local_status_msg = purple_savedstatus_get_message(savedstatus);
}
//remote
msg.remote_status_msg = NULL;
if (purple_status_type_get_attr(r_status_type, "message") != NULL) {
msg.remote_status_msg = purple_status_get_attr_string(r_status, "message");
} else {
msg.remote_status_msg = "";
}
run_lua(conv, msg);
}
JabberChat *jabber_join_chat(JabberStream *js, const char *room,
const char *server, const char *handle,
const char *password, GHashTable *data)
{
JabberChat *chat;
PurpleConnection *gc;
PurpleAccount *account;
PurpleStatus *status;
xmlnode *presence, *x;
JabberBuddyState state;
char *msg;
int priority;
char *jid;
char *history_maxchars;
char *history_maxstanzas;
char *history_seconds;
char *history_since;
struct tm history_since_datetime;
const char *history_since_string = NULL;
chat = jabber_chat_new(js, room, server, handle, password, data);
if (chat == NULL)
return NULL;
gc = js->gc;
account = purple_connection_get_account(gc);
status = purple_account_get_active_status(account);
purple_status_to_jabber(status, &state, &msg, &priority);
presence = jabber_presence_create_js(js, state, msg, priority);
g_free(msg);
jid = g_strdup_printf("%s@%s/%s", room, server, handle);
xmlnode_set_attrib(presence, "to", jid);
g_free(jid);
history_maxchars = g_hash_table_lookup(data, "history_maxchars");
history_maxstanzas = g_hash_table_lookup(data, "history_maxstanzas");
history_seconds = g_hash_table_lookup(data, "history_seconds");
history_since = g_hash_table_lookup(data, "history_since");
if (history_since) {
if (purple_str_to_time(history_since, TRUE, &history_since_datetime, NULL, NULL) != 0) {
history_since_string = purple_utf8_strftime("%Y-%m-%dT%H:%M:%SZ", &history_since_datetime);
} else {
history_since_string = NULL;
purple_debug_error("jabber", "Invalid date format for history_since"
" while requesting history: %s", history_since);
}
}
x = xmlnode_new_child(presence, "x");
xmlnode_set_namespace(x, "http://jabber.org/protocol/muc");
if (password && *password) {
xmlnode *p = xmlnode_new_child(x, "password");
xmlnode_insert_data(p, password, -1);
}
if ((history_maxchars && *history_maxchars)
|| (history_maxstanzas && *history_maxstanzas)
|| (history_seconds && *history_seconds)
|| (history_since_string && *history_since_string)) {
xmlnode *history = xmlnode_new_child(x, "history");
if (history_maxchars && *history_maxchars) {
xmlnode_set_attrib(history, "maxchars", history_maxchars);
}
if (history_maxstanzas && *history_maxstanzas) {
xmlnode_set_attrib(history, "maxstanzas", history_maxstanzas);
}
if (history_seconds && *history_seconds) {
xmlnode_set_attrib(history, "seconds", history_seconds);
}
if (history_since_string && *history_since_string) {
xmlnode_set_attrib(history, "since", history_since_string);
}
}
jabber_send(js, presence);
xmlnode_free(presence);
return chat;
}
static void tgp_msg_display (struct tgl_state *TLS, struct tgp_msg_loading *C) {
connection_data *conn = TLS->ev_base;
struct tgl_message *M = C->msg;
char *text = NULL;
int flags = 0;
// only display new messages, ignore updates or deletions
if ((M->flags & (TGLMF_EMPTY | TGLMF_DELETED)) ||
!(M->flags & TGLMF_CREATED) ||
!M->message ||
tgp_outgoing_msg (TLS, M) ||
!tgl_get_peer_type (M->to_id)) {
return;
}
if (M->flags & TGLMF_SERVICE) {
text = format_service_msg (TLS, M);
flags |= PURPLE_MESSAGE_SYSTEM;
}
else if (M->media.type == tgl_message_media_document && M->media.document->flags & TGLDF_STICKER) {
#ifdef HAVE_LIBWEBP
char *filename = C->data;
int img = p2tgl_imgstore_add_with_id_webp (filename);
if (img <= 0) { failure ("Cannot display sticker, adding to imgstore failed"); return; }
used_images_add (conn, img);
text = format_img_full (img);
flags |= PURPLE_MESSAGE_IMAGES;
g_free (filename);
#else
char *txt_user = p2tgl_strdup_alias (tgl_peer_get (TLS, M->from_id));
text = g_strdup_printf ("%s sent a sticker", txt_user);
flags |= PURPLE_MESSAGE_SYSTEM;
g_free (txt_user);
#endif
}
else if (M->media.type == tgl_message_media_photo ||
(M->media.type == tgl_message_media_document_encr && M->media.encr_document->flags & TGLDF_IMAGE)) {
char *filename = C->data;
int img = p2tgl_imgstore_add_with_id (filename);
if (img <= 0) {
failure ("Cannot display picture message, adding to imgstore failed.");
return;
}
used_images_add (conn, img);
text = format_img_full (img);
flags |= PURPLE_MESSAGE_IMAGES;
g_free (filename);
}
else if (M->media.type == tgl_message_media_document) {
char *who = p2tgl_strdup_id (M->from_id);
if (! tgp_our_msg(TLS, M)) {
tgprpl_recv_file (conn->gc, who, M->media.document);
}
g_free (who);
return;
}
else if (M->media.type == tgl_message_media_document_encr) {
char *who = p2tgl_strdup_id (M->to_id);
if (! tgp_our_msg(TLS, M)) {
tgprpl_recv_encr_file (conn->gc, who, M->media.encr_document);
}
g_free (who);
return;
}
else {
text = format_message (M);
flags |= PURPLE_MESSAGE_RECV;
}
if (! text || ! *text) {
warning ("No text to display");
return;
}
switch (tgl_get_peer_type (M->to_id)) {
case TGL_PEER_CHAT: {
if (chat_show (conn->gc, tgl_get_peer_id (M->to_id))) {
p2tgl_got_chat_in (TLS, M->to_id, M->from_id, text, flags, M->date);
}
pending_reads_add (conn->pending_reads, M->to_id);
break;
}
case TGL_PEER_ENCR_CHAT: {
p2tgl_got_im (TLS, M->to_id, text, flags, M->date);
pending_reads_add (conn->pending_reads, M->to_id);
break;
}
case TGL_PEER_USER: {
if (tgp_our_msg (TLS, M)) {
flags |= PURPLE_MESSAGE_SEND;
flags &= ~PURPLE_MESSAGE_RECV;
p2tgl_got_im_combo (TLS, M->to_id, text, flags, M->date);
} else {
p2tgl_got_im (TLS, M->from_id, text, flags, M->date);
pending_reads_add (conn->pending_reads, M->from_id);
}
break;
}
}
if (p2tgl_status_is_present (purple_account_get_active_status (conn->pa)) && p2tgl_send_notifications(conn->pa)) {
pending_reads_send_all (conn->pending_reads, conn->TLS);
}
g_free (text);
}
static void waprpl_process_incoming_events(PurpleConnection * gc)
{
whatsapp_connection *wconn = purple_connection_get_protocol_data(gc);
PurpleAccount *acc = purple_connection_get_account(gc);
int err;
do {
char * reason;
err = waAPI_geterror(wconn->waAPI, &reason);
if (err != 0) {
PurpleConnectionError errcode = PURPLE_CONNECTION_ERROR_OTHER_ERROR;
if (err == 1)
errcode = PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED;
purple_connection_error_reason(gc, errcode, reason);
g_free(reason);
}
} while (err != 0);
switch (waAPI_loginstatus(wconn->waAPI)) {
case 0:
purple_connection_update_progress(gc, "Connecting", 0, 4);
break;
case 1:
purple_connection_update_progress(gc, "Sending authorization", 1, 4);
break;
case 2:
purple_connection_update_progress(gc, "Awaiting response", 2, 4);
break;
case 3:
if (!wconn->connected) {
purple_connection_update_progress(gc, "Connection established", 3, 4);
purple_connection_set_state(gc, PURPLE_CONNECTED);
PurpleAccount *account = purple_connection_get_account(gc);
PurpleStatus *status = purple_account_get_active_status(account);
waprpl_insert_contacts(gc);
waprpl_set_status(account, status);
wconn->connected = 1;
}
break;
default:
break;
};
/* Groups update */
if (waAPI_getgroupsupdated(wconn->waAPI)) {
purple_debug_info(WHATSAPP_ID, "Receiving update information from my groups\n");
/* Delete/update the chats that are in our list */
PurpleBlistNode *node;
for (node = purple_blist_get_root(); node; node = purple_blist_node_next(node, FALSE)) {
if (!PURPLE_BLIST_NODE_IS_CHAT(node))
continue;
PurpleChat *ch = PURPLE_CHAT(node);
if (purple_chat_get_account(ch) != acc)
continue;
GHashTable *hasht = purple_chat_get_components(ch);
char *grid = g_hash_table_lookup(hasht, "id");
char *glist = waAPI_getgroups(wconn->waAPI);
gchar **gplist = g_strsplit(glist, ",", 0);
if (str_array_find(gplist, grid) >= 0) {
/* The group is in the system, update the fields */
char *sub, *own;
waAPI_getgroupinfo(wconn->waAPI, grid, &sub, &own, 0);
g_hash_table_replace(hasht, g_strdup("subject"), sub);
g_hash_table_replace(hasht, g_strdup("owner"), own);
purple_blist_alias_chat(ch, sub);
} else {
/* The group was deleted */
PurpleChat *del = (PurpleChat *) node;
node = purple_blist_node_next(node, FALSE);
purple_blist_remove_chat(del);
}
g_strfreev(gplist);
g_free(glist);
}
/* Add new groups */
char *glist = waAPI_getgroups(wconn->waAPI);
gchar **gplist = g_strsplit(glist, ",", 0);
gchar **p;
for (p = gplist; *p; p++) {
gchar *gpid = *p;
PurpleChat *ch = blist_find_chat_by_id(gc, gpid);
if (!ch)
ch = create_chat_group(gpid, wconn, acc);
/* Now update the open conversation that may exist */
char *id = g_hash_table_lookup(purple_chat_get_components(ch), "id");
int prplid = chatid_to_convo(id);
PurpleConversation *conv = purple_find_chat(gc, prplid);
char *subject, *owner, *part;
if (conv && waAPI_getgroupinfo(wconn->waAPI, id, &subject, &owner, &part)) {
conv_add_participants(conv, part, owner);
}
}
g_strfreev(gplist);
g_free(glist);
}
t_message m;
while (waAPI_querymsg(wconn->waAPI, &m)) {
switch (m.type) {
case 0:
purple_debug_info(WHATSAPP_ID, "Got chat message from %s: %s\n", m.who, m.message);
conv_add_message(gc, m.who, m.message, m.author, m.t);
break;
case 1: {
purple_debug_info(WHATSAPP_ID, "Got image from %s: %s\n", m.who, m.message);
int imgid = purple_imgstore_add_with_id(g_memdup(m.image, m.imagelen), m.imagelen, NULL);
char *msg = g_strdup_printf("<a href=\"%s\"><img id=\"%u\"></a><br/><a href=\"%s\">%s</a>",
m.url, imgid, m.url, m.url);
conv_add_message(gc, m.who, msg, m.author, m.t);
g_free(msg);
} break;
case 2: {
purple_debug_info(WHATSAPP_ID, "Got geomessage from: %s Coordinates (%f %f)\n",
m.who, (float)m.lat, (float)m.lng);
char * lat = dbl2str(m.lat);
char * lng = dbl2str(m.lng);
char *msg = g_strdup_printf("<a href=\"http://openstreetmap.org/?lat=%s&lon=%s&zoom=20\">"
"http://openstreetmap.org/?lat=%s&lon=%s&zoom=20</a>",
lat, lng, lat, lng);
conv_add_message(gc, m.who, msg, m.author, m.t);
g_free(msg); g_free(lng); g_free(lat);
} break;
case 3: {
purple_debug_info(WHATSAPP_ID, "Got chat sound from %s: %s\n", m.who, m.url);
char *msg = g_strdup_printf("<a href=\"%s\">%s</a>", m.url, m.url);
conv_add_message(gc, m.who, msg, m.author, m.t);
g_free(msg);
} break;
case 4: {
purple_debug_info(WHATSAPP_ID, "Got chat video from %s: %s\n", m.who, m.url);
char *msg = g_strdup_printf("<a href=\"%s\">%s</a>", m.url, m.url);
conv_add_message(gc, m.who, msg, m.author, m.t);
g_free(msg);
} break;
case 5: {
purple_debug_info(WHATSAPP_ID, "Got phone call from %s\n", m.who);
conv_add_message(gc, m.who, "[Trying to voice-call you]", m.author, m.t);
} break;
default:
purple_debug_info(WHATSAPP_ID, "Got an unrecognized message!\n");
break;
};
g_free(m.who); g_free(m.author); g_free(m.message);
}
while (1) {
int typer;
char msgid[128];
if (!waAPI_queryreceivedmsg(wconn->waAPI, msgid, &typer))
break;
purple_debug_info(WHATSAPP_ID, "Received message %s type: %d\n", msgid, typer);
purple_signal_emit(purple_connection_get_prpl(gc), "whatsapp-message-received", gc, msgid, typer);
}
/* Status changes, typing notices and profile pictures. */
query_status(gc);
query_typing(gc);
query_icon(gc);
}
static void tgp_msg_display (struct tgl_state *TLS, struct tgp_msg_loading *C) {
connection_data *conn = TLS->ev_base;
struct tgl_message *M = C->msg;
char *text = NULL;
int flags = 0;
// Filter message updates and deletes, are not created and
// all messages in general that were already displayed, or shouldn't be displayed
if ((M->flags & (FLAG_MESSAGE_EMPTY | FLAG_DELETED)) ||
!(M->flags & FLAG_CREATED) ||
!M->message ||
our_msg (TLS, M) ||
!tgl_get_peer_type (M->to_id)) {
return;
}
if (M->service) {
text = format_service_msg (TLS, M);
flags |= PURPLE_MESSAGE_SYSTEM;
}
else if (M->media.type == tgl_message_media_document) {
char *who = p2tgl_strdup_id (M->from_id);
if (! out_msg(TLS, M)) {
tgprpl_recv_file (conn->gc, who, &M->media.document);
}
g_free (who);
return;
}
else if (M->media.type == tgl_message_media_document_encr) {
char *who = p2tgl_strdup_id (M->from_id);
if (! out_msg(TLS, M)) {
tgprpl_recv_encr_file (conn->gc, who, &M->media.encr_document);
}
g_free (who);
}
else if (M->media.type == tgl_message_media_photo) {
char *filename = C->data;
int imgStoreId = p2tgl_imgstore_add_with_id (filename);
if (imgStoreId <= 0) {
failure ("Cannot display picture message, adding to imgstore failed.");
return;
}
used_images_add (conn, imgStoreId);
text = format_img_full (imgStoreId);
flags |= PURPLE_MESSAGE_IMAGES;
}
else {
text = format_message (M);
flags |= PURPLE_MESSAGE_RECV;
}
if (! text || ! *text) {
warning ("No text to display");
return;
}
switch (tgl_get_peer_type (M->to_id)) {
case TGL_PEER_CHAT: {
if (chat_show (conn->gc, tgl_get_peer_id (M->to_id))) {
p2tgl_got_chat_in (TLS, M->to_id, M->from_id, text, flags, M->date);
}
pending_reads_add (conn->pending_reads, M->to_id);
break;
}
case TGL_PEER_ENCR_CHAT: {
p2tgl_got_im (TLS, M->to_id, text, flags, M->date);
pending_reads_add (conn->pending_reads, M->to_id);
break;
}
case TGL_PEER_USER: {
if (out_msg (TLS, M)) {
flags |= PURPLE_MESSAGE_SEND;
flags &= ~PURPLE_MESSAGE_RECV;
p2tgl_got_im_combo (TLS, M->to_id, text, flags, M->date);
} else {
p2tgl_got_im (TLS, M->from_id, text, flags, M->date);
pending_reads_add (conn->pending_reads, M->from_id);
}
break;
}
}
if (p2tgl_status_is_present (purple_account_get_active_status (conn->pa))) {
pending_reads_send_all (conn->pending_reads, conn->TLS);
}
g_free (text);
}
static void waprpl_process_incoming_events(PurpleConnection * gc)
{
whatsapp_connection *wconn = purple_connection_get_protocol_data(gc);
PurpleAccount *acc = purple_connection_get_account(gc);
switch (waAPI_loginstatus(wconn->waAPI)) {
case 0:
purple_connection_update_progress(gc, "Connecting", 0, 4);
break;
case 1:
purple_connection_update_progress(gc, "Sending authorization", 1, 4);
break;
case 2:
purple_connection_update_progress(gc, "Awaiting response", 2, 4);
break;
case 3:
purple_connection_update_progress(gc, "Connection established", 3, 4);
purple_connection_set_state(gc, PURPLE_CONNECTED);
if (!wconn->connected)
waprpl_insert_contacts(gc);
wconn->connected = 1;
PurpleAccount *account = purple_connection_get_account(gc);
PurpleStatus *status = purple_account_get_active_status(account);
waprpl_set_status(account, status);
break;
default:
break;
};
char *msg, *who, *prev, *url, *author;
int status;
int size;
double lat, lng;
unsigned long timestamp;
/* Incoming messages */
while (1) {
int r = waAPI_querynext(wconn->waAPI);
switch (r) {
case 0:
if (waAPI_querychat(wconn->waAPI, &who, &msg, &author, ×tamp)) {
purple_debug_info(WHATSAPP_ID, "Got chat message from %s: %s\n", who, msg);
conv_add_message(gc, who, msg, author, timestamp);
}
break;
case 1:
if (waAPI_querychatimage(wconn->waAPI, &who, &prev, &size, &url, &author, ×tamp)) {
purple_debug_info(WHATSAPP_ID, "Got image from %s: %s\n", who, url);
int imgid = purple_imgstore_add_with_id(g_memdup(prev, size), size, NULL);
char *msg = g_strdup_printf("<a href=\"%s\"><img id=\"%u\"></a><br/><a href=\"%s\">%s</a>", url, imgid, url, url);
conv_add_message(gc, who, msg, author, timestamp);
g_free(msg);
}
break;
case 2:
if (waAPI_querychatlocation(wconn->waAPI, &who, &prev, &size, &lat, &lng, &author, ×tamp)) {
purple_debug_info(WHATSAPP_ID, "Got geomessage from: %s Coordinates (%f %f)\n", who, (float)lat, (float)lng);
int imgid = purple_imgstore_add_with_id(g_memdup(prev, size), size, NULL);
char *msg = g_strdup_printf("<a href=\"http://openstreetmap.org/?lat=%f&lon=%f&zoom=16\"><img src=\"%u\"></a>", lat, lng, imgid);
conv_add_message(gc, who, msg, author, timestamp);
g_free(msg);
}
break;
case 3:
if (waAPI_querychatsound(wconn->waAPI, &who, &url, &author, ×tamp)) {
purple_debug_info(WHATSAPP_ID, "Got chat sound from %s: %s\n", who, url);
char *msg = g_strdup_printf("<a href=\"%s\">%s</a>", url, url);
conv_add_message(gc, who, msg, author, timestamp);
g_free(msg);
}
break;
default: break;
};
if (r < 0) break;
}
/* User status change */
while (waAPI_querystatus(wconn->waAPI, &who, &status)) {
if (status == 1) {
purple_prpl_got_user_status(acc, who, "available", "message", "", NULL);
} else {
purple_prpl_got_user_status(acc, who, "unavailable", "message", "", NULL);
}
}
/* User typing info notify */
while (waAPI_querytyping(wconn->waAPI, &who, &status)) {
if (status == 1) {
purple_debug_info(WHATSAPP_ID, "%s is typing\n", who);
serv_got_typing(gc, who, 0, PURPLE_TYPING);
} else {
purple_debug_info(WHATSAPP_ID, "%s is not typing\n", who);
serv_got_typing(gc, who, 0, PURPLE_NOT_TYPING);
serv_got_typing_stopped(gc, who);
}
}
/* User profile picture */
char *icon, *hash;
int len;
while (waAPI_queryicon(wconn->waAPI, &who, &icon, &len, &hash)) {
purple_buddy_icons_set_for_user(acc, who, g_memdup(icon, len), len, hash);
}
/* Groups update */
if (waAPI_getgroupsupdated(wconn->waAPI)) {
/* Delete/update the chats that are in our list */
PurpleBlistNode *node;
for (node = purple_blist_get_root(); node; node = purple_blist_node_next(node, FALSE)) {
if (!PURPLE_BLIST_NODE_IS_CHAT(node))
continue;
PurpleChat *ch = PURPLE_CHAT(node);
if (purple_chat_get_account(ch) != acc)
continue;
GHashTable *hasht = purple_chat_get_components(ch);
char *grid = g_hash_table_lookup(hasht, "id");
char *glist = waAPI_getgroups(wconn->waAPI);
gchar **gplist = g_strsplit(glist, ",", 0);
if (str_array_find(gplist, grid) >= 0) {
/* The group is in the system, update the fields */
char *sub, *own;
waAPI_getgroupinfo(wconn->waAPI, grid, &sub, &own, 0);
g_hash_table_insert(hasht, g_strdup("subject"), g_strdup(sub));
g_hash_table_insert(hasht, g_strdup("owner"), g_strdup(own));
} else {
/* The group was deleted */
PurpleChat *del = (PurpleChat *) node;
node = purple_blist_node_next(node, FALSE);
purple_blist_remove_chat(del);
}
g_strfreev(gplist);
}
/* Add new groups */
char *glist = waAPI_getgroups(wconn->waAPI);
gchar **gplist = g_strsplit(glist, ",", 0);
gchar **p;
for (p = gplist; *p; p++) {
gchar *gpid = *p;
PurpleChat *ch = blist_find_chat_by_id(gc, gpid);
if (!ch) {
char *sub, *own;
waAPI_getgroupinfo(wconn->waAPI, gpid, &sub, &own, 0);
purple_debug_info("waprpl", "New group found %s %s\n", gpid, sub);
GHashTable *htable = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
g_hash_table_insert(htable, g_strdup("subject"), g_strdup(sub));
g_hash_table_insert(htable, g_strdup("id"), g_strdup(gpid));
g_hash_table_insert(htable, g_strdup("owner"), g_strdup(own));
ch = purple_chat_new(acc, sub, htable);
purple_blist_add_chat(ch, NULL, NULL);
}
/* Now update the open conversation that may exist */
char *id = g_hash_table_lookup(purple_chat_get_components(ch), "id");
int prplid = chatid_to_convo(id);
PurpleConversation *conv = purple_find_chat(gc, prplid);
char *subject, *owner, *part;
if (conv && waAPI_getgroupinfo(wconn->waAPI, id, &subject, &owner, &part))
conv_add_participants(conv, part, owner);
}
g_strfreev(gplist);
}
}
void QuetzalAccount::handleSignedOn()
{
setStatusChanged(purple_account_get_active_status(m_account));
if (PURPLE_PLUGIN_PROTOCOL_INFO(m_account->gc->prpl)->chat_info)
resetGroupChatManager(new QuetzalJoinChatManager(this));
}
static void waprpl_process_incoming_events(PurpleConnection * gc)
{
whatsapp_connection *wconn = purple_connection_get_protocol_data(gc);
PurpleAccount *acc = purple_connection_get_account(gc);
switch (waAPI_loginstatus(wconn->waAPI)) {
case 0:
purple_connection_update_progress(gc, "Connecting", 0, 4);
break;
case 1:
purple_connection_update_progress(gc, "Sending authorization", 1, 4);
break;
case 2:
purple_connection_update_progress(gc, "Awaiting response", 2, 4);
break;
case 3:
purple_connection_update_progress(gc, "Connection established", 3, 4);
purple_connection_set_state(gc, PURPLE_CONNECTED);
if (!wconn->connected)
waprpl_insert_contacts(gc);
wconn->connected = 1;
PurpleAccount *account = purple_connection_get_account(gc);
PurpleStatus *status = purple_account_get_active_status(account);
waprpl_set_status(account, status);
break;
default:
break;
};
/* Groups update */
if (waAPI_getgroupsupdated(wconn->waAPI)) {
/* Delete/update the chats that are in our list */
PurpleBlistNode *node;
for (node = purple_blist_get_root(); node; node = purple_blist_node_next(node, FALSE)) {
if (!PURPLE_BLIST_NODE_IS_CHAT(node))
continue;
PurpleChat *ch = PURPLE_CHAT(node);
if (purple_chat_get_account(ch) != acc)
continue;
GHashTable *hasht = purple_chat_get_components(ch);
char *grid = g_hash_table_lookup(hasht, "id");
char *glist = waAPI_getgroups(wconn->waAPI);
gchar **gplist = g_strsplit(glist, ",", 0);
if (str_array_find(gplist, grid) >= 0) {
/* The group is in the system, update the fields */
char *sub, *own;
waAPI_getgroupinfo(wconn->waAPI, grid, &sub, &own, 0);
g_hash_table_replace(hasht, g_strdup("subject"), g_strdup(sub));
g_hash_table_replace(hasht, g_strdup("owner"), g_strdup(own));
purple_blist_alias_chat(ch, g_strdup(sub));
} else {
/* The group was deleted */
PurpleChat *del = (PurpleChat *) node;
node = purple_blist_node_next(node, FALSE);
purple_blist_remove_chat(del);
}
g_strfreev(gplist);
}
/* Add new groups */
char *glist = waAPI_getgroups(wconn->waAPI);
gchar **gplist = g_strsplit(glist, ",", 0);
gchar **p;
for (p = gplist; *p; p++) {
gchar *gpid = *p;
PurpleChat *ch = blist_find_chat_by_id(gc, gpid);
if (!ch) {
char *sub, *own;
waAPI_getgroupinfo(wconn->waAPI, gpid, &sub, &own, 0);
purple_debug_info("waprpl", "New group found %s %s\n", gpid, sub);
GHashTable *htable = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
g_hash_table_insert(htable, g_strdup("subject"), g_strdup(sub));
g_hash_table_insert(htable, g_strdup("id"), g_strdup(gpid));
g_hash_table_insert(htable, g_strdup("owner"), g_strdup(own));
ch = purple_chat_new(acc, sub, htable);
purple_blist_add_chat(ch, NULL, NULL);
}
/* Now update the open conversation that may exist */
char *id = g_hash_table_lookup(purple_chat_get_components(ch), "id");
int prplid = chatid_to_convo(id);
PurpleConversation *conv = purple_find_chat(gc, prplid);
char *subject, *owner, *part;
if (conv && waAPI_getgroupinfo(wconn->waAPI, id, &subject, &owner, &part))
conv_add_participants(conv, part, owner);
}
g_strfreev(gplist);
}
/* Incoming messages. */
for (;;) {
int r = waAPI_querynext(wconn->waAPI);
if (r < 0)
break;
switch (r) {
case 0:
query_chat_message(gc);
break;
case 1:
query_chat_image(gc);
break;
case 2:
query_chat_location(gc);
break;
case 3:
query_chat_sound(gc);
break;
case 4:
query_chat_video(gc);
break;
default:
/* Unsupported message type. */
break;
};
}
/* Status changes, typing notices and profile pictures. */
query_status(gc);
query_typing(gc);
query_icon(gc);
}