static void nullprpl_tooltip_text(PurpleBuddy *buddy,
PurpleNotifyUserInfo *info,
gboolean full) {
PurpleConnection *gc = get_nullprpl_gc(purple_buddy_get_name(buddy));
if (gc) {
/* they're logged in */
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
char *msg = nullprpl_status_text(buddy);
/* TODO: Check whether it's correct to call add_pair_html,
or if we should be using add_pair_plaintext */
purple_notify_user_info_add_pair_html(info, purple_status_get_name(status),
msg);
g_free(msg);
if (full) {
const char *user_info = purple_account_get_user_info(purple_connection_get_account(gc));
if (user_info)
/* TODO: Check whether it's correct to call add_pair_html,
or if we should be using add_pair_plaintext */
purple_notify_user_info_add_pair_html(info, _("User info"), user_info);
}
} else {
/* they're not logged in */
purple_notify_user_info_add_pair_plaintext(info, _("User info"), _("not logged in"));
}
purple_debug_info("nullprpl", "showing %s tooltip for %s\n",
(full) ? "full" : "short", purple_buddy_get_name(buddy));
}
static void
purplemot_tooltip_text(PurpleBuddy *buddy, PurpleNotifyUserInfo *info, int full)
{
PurpleConnection *gc = get_purplemot_gc(buddy->name);
if (gc) {
/* they're logged in */
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
char *msg = purplemot_status_text(buddy);
purple_notify_user_info_add_pair(info, purple_status_get_name(status),
msg);
g_free(msg);
if (full) {
const char *user_info = purple_account_get_user_info(gc->account);
if (user_info)
purple_notify_user_info_add_pair(info, _("User info"), user_info);
}
} else {
/* they're not logged in */
purple_notify_user_info_add_pair(info, _("User info"), _("not logged in"));
}
purple_debug_info("purplemot", "showing %s tooltip for %s\n",
(full) ? "full" : "short", buddy->name);
}
static char *plainprpl_status_text(PurpleBuddy *buddy)
{
PurplePresence *presence;
PurpleStatus *status;
const char *status_name;
const char *message;
char *status_text;
//purple_debug_info("plainprpl", "getting %s's status text for %s\n", buddy->name, buddy->account->username);
presence = purple_buddy_get_presence(buddy);
if (presence) {
status = purple_presence_get_active_status(presence);
} else {
//printf("presence is null for ");
status = NULL;
}
if (status) {
status_name = purple_status_get_name(status);
message = purple_status_get_attr_string(status, "message");
if (message && strlen(message) > 0) {
status_text = g_strdup_printf("%s: %s", status_name, message);
} else {
status_text = g_strdup(status_name);
}
//purple_debug_info("plainprpl", "%s's status text is %s\n", buddy->name, status_text);
return status_text;
} else {
return g_strdup("Not logged in");
}
}
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 plainprpl_get_info(PurpleConnection *gc, const char *buddy_name)
{
PurpleBuddy *buddy;
plain_buddy_state *bstate;
PurpleNotifyUserInfo *info;
const char *addr_str;
buddy = purple_find_buddy(gc->account, buddy_name);
bstate = purple_buddy_get_protocol_data(buddy);
info = purple_notify_user_info_new();
if (bstate) {
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
const char *status_name = purple_status_get_name(status);
purple_notify_user_info_add_pair(info, "Status", status_name);
addr_str = purple_blist_node_get_string(PURPLE_BLIST_NODE(buddy), "addr_str");
purple_notify_user_info_add_pair(info, "Address", addr_str);
if (bstate->state == BUDDY_STATE_RESOLVE) {
/* The IP address has not been resolved yet */
purple_notify_user_info_add_pair(info, "Resolved", "Unknown");
} else {
purple_notify_user_info_add_pair(info, "Resolved", str_addr(&bstate->addr));
}
purple_notify_user_info_add_pair(info, "Last Seen", str_time(bstate->time_recv));
} else {
purple_notify_user_info_add_pair(info, "Info", "Missing Data");
}
/* Show a buddy's user info in a nice dialog box */
purple_notify_userinfo(gc, buddy_name, info, NULL, NULL);
}
static char *nullprpl_status_text(PurpleBuddy *buddy) {
purple_debug_info("nullprpl", "getting %s's status text for %s\n",
purple_buddy_get_name(buddy),
purple_account_get_username(purple_buddy_get_account(buddy)));
if (purple_blist_find_buddy(purple_buddy_get_account(buddy), purple_buddy_get_name(buddy))) {
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
const char *name = purple_status_get_name(status);
const char *message = purple_status_get_attr_string(status, "message");
char *text;
if (message && *message)
text = g_strdup_printf("%s: %s", name, message);
else
text = g_strdup(name);
purple_debug_info("nullprpl", "%s's status text is %s\n",
purple_buddy_get_name(buddy), text);
return text;
} else {
purple_debug_info("nullprpl", "...but %s is not logged in\n", purple_buddy_get_name(buddy));
return g_strdup("Not logged in");
}
}
static char *
purplemot_status_text(PurpleBuddy *buddy) {
purple_debug_info("purplemot", "getting %s's status text for %s\n",
buddy->name, buddy->account->username);
if (purple_find_buddy(buddy->account, buddy->name)) {
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
const char *name = purple_status_get_name(status);
const char *message = purple_status_get_attr_string(status, "message");
char *text;
if (message && strlen(message) > 0)
text = g_strdup_printf("%s: %s", name, message);
else
text = g_strdup(name);
purple_debug_info("purplemot", "%s's status text is %s\n", buddy->name, text);
return text;
} else {
purple_debug_info("purplemot", "...but %s is not logged in\n", buddy->name);
return g_strdup("Not logged in");
}
}
Data IMInvoker::statusToData(PurpleStatus *status) {
Data data;
const char* statusName = purple_status_get_name(status);
if (statusName) data.compound["name"] = Data(statusName, Data::VERBATIM);
PurpleStatusType* statusType = PURPLE_STATUS_GET_TYPE(status);
GList *statusAttrElem;
PURPLE_STATUS_ATTR* statusAttr;
GList *statusAttrList = purple_status_type_get_attrs(statusType);
for(statusAttrElem = statusAttrList; statusAttrElem; statusAttrElem = statusAttrElem->next) {
statusAttr = (PURPLE_STATUS_ATTR*)statusAttrElem->data;
const char* statusAttrId = PURPLE_STATUS_ATTR_GET_ID(statusAttr);
PURPLE_VALUE* statusValue = purple_status_get_attr_value(status, statusAttrId);
if (statusValue) {
data.compound[statusAttrId] = purpleValueToData(statusValue);
}
}
data.compound["active"] = Data((bool)purple_status_is_active(status));
data.compound["available"] = Data((bool)purple_status_is_available(status));
data.compound["exclusive"] = Data((bool)purple_status_is_exclusive(status));
data.compound["active"] = Data((bool)purple_status_is_active(status));
data.compound["independent"] = Data((bool)purple_status_is_independent(status));
data.compound["online"] = Data((bool)purple_status_is_online(status));
return data;
}
void QuetzalAccount::setStatus(Status status)
{
PurpleStatus *purple_status = quetzal_get_correct_status(m_account->presence, status);
debug() << purple_status_get_id(purple_status) << purple_status_get_name(purple_status);
purple_presence_set_status_active(m_account->presence, purple_status_get_id(purple_status), TRUE);
if (status.type() != Status::Offline)
purple_account_connect(m_account);
}
static void nullprpl_set_status(PurpleAccount *acct, PurpleStatus *status) {
const char *msg = purple_status_get_attr_string(status, "message");
purple_debug_info("nullprpl", "setting %s's status to %s: %s\n",
purple_account_get_username(acct), purple_status_get_name(status), msg);
foreach_nullprpl_gc(report_status_change, get_nullprpl_gc(purple_account_get_username(acct)),
NULL);
}
/**
* \brief Get string representation of buddy.
*
* This function returns the string-representation of a buddy in the format:
* <tt>
* buddies name<TAB>buddies active status<TAB>buddies alias
* </tt>
*
* \param buddy The buddy
* \returns String representation of the buddy. The returned string has to
* be freed by the caller later on.
*/
static char *get_buddy_string(PurpleBuddy *buddy)
{
return g_strdup_printf("%s\t%s\t%s\n",
purple_buddy_get_name(buddy),
purple_status_get_name(
purple_presence_get_active_status(
purple_buddy_get_presence(buddy))),
purple_buddy_get_alias(buddy));
}
void Accounts::status_changed(PurpleAccount *account, PurpleStatus *status)
{
if (!purple_account_get_enabled(account, PACKAGE_NAME))
return;
LOG->Message(_("+ [%s] %s: Status changed to: %s"),
purple_account_get_protocol_name(account),
purple_account_get_username(account),
purple_status_get_name(status));
}
static void _elim_status_changed ( PurpleAccount *account ,
PurpleStatus *status )
{
xmlnode *alist = xnode_new( "alist" );
char *ID = new_elim_id();
fprintf( stderr, "(_elim_status_changed)\n" );
PurpleStatusType *type = purple_status_get_type( status );
PurpleStatusPrimitive statp = purple_status_type_get_primitive( type );
AL_PTR ( alist, "account-uid" , account );
AL_STR ( alist, "account-name", purple_account_get_username ( account ) );
AL_STR ( alist, "im-protocol" , purple_account_get_protocol_id( account ) );
AL_STR ( alist, "status-name" , purple_status_get_name ( status ) );
AL_ENUM( alist, "status-type" , statp, ":status-primitive" );
AL_BOOL( alist, "connected" , purple_account_is_connected ( account ) );
xmlnode *mcall = func_call( "elim-account-status-changed", ID, alist );
g_free( ID );
add_outbound_sexp( mcall );
}
void
skypeweb_tooltip_text(PurpleBuddy *buddy, PurpleNotifyUserInfo *user_info, gboolean full)
{
SkypeWebBuddy *sbuddy = purple_buddy_get_protocol_data(buddy);
if (sbuddy)
{
PurplePresence *presence;
PurpleStatus *status;
SkypeWebBuddy *sbuddy = purple_buddy_get_protocol_data(buddy);
presence = purple_buddy_get_presence(buddy);
status = purple_presence_get_active_status(presence);
purple_notify_user_info_add_pair_html(user_info, _("Status"), purple_status_get_name(status));
if (sbuddy->mood && *sbuddy->mood)
purple_notify_user_info_add_pair_html(user_info, _("Message"), sbuddy->mood);
if (sbuddy->display_name && *sbuddy->display_name)
purple_notify_user_info_add_pair_html(user_info, "Alias", sbuddy->display_name);
if (sbuddy->fullname && *sbuddy->fullname)
purple_notify_user_info_add_pair_html(user_info, "Full Name", sbuddy->fullname);
}
}
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 ggp_pubdir_get_info_protocol_got(PurpleConnection *gc,
int records_count, const ggp_pubdir_record *records, int next_offset,
void *_uin_p)
{
uin_t uin = *((uin_t*)_uin_p);
PurpleNotifyUserInfo *info = purple_notify_user_info_new();
const ggp_pubdir_record *record = &records[0];
PurpleBuddy *buddy;
g_free(_uin_p);
if (records_count < 1) {
purple_debug_error("gg", "ggp_pubdir_get_info_protocol_got: "
"couldn't get info for %u\n", uin);
purple_notify_user_info_add_pair_plaintext(info, NULL,
_("Cannot get user information"));
purple_notify_userinfo(gc, ggp_uin_to_str(uin), info,
NULL, NULL);
purple_notify_user_info_destroy(info);
return;
}
purple_debug_info("gg", "ggp_pubdir_get_info_protocol_got: %u\n", uin);
g_assert(uin == record->uin);
g_assert(records_count == 1);
buddy = purple_blist_find_buddy(purple_connection_get_account(gc),
ggp_uin_to_str(uin));
if (buddy) {
const char *alias;
PurpleStatus *status;
gchar *status_message;
alias = purple_buddy_get_alias_only(buddy);
if (alias)
purple_notify_user_info_add_pair_plaintext(info,
_("Alias"), alias);
status = purple_presence_get_active_status(
purple_buddy_get_presence(buddy));
ggp_status_from_purplestatus(status, &status_message);
purple_notify_user_info_add_pair_plaintext(info, _("Status"),
purple_status_get_name(status));
if (status_message) {
purple_notify_user_info_add_pair_plaintext(info,
_("Message"), status_message);
}
}
if (record->nickname) {
purple_notify_user_info_add_pair_plaintext(info,
_("Nickname"), record->nickname);
}
if (record->first_name) {
purple_notify_user_info_add_pair_plaintext(info,
_("First name"), record->first_name);
}
if (record->last_name) {
purple_notify_user_info_add_pair_plaintext(info,
_("Last name"), record->last_name);
}
if (record->gender != GGP_PUBDIR_GENDER_UNSPECIFIED) {
purple_notify_user_info_add_pair_plaintext(info, _("Gender"),
record->gender == GGP_PUBDIR_GENDER_FEMALE ?
_("Female") : _("Male"));
}
if (record->city) {
purple_notify_user_info_add_pair_plaintext(info, _("City"),
record->city);
}
if (record->birth) {
purple_notify_user_info_add_pair_plaintext(info, _("Birthday"),
ggp_date_strftime("%Y-%m-%d", record->birth));
} else if (record->age) {
gchar *age_s = g_strdup_printf("%d", record->age);
purple_notify_user_info_add_pair_plaintext(info, _("Age"),
age_s);
g_free(age_s);
}
purple_notify_userinfo(gc, ggp_uin_to_str(uin), info, NULL, NULL);
purple_notify_user_info_destroy(info);
}
/**
* @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
account_set_info_cb(PurpleAccount *account, const char *info, void *data)
{
purple_debug_misc("signals test", "account-set-info (%s, %s)\n",
purple_account_get_username(account), info);
}
static void
account_status_changed(PurpleAccount *account, PurpleStatus *old, PurpleStatus *new,
gpointer data)
{
purple_debug_misc("signals test", "account-status-changed (%s, %s, %s)\n",
purple_account_get_username(account),
purple_status_get_name(old),
purple_status_get_name(new));
}
static void
account_alias_changed(PurpleAccount *account, const char *old, gpointer data)
{
purple_debug_misc("signals test", "account-alias-changed (%s, %s, %s)\n",
purple_account_get_username(account),
old, purple_account_get_alias(account));
}
static int
account_authorization_requested_cb(PurpleAccount *account, const char *user, gpointer data)
{
purple_debug_misc("signals test", "account-authorization-requested (%s, %s)\n",
/**************************************************************************
* Buddy List subsystem signal callbacks
**************************************************************************/
static void
buddy_status_changed_cb(PurpleBuddy *buddy, PurpleStatus *old_status, PurpleStatus *status)
{
char *status_name, *old_status_name, *status_msg;
char* buddy_nick, *buddy_name, *icon_path, *growl_msg;
PurpleBuddyIcon* icon;
int len, hack_ms;
PurpleAccount* account;
DEBUG_MSG("buddy_status_changed_cb\n");
g_return_if_fail( buddy != NULL );
account = purple_buddy_get_account(buddy);
g_return_if_fail( is_allowed(account) );
status_name = (char *)purple_status_get_name(status);
old_status_name = (char *)purple_status_get_name(old_status);
buddy_nick = (char*)purple_buddy_get_alias(buddy);
buddy_name = (char*)purple_buddy_get_name(buddy);
icon = purple_buddy_get_icon(buddy);
icon_path = (char*)purple_buddy_icon_get_full_path(icon);
status_msg = custom_get_buddy_status_text(buddy);
if( status_msg == NULL )
status_msg = "";
special_entries(status_msg);
strip_tags(status_msg);
//hack to hide spam when signing on to account
hack_ms = purple_prefs_get_int("/plugins/core/pidgin-gntp/hack_ms");
GList *node = buddy_status_is_new(buddy, status_msg);
if( GetTickCount() - start_tick_im < hack_ms) return;
if( node != NULL )
{
DEBUG_MSG("status node received\n");
struct buddy_status* node_status = node->data;
free(node_status->status);
char* the_status = malloc( s_strlen(status_msg)+1 );
strcpy(the_status, status_msg);
node_status->status = the_status;
if(status_msg[0] == 0)
{
len = s_strlen(buddy_nick) + s_strlen(buddy_name) + 25;
growl_msg = malloc( len );
g_snprintf(growl_msg, len, "status message removed\n%s\n%s",buddy_nick, buddy_name );
gntp_notify("buddy-change-msg", icon_path, "Status Message Changed", growl_msg, NULL);
free(growl_msg);
}
else
{
len = s_strlen(buddy_nick) + s_strlen(buddy_name) + s_strlen(status_msg)+5;
growl_msg = malloc( len );
g_snprintf(growl_msg, len, "\"%s\"\n%s\n%s",
status_msg, buddy_nick, buddy_name );
gntp_notify("buddy-change-msg", icon_path, "Status Changed", growl_msg, NULL);
free(growl_msg);
}
}
if( strcmp(status_name, old_status_name) == 0)
return;
len = s_strlen(buddy_nick) + s_strlen(buddy_name) + s_strlen(status_name) + 3;
growl_msg = malloc( len );
g_snprintf(growl_msg, len, "%s\n%s\n%s",
status_name, buddy_nick, buddy_name );
gntp_notify("buddy-change-status", icon_path, "Status Changed", growl_msg, NULL);
free(growl_msg);
}
