static gchar *
stress_status_text(PurpleBuddy *buddy) {
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
const gchar *msg = NULL;
msg = purple_status_get_attr_string(status, "message");
return (msg) ? g_strdup(msg) : NULL;
}
static void fx_tooltip_text(PurpleBuddy *buddy, PurpleNotifyUserInfo *user_info, gboolean UNUSED(full))
{
PurpleStatus *status;
const gchar *impresa, *alias, *sid, *mobileno;
g_return_if_fail(buddy != NULL);
status = purple_presence_get_active_status(purple_buddy_get_presence(buddy));
impresa = purple_status_get_attr_string(status, "impresa");
sid = purple_status_get_attr_string(status, "fetionno");
mobileno = purple_status_get_attr_string(status, "mobileno");
alias = purple_buddy_get_alias(buddy);
purple_notify_user_info_add_pair(user_info, _("FetionNo"), sid);
purple_notify_user_info_add_pair(user_info, _("MobileNo"), mobileno);
purple_notify_user_info_add_pair(user_info, _("Alias"), alias);
purple_notify_user_info_add_pair(user_info, _("Signature"), impresa);
}
EntryStatus FromPurpleStatus (PurpleAccount *account, PurpleStatus *status)
{
const auto id = purple_status_get_id (status);
const auto statusType = purple_account_get_status_type (account, id);
const auto message = purple_status_get_attr_string (status, "message");
return EntryStatus (FromPurpleState (purple_status_type_get_primitive (statusType)),
message ? QString::fromUtf8 (message) : QString ());
}
char *PurpleLine::status_text(PurpleBuddy *buddy) {
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
const char *msg = purple_status_get_attr_string(status, "message");
if (msg && msg[0])
return g_markup_escape_text(msg, -1);
return nullptr;
}
/**
* Set the currently playing song artist and or title.
*
* @param user User associated with the now playing information.
*
* @param new_artist New artist to set, or NULL/empty to not change artist.
*
* @param new_title New title to set, or NULL/empty to not change title.
*
* If new_artist and new_title are NULL/empty, deactivate PURPLE_STATUS_TUNE.
*
* This function is useful because it lets you set the artist or title
* individually, which purple_prpl_got_user_status() doesn't do.
*/
static void msim_set_artist_or_title(MsimUser *user, const char *new_artist, const char *new_title)
{
PurplePresence *presence;
const char *prev_artist, *prev_title;
if (user->buddy == NULL)
/* User not on buddy list so nothing to do */
return;
prev_artist = NULL;
prev_title = NULL;
if (new_artist && !*new_artist)
new_artist = NULL;
if (new_title && !*new_title)
new_title = NULL;
if (!new_artist && !new_title) {
purple_prpl_got_user_status_deactive(user->buddy->account, user->buddy->name, "tune");
return;
}
presence = purple_buddy_get_presence(user->buddy);
if (purple_presence_is_status_primitive_active(presence, PURPLE_STATUS_TUNE)) {
PurpleStatus *status;
status = purple_presence_get_status(presence, "tune");
prev_title = purple_status_get_attr_string(status, PURPLE_TUNE_TITLE);
prev_artist = purple_status_get_attr_string(status, PURPLE_TUNE_ARTIST);
}
if (!new_artist)
new_artist = prev_artist;
if (!new_title)
new_title = prev_title;
purple_prpl_got_user_status(user->buddy->account, user->buddy->name, "tune",
PURPLE_TUNE_TITLE, new_title,
PURPLE_TUNE_ARTIST, new_artist,
NULL);
}
static void waprpl_set_status(PurpleAccount * acct, PurpleStatus * status)
{
whatsapp_connection *wconn = purple_connection_get_protocol_data(purple_account_get_connection(acct));
const char *sid = purple_status_get_id(status);
const char *mid = purple_status_get_attr_string(status, "message");
if (mid == 0)
mid = "";
waAPI_setmypresence(wconn->waAPI, sid, mid);
waprpl_check_output(purple_account_get_connection(acct));
}
void jidgin_worker_cb_status(PurpleBuddy *buddy, PurpleStatus *old_status, PurpleStatus *status) {
const char *sig_new = purple_status_get_attr_string(status, "message");
pJidginMsg pmsg;
PurpleAccount *account;
if (sig_new) {
account = purple_buddy_get_account(buddy);
pmsg = jidgin_msg_init(ROBOTMSG_TYPE_SIG);
pmsg->from = g_strdup(buddy->name);
pmsg->to = g_strdup(account->username);
pmsg->msg = g_strdup(sig_new);
pmsg->device = g_strdup(account->protocol_id);
jidgin_reactor_emit(pmsg);
jidgin_msg_destroy(pmsg);
jidgin_log(LOG_INFO, "[jidgin_worker_cb_status]%s %s\n",
buddy->name,
purple_status_get_attr_string(status, "message"));
}
}
static gchar *fx_status_text(PurpleBuddy *buddy)
{
PurplePresence *presence;
PurpleStatus *status;
const gchar *msg;
presence = purple_buddy_get_presence(buddy);
status = purple_presence_get_active_status(presence);
msg = purple_status_get_attr_string(status, "impresa");
if(msg && *msg) return g_markup_escape_text(msg, -1);
return NULL;
}
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 sipe_purple_set_status(PurpleAccount *account,
PurpleStatus *status)
{
SIPE_DEBUG_INFO("sipe_purple_set_status[CB]: status=%s",
purple_status_get_id(status));
if (!purple_status_is_active(status))
return;
if (account->gc) {
const gchar *status_id = purple_status_get_id(status);
const gchar *note = purple_status_get_attr_string(status,
SIPE_PURPLE_STATUS_ATTR_ID_MESSAGE);
sipe_core_status_set(PURPLE_ACCOUNT_TO_SIPE_CORE_PUBLIC,
sipe_purple_token_to_activity(status_id),
note);
}
}
bool SpectrumBuddy::getStatus(PurpleStatusPrimitive &status, std::string &statusMessage) {
PurplePresence *pres = purple_buddy_get_presence(m_buddy);
if (pres == NULL)
return false;
PurpleStatus *stat = purple_presence_get_active_status(pres);
if (stat == NULL)
return false;
status = purple_status_type_get_primitive(purple_status_get_type(stat));
const char *message = purple_status_get_attr_string(stat, "message");
if (message != NULL) {
char *stripped = purple_markup_strip_html(message);
statusMessage = std::string(stripped);
g_free(stripped);
}
else
statusMessage = "";
return true;
}
/* a short status text beside buddy icon*/
static gchar *qq_status_text(PurpleBuddy *b)
{
PurpleStatus *status;
PurplePresence *presence;
gchar *moodtext, *ret;
presence = purple_buddy_get_presence(b);
status = purple_presence_get_status(presence, "mood");
/* we only provide Mood here
switch(bd->status) {
case QQ_BUDDY_OFFLINE:
g_string_append(status, _("Offline"));
break;
case QQ_BUDDY_ONLINE_NORMAL:
g_string_append(status, _("Online"));
break;
case QQ_BUDDY_CHANGE_TO_OFFLINE:
g_string_append(status, _("Offline"));
break;
case QQ_BUDDY_ONLINE_AWAY:
g_string_append(status, _("Away"));
break;
case QQ_BUDDY_ONLINE_INVISIBLE:
g_string_append(status, _("Invisible"));
break;
case QQ_BUDDY_ONLINE_BUSY:
g_string_append(status, _("Busy"));
break;
default:
g_string_printf(status, _("Unknown-%d"), bd->status);
}
*/
moodtext = purple_status_get_attr_string(status, PURPLE_MOOD_COMMENT);
if (moodtext)
{
ret = g_strdup(moodtext); //ret will be free by invoker
return ret;
}
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
write_status(PurpleBuddy *buddy, const char *fmt)
{
const char *message;
const char *status_type;
const char *alias = purple_buddy_get_alias(buddy);
char *log_entry;
PurpleStatus *status = purple_presence_get_active_status(buddy->presence);
/* Collect data */
message = purple_status_get_attr_string(status, "message");
if (message == NULL) {
/* Don't bother with no message only
* if we have something other to say */
if (fmt)
message = _("");
else
return;
}
if (!fmt) {
/* No fmt? Use default */
fmt = _("%s status is: %s (%s)");
}
if (!status) {
status_type = _("Unknown status type");
} else {
status_type = purple_status_get_name(status);
}
log_entry = g_strdup_printf(fmt, alias, status_type, message);
write_message(buddy, log_entry);
g_free(log_entry);
return;
}
static void irc_set_status(PurpleAccount *account, PurpleStatus *status)
{
PurpleConnection *gc = purple_account_get_connection(account);
struct irc_conn *irc;
const char *args[1];
const char *status_id = purple_status_get_id(status);
g_return_if_fail(gc != NULL);
irc = gc->proto_data;
if (!purple_status_is_active(status))
return;
args[0] = NULL;
if (!strcmp(status_id, "away")) {
args[0] = purple_status_get_attr_string(status, "message");
if ((args[0] == NULL) || (*args[0] == '\0'))
args[0] = _("Away");
irc_cmd_away(irc, "away", NULL, args);
} else if (!strcmp(status_id, "available")) {
irc_cmd_away(irc, "back", NULL, args);
}
}
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 void prplcb_blist_update(PurpleBuddyList *list, PurpleBlistNode *node)
{
if (node->type == PURPLE_BLIST_BUDDY_NODE) {
PurpleBuddy *bud = (PurpleBuddy *) node;
PurpleGroup *group = purple_buddy_get_group(bud);
struct im_connection *ic = purple_ic_by_pa(bud->account);
PurpleStatus *as;
int flags = 0;
if (ic == NULL) {
return;
}
if (bud->server_alias) {
imcb_rename_buddy(ic, bud->name, bud->server_alias);
} else if (bud->alias) {
imcb_rename_buddy(ic, bud->name, bud->alias);
}
if (group) {
imcb_add_buddy(ic, bud->name, purple_group_get_name(group));
}
flags |= purple_presence_is_online(bud->presence) ? OPT_LOGGED_IN : 0;
flags |= purple_presence_is_available(bud->presence) ? 0 : OPT_AWAY;
as = purple_presence_get_active_status(bud->presence);
imcb_buddy_status(ic, bud->name, flags, purple_status_get_name(as),
purple_status_get_attr_string(as, "message"));
imcb_buddy_times(ic, bud->name,
purple_presence_get_login_time(bud->presence),
purple_presence_get_idle_time(bud->presence));
}
}
static void pipe_handle_subscribe(struct purple_subscribe *subscribe) {
PurpleAccount *account = NULL;
extern_account_t *accounts = NULL;
extern_user_t *users = NULL;
int naccounts = 0, nusers = 0;
int i, j;
PurpleBuddy *buddy = NULL;
int d = 0;
const char *note;
enum purple_publish_basic basic;
enum purple_publish_activity activity;
LM_DBG("calling find_accounts(\"%s\", &naccounts)\n", subscribe->from);
accounts = find_accounts(subscribe->from, &naccounts);
LM_DBG("found %d extra account(s) for <%s>", naccounts, subscribe->from);
LM_DBG("calling find_users(\"%s\", &nusers)\n", subscribe->to);
users = find_users(subscribe->to, &nusers);
LM_DBG("found %d extra user(s) for <%s>", nusers, subscribe->to);
for (i = 0; i < naccounts; i++) {
LM_DBG("calling client_find_account(\"%s\")\n", accounts[i].username);
account = client_find_account(&accounts[i]);
//if ((account) && (purple_account_is_connected(account) || purple_account_is_connecting(account))) {
if (account) {
for (j = 0; j < nusers; j++) {
if (!strcmp(accounts[i].protocol, users[j].protocol)) {
LM_DBG("found matching protocol: %s\n", accounts[i].protocol);
LM_DBG("subscribe expires : %d\n", subscribe->expires);
if (subscribe->expires == 0)
d = hashtable_dec_counter(users[j].username);
else
d = hashtable_inc_counter(users[j].username);
LM_DBG("<%s> is now referenced %d times\n", users[j].username, d);
if (d == 0) {
LM_DBG("<%s> is no more referenced, removing presence...\n", users[j].username);
if (purple_send_sip_publish(subscribe->to, users[j].username, PURPLE_BASIC_CLOSED, 0, NULL) < 0)
LM_ERR("error sending presence for %s", subscribe->to);
else
LM_DBG("presence message sent successfully\n");
}
else {
buddy = purple_find_buddy(account, users[j].username);
if (buddy == NULL) {
LM_DBG("<%s> not found in <%s> buddy list, adding\n", users[j].username, accounts[i].username);
buddy = purple_buddy_new(account, users[j].username, users[j].username);
//purple_blist_add_buddy(buddy, NULL, NULL, NULL);
purple_account_add_buddy(account, buddy);
}
else {
LM_DBG("<%s> found in <%s> buddy list, sending publish\n", users[j].username, accounts[i].username);
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
PurpleStatusType *type = purple_status_get_type(status);
PurpleStatusPrimitive primitive = purple_status_type_get_primitive(type);
note = purple_status_get_attr_string(status, "message");
primitive_parse(primitive, &basic, &activity);
if (purple_send_sip_publish(subscribe->to, users[j].username, basic, activity, note) < 0)
LM_ERR("error sending presence for %s", subscribe->to);
else
LM_DBG("presence message sent successfully\n");
}
}
break;
}
}
}
}
if (accounts)
extern_account_free(accounts, naccounts);
if (users)
extern_user_free(users, nusers);
}
void jabber_presence_send(JabberStream *js, gboolean force)
{
PurpleAccount *account;
xmlnode *presence, *x, *photo;
char *stripped = NULL;
JabberBuddyState state;
int priority;
const char *artist = NULL, *title = NULL, *source = NULL, *uri = NULL, *track = NULL;
int length = -1;
gboolean allowBuzz;
PurplePresence *p;
PurpleStatus *status, *tune;
account = purple_connection_get_account(js->gc);
p = purple_account_get_presence(account);
status = purple_presence_get_active_status(p);
/* we don't want to send presence before we've gotten our roster */
if (js->state != JABBER_STREAM_CONNECTED) {
purple_debug_misc("jabber", "attempt to send presence before roster retrieved\n");
return;
}
purple_status_to_jabber(status, &state, &stripped, &priority);
/* check for buzz support */
allowBuzz = purple_status_get_attr_boolean(status,"buzz");
/* changing the buzz state has to trigger a re-broadcasting of the presence for caps */
tune = purple_presence_get_status(p, "tune");
if (js->googletalk && !stripped && purple_status_is_active(tune)) {
stripped = jabber_google_presence_outgoing(tune);
}
#define CHANGED(a,b) ((!a && b) || (a && a[0] == '\0' && b && b[0] != '\0') || \
(a && !b) || (a && a[0] != '\0' && b && b[0] == '\0') || (a && b && strcmp(a,b)))
/* check if there are any differences to the <presence> and send them in that case */
if (force || allowBuzz != js->allowBuzz || js->old_state != state ||
CHANGED(js->old_msg, stripped) || js->old_priority != priority ||
CHANGED(js->old_avatarhash, js->avatar_hash) || js->old_idle != js->idle) {
/* Need to update allowBuzz before creating the presence (with caps) */
js->allowBuzz = allowBuzz;
presence = jabber_presence_create_js(js, state, stripped, priority);
/* Per XEP-0153 4.1, we must always send the <x> */
x = xmlnode_new_child(presence, "x");
xmlnode_set_namespace(x, "vcard-temp:x:update");
/*
* FIXME: Per XEP-0153 4.3.2 bullet 2, we must not publish our
* image hash if another resource has logged in and updated the
* vcard avatar. Requires changes in jabber_presence_parse.
*/
if (js->vcard_fetched) {
/* Always publish a <photo>; it's empty if we have no image. */
photo = xmlnode_new_child(x, "photo");
if (js->avatar_hash)
xmlnode_insert_data(photo, js->avatar_hash, -1);
}
jabber_send(js, presence);
g_hash_table_foreach(js->chats, chats_send_presence_foreach, presence);
xmlnode_free(presence);
/* update old values */
if(js->old_msg)
g_free(js->old_msg);
if(js->old_avatarhash)
g_free(js->old_avatarhash);
js->old_msg = g_strdup(stripped);
js->old_avatarhash = g_strdup(js->avatar_hash);
js->old_state = state;
js->old_priority = priority;
js->old_idle = js->idle;
}
g_free(stripped);
/* next, check if there are any changes to the tune values */
if (purple_status_is_active(tune)) {
artist = purple_status_get_attr_string(tune, PURPLE_TUNE_ARTIST);
title = purple_status_get_attr_string(tune, PURPLE_TUNE_TITLE);
source = purple_status_get_attr_string(tune, PURPLE_TUNE_ALBUM);
uri = purple_status_get_attr_string(tune, PURPLE_TUNE_URL);
track = purple_status_get_attr_string(tune, PURPLE_TUNE_TRACK);
length = (!purple_status_get_attr_value(tune, PURPLE_TUNE_TIME)) ? -1 :
purple_status_get_attr_int(tune, PURPLE_TUNE_TIME);
}
if(CHANGED(artist, js->old_artist) || CHANGED(title, js->old_title) || CHANGED(source, js->old_source) ||
CHANGED(uri, js->old_uri) || CHANGED(track, js->old_track) || (length != js->old_length)) {
PurpleJabberTuneInfo tuneinfo = {
(char*)artist,
(char*)title,
(char*)source,
(char*)track,
length,
(char*)uri
};
jabber_tune_set(js->gc, &tuneinfo);
/* update old values */
g_free(js->old_artist);
g_free(js->old_title);
g_free(js->old_source);
g_free(js->old_uri);
g_free(js->old_track);
js->old_artist = g_strdup(artist);
js->old_title = g_strdup(title);
js->old_source = g_strdup(source);
js->old_uri = g_strdup(uri);
js->old_length = length;
js->old_track = g_strdup(track);
}
#undef CHANGED
jabber_presence_fake_to_self(js, status);
}
/* a floating text when mouse is on the icon, show connection status here */
static void qq_tooltip_text(PurpleBuddy *b, PurpleNotifyUserInfo *user_info, gboolean full)
{
qq_buddy_data *bd;
gchar *tmp;
GString *str;
PurplePresence *presence;
PurpleStatus *status;
gchar *moodtext;
g_return_if_fail(b != NULL);
presence = purple_buddy_get_presence(b);
bd = purple_buddy_get_protocol_data(b);
if (bd == NULL)
return;
if (bd->level == NULL)
qq_request_get_level(purple_account_get_connection(purple_buddy_get_account(b)), bd->uid);
/* if (PURPLE_BUDDY_IS_ONLINE(b) && bd != NULL) */
if (bd->ip.s_addr != 0) {
str = g_string_new(NULL);
g_string_printf(str, "%s:%d", inet_ntoa(bd->ip), bd->port);
if (bd->comm_flag & QQ_COMM_FLAG_TCP_MODE) {
g_string_append(str, " TCP");
} else {
g_string_append(str, " UDP");
}
g_string_free(str, TRUE);
}
tmp = g_strdup_printf("%d", bd->age);
purple_notify_user_info_add_pair(user_info, _("Age"), tmp);
g_free(tmp);
switch (bd->gender) {
case QQ_BUDDY_GENDER_GG:
purple_notify_user_info_add_pair(user_info, _("Gender"), _("Male"));
break;
case QQ_BUDDY_GENDER_MM:
purple_notify_user_info_add_pair(user_info, _("Gender"), _("Female"));
break;
default:
purple_notify_user_info_add_pair(user_info, _("Gender"), _("Unknown"));
}
if (bd->level) {
tmp = g_strdup_printf("%d", bd->level);
purple_notify_user_info_add_pair(user_info, _("Level"), tmp);
g_free(tmp);
}
str = g_string_new(NULL);
if (bd->comm_flag & QQ_COMM_FLAG_QQ_MEMBER) {
g_string_append( str, _("Member") );
}
if (bd->comm_flag & QQ_COMM_FLAG_QQ_VIP) {
g_string_append( str, _(" VIP") );
}
if (bd->comm_flag & QQ_COMM_FLAG_TCP_MODE) {
g_string_append( str, _(" TCP") );
}
if (bd->comm_flag & QQ_COMM_FLAG_MOBILE) {
g_string_append( str, _(" FromMobile") );
}
if (bd->comm_flag & QQ_COMM_FLAG_BIND_MOBILE) {
g_string_append( str, _(" BindMobile") );
}
if (bd->comm_flag & QQ_COMM_FLAG_VIDEO) {
g_string_append( str, _(" Video") );
}
if (bd->ext_flag & QQ_EXT_FLAG_ZONE) {
g_string_append( str, _(" Zone") );
}
purple_notify_user_info_add_pair(user_info, _("Flag"), str->str);
g_string_free(str, TRUE);
status = purple_presence_get_status(presence, PURPLE_MOOD_NAME);
moodtext = purple_status_get_attr_string(status, PURPLE_MOOD_COMMENT);
if (moodtext)
{
purple_notify_user_info_add_pair(user_info, _("Signature"), moodtext);
}
#ifdef DEBUG
tmp = g_strdup_printf( "%s (%04X)",
qq_get_ver_desc(bd->client_tag),
bd->client_tag );
purple_notify_user_info_add_pair(user_info, _("Ver"), tmp);
g_free(tmp);
tmp = g_strdup_printf( "Ext 0x%X, Comm 0x%X",
bd->ext_flag, bd->comm_flag );
purple_notify_user_info_add_pair(user_info, _("Flag"), tmp);
g_free(tmp);
#endif
}
char *jabber_google_presence_outgoing(PurpleStatus *tune)
{
const char *attr = purple_status_get_attr_string(tune, PURPLE_TUNE_TITLE);
return attr ? g_strdup_printf("♫ %s", attr) : g_strdup("");
}
/**
* @brief Append the status information to a user_info struct
*
* The returned information is HTML-ready, appropriately escaped, as all information in a user_info struct should be HTML.
*
* @param gc The PurpleConnection
* @param user_info A PurpleNotifyUserInfo object to which status information will be added
* @param b The PurpleBuddy whose status is desired. This or the aim_userinfo_t (or both) must be passed to oscar_user_info_append_status().
* @param userinfo The aim_userinfo_t of the buddy whose status is desired. This or the PurpleBuddy (or both) must be passed to oscar_user_info_append_status().
* @param use_html_status If TRUE, prefer HTML-formatted away message over plaintext available message.
*/
void
oscar_user_info_append_status(PurpleConnection *gc, PurpleNotifyUserInfo *user_info, PurpleBuddy *b, aim_userinfo_t *userinfo, gboolean use_html_status)
{
PurpleAccount *account = purple_connection_get_account(gc);
OscarData *od;
PurplePresence *presence = NULL;
PurpleStatus *status = NULL;
gchar *message = NULL, *itmsurl = NULL, *tmp;
gboolean escaping_needed = TRUE;
od = purple_connection_get_protocol_data(gc);
if (b == NULL && userinfo == NULL)
return;
if (b == NULL)
b = purple_find_buddy(purple_connection_get_account(gc), userinfo->bn);
else
userinfo = aim_locate_finduserinfo(od, purple_buddy_get_name(b));
if (b) {
presence = purple_buddy_get_presence(b);
status = purple_presence_get_active_status(presence);
}
/* If we have both b and userinfo we favor userinfo, because if we're
viewing someone's profile then we want the HTML away message, and
the "message" attribute of the status contains only the plaintext
message. */
if (userinfo) {
if ((userinfo->flags & AIM_FLAG_AWAY) && use_html_status && userinfo->away_len > 0 && userinfo->away != NULL && userinfo->away_encoding != NULL) {
/* Away message */
message = oscar_encoding_to_utf8(userinfo->away_encoding, userinfo->away, userinfo->away_len);
escaping_needed = FALSE;
} else {
/*
* Available message or non-HTML away message (because that's
* all we have right now.
*/
if ((userinfo->status != NULL) && userinfo->status[0] != '\0') {
message = oscar_encoding_to_utf8(userinfo->status_encoding, userinfo->status, userinfo->status_len);
}
#if defined (_WIN32) || defined (__APPLE__)
if (userinfo->itmsurl && (userinfo->itmsurl[0] != '\0')) {
itmsurl = oscar_encoding_to_utf8(userinfo->itmsurl_encoding, userinfo->itmsurl, userinfo->itmsurl_len);
}
#endif
}
} else {
message = g_strdup(purple_status_get_attr_string(status, "message"));
itmsurl = g_strdup(purple_status_get_attr_string(status, "itmsurl"));
}
if (message) {
tmp = oscar_util_format_string(message, purple_account_get_username(account));
g_free(message);
message = tmp;
if (escaping_needed) {
tmp = purple_markup_escape_text(message, -1);
g_free(message);
message = tmp;
}
}
if (use_html_status && itmsurl) {
tmp = g_strdup_printf("<a href=\"%s\">%s</a>", itmsurl, message);
g_free(message);
message = tmp;
}
if (b) {
if (purple_presence_is_online(presence)) {
gboolean is_away = ((status && !purple_status_is_available(status)) || (userinfo && (userinfo->flags & AIM_FLAG_AWAY)));
if (oscar_util_valid_name_icq(purple_buddy_get_name(b)) || is_away || !message || !(*message)) {
/* Append the status name for online ICQ statuses, away AIM statuses, and for all buddies with no message.
* If the status name and the message are the same, only show one. */
const char *status_name = purple_status_get_name(status);
if (status_name && message && !strcmp(status_name, message))
status_name = NULL;
tmp = g_strdup_printf("%s%s%s",
status_name ? status_name : "",
((status_name && message) && *message) ? ": " : "",
(message && *message) ? message : "");
g_free(message);
message = tmp;
}
} else if (aim_ssi_waitingforauth(od->ssi.local,
aim_ssi_itemlist_findparentname(od->ssi.local, purple_buddy_get_name(b)),
purple_buddy_get_name(b)))
{
/* Note if an offline buddy is not authorized */
tmp = g_strdup_printf("%s%s%s",
_("Not Authorized"),
(message && *message) ? ": " : "",
(message && *message) ? message : "");
g_free(message);
message = tmp;
} else {
g_free(message);
message = g_strdup(_("Offline"));
}
}
if (presence) {
const char *mood;
const char *comment;
char *description;
status = purple_presence_get_status(presence, "mood");
mood = icq_get_custom_icon_description(purple_status_get_attr_string(status, PURPLE_MOOD_NAME));
if (mood) {
comment = purple_status_get_attr_string(status, PURPLE_MOOD_COMMENT);
if (comment) {
char *escaped_comment = purple_markup_escape_text(comment, -1);
description = g_strdup_printf("%s (%s)", _(mood), escaped_comment);
g_free(escaped_comment);
} else {
description = g_strdup(_(mood));
}
purple_notify_user_info_add_pair(user_info, _("Mood"), description);
g_free(description);
}
}
purple_notify_user_info_add_pair(user_info, _("Status"), message);
g_free(message);
}
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);
}
/**
* Append user information to a PurpleNotifyUserInfo, given an MsimUser.
* Used by msim_tooltip_text() and msim_get_info_cb() to show a user's profile.
*/
void
msim_append_user_info(MsimSession *session, PurpleNotifyUserInfo *user_info, MsimUser *user, gboolean full)
{
PurplePresence *presence;
gchar *str;
guint cv;
/* Useful to identify the account the tooltip refers to.
* Other prpls show this. */
if (user->username) {
purple_notify_user_info_add_pair(user_info, _("User"), user->username);
}
/* a/s/l...the vitals */
if (user->age) {
char age[16];
g_snprintf(age, sizeof(age), "%d", user->age);
purple_notify_user_info_add_pair(user_info, _("Age"), age);
}
if (user->gender && *user->gender) {
purple_notify_user_info_add_pair(user_info, _("Gender"), user->gender);
}
if (user->location && *user->location) {
purple_notify_user_info_add_pair(user_info, _("Location"), user->location);
}
/* Other information */
if (user->headline && *user->headline) {
purple_notify_user_info_add_pair(user_info, _("Headline"), user->headline);
}
if (user->buddy != NULL) {
presence = purple_buddy_get_presence(user->buddy);
if (purple_presence_is_status_primitive_active(presence, PURPLE_STATUS_TUNE)) {
PurpleStatus *status;
const char *artist, *title;
status = purple_presence_get_status(presence, "tune");
title = purple_status_get_attr_string(status, PURPLE_TUNE_TITLE);
artist = purple_status_get_attr_string(status, PURPLE_TUNE_ARTIST);
str = msim_format_now_playing(artist, title);
if (str && *str) {
purple_notify_user_info_add_pair(user_info, _("Song"), str);
}
g_free(str);
}
}
/* Note: total friends only available if looked up by uid, not username. */
if (user->total_friends) {
char friends[16];
g_snprintf(friends, sizeof(friends), "%d", user->total_friends);
purple_notify_user_info_add_pair(user_info, _("Total Friends"), friends);
}
if (full) {
/* Client information */
char *client = NULL;
str = user->client_info;
cv = user->client_cv;
if (str && cv != 0) {
client = g_strdup_printf("%s (build %d)", str, cv);
} else if (str) {
client = g_strdup(str);
} else if (cv) {
client = g_strdup_printf("Build %d", cv);
}
if (client && *client)
purple_notify_user_info_add_pair(user_info, _("Client Version"), client);
g_free(client);
}
if (full && user->id) {
/* TODO: link to username, if available */
char *profile;
purple_notify_user_info_add_section_break(user_info);
if (user->buddy != NULL)
profile = g_strdup_printf("<a href=\"http://myspace.com/%s\">%s</a>",
purple_buddy_get_name(user->buddy), _("View web profile"));
else
profile = g_strdup_printf("<a href=\"http://myspace.com/%d\">%s</a>",
user->id, _("View web profile"));
purple_notify_user_info_add_pair(user_info, NULL, profile);
g_free(profile);
}
}
