gboolean
pop(gpointer p) {
char *reply = "";
queue_t *q = (queue_t*)p;
queue_item_t *item;
if (q->len > 0) {
item = q->q[0];
q->len--;
if (q->len > 0) {
memmove(q->q, &(q->q[1]), q->len * sizeof(queue_item_t*));
// q->q = realloc(q->q, q->len * sizeof(queue_item_t*));
}
if (purple_conversation_get_type(item->conv) == PURPLE_CONV_TYPE_IM) {
// reply = alice(item->name, item->msg, item->conv);
purple_conv_im_send(PURPLE_CONV_IM(item->conv), item->msg);
} else if (purple_conversation_get_type(item->conv) == PURPLE_CONV_TYPE_CHAT) {
// reply = alice(item->name, item->msg, item->conv);
purple_conv_chat_send(PURPLE_CONV_CHAT(item->conv), item->msg);
}
printf (NAME ": %s\n", reply);
free(item->name);
free(item->msg);
free(item);
}
return 1;
}
bool PurpleIMChat::sendMessageCbk(void * dataIn)
{
Mutex::ScopedLock lock(PurpleIMChat::_mutex);
PurpleIMChatCallbackData* cbData = (PurpleIMChatCallbackData*) dataIn;
IMChatSession* chatSession = cbData->getIMChatSession();
// const char * message = (const char *)((misc_t *)data)->data_ptr2;
// char *cleanMess = (char *) message;
// bool cleaned = false;
std::string cleanMsg = cbData->getMessage();
mConvInfo_t *mConv = FindChatStructById(chatSession->getId());
PurpleConversation *gConv = mConv->purple_conv_session; //VOXOX - JRT - 2009.07.09
// special case for ICQ
PurpleAccount *gAccount = purple_conversation_get_account(gConv);
PurplePlugin *prpl = purple_find_prpl(purple_account_get_protocol_id(gAccount));
if (prpl)
{
PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
if (prpl_info->list_icon != NULL)
{
if (!strcmp("icq", prpl_info->list_icon(gAccount, NULL)))
{
// cleanMess = (char *) purple_markup_strip_html(message);
cleanMsg= purple_markup_strip_html( cbData->getMessage().c_str() );
// cleaned = true;
}
}
}
if (purple_conversation_get_type(gConv) == PURPLE_CONV_TYPE_IM)
{
purple_conv_im_send_with_flags(PURPLE_CONV_IM(gConv), cleanMsg.c_str(), PURPLE_MESSAGE_SEND);
}
else if (purple_conversation_get_type(gConv) == PURPLE_CONV_TYPE_CHAT)
{
purple_conv_chat_send_with_flags(PURPLE_CONV_CHAT(gConv), cleanMsg.c_str(), PURPLE_MESSAGE_SEND);
}
// if (cleaned)
// {
// g_free(cleanMess);
// }
timeoutRemove( cbData );
delete cbData;
return TRUE;
}
static char *timestamp_cb_common(PurpleConversation *conv,
time_t t,
gboolean show_date,
gboolean force,
const char *dates,
gboolean parens)
{
g_return_val_if_fail(dates != NULL, NULL);
if (show_date ||
!strcmp(dates, "always") ||
(conv != NULL && purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT && !strcmp(dates, "chats")))
{
struct tm *tm = localtime(&t);
if (force)
return g_strdup_printf("%s%s%s", parens ? "(" : "", purple_utf8_strftime("%Y-%m-%d %H:%M:%S", tm), parens ? ")" : "");
else
return g_strdup_printf("%s%s%s", parens ? "(" : "", purple_date_format_long(tm), parens ? ")" : "");
}
if (force)
{
struct tm *tm = localtime(&t);
return g_strdup_printf("%s%s%s", parens ? "(" : "", purple_utf8_strftime("%H:%M:%S", tm), parens ? ")" : "");
}
return NULL;
}
static gboolean should_hide_notice(PurpleConversation *conv, const char *name,
GHashTable *users)
{
PurpleConvChat *chat;
int threshold;
struct joinpart_key key;
time_t *last_said;
g_return_val_if_fail(conv != NULL, FALSE);
g_return_val_if_fail(purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT, FALSE);
/* If the room is small, don't bother. */
chat = PURPLE_CONV_CHAT(conv);
threshold = purple_prefs_get_int(THRESHOLD_PREF);
if (g_list_length(purple_conv_chat_get_users(chat)) < threshold)
return FALSE;
if (!purple_prefs_get_bool(HIDE_BUDDIES_PREF) &&
purple_find_buddy(purple_conversation_get_account(conv), name))
return FALSE;
/* Only show the notice if the user has spoken recently. */
key.conv = conv;
key.user = (gchar *)name;
last_said = g_hash_table_lookup(users, &key);
if (last_said != NULL)
{
int delay = purple_prefs_get_int(DELAY_PREF);
if (delay > 0 && (*last_said + (delay * 60)) >= time(NULL))
return FALSE;
}
return TRUE;
}
static VALUE conversation_get_type(VALUE self)
{
PurpleConversation *conversation;
Data_Get_Struct(self, PurpleConversation, conversation);
return INT2FIX(purple_conversation_get_type(conversation));
}
void PurpleLine::write_message(PurpleConversation *conv, std::string &from, std::string &text,
time_t mtime, int flags)
{
if (!conv)
return;
PurpleConversationType type = purple_conversation_get_type(conv);
if (type == PURPLE_CONV_TYPE_IM) {
purple_conv_im_write(
PURPLE_CONV_IM(conv),
from.c_str(),
text.c_str(),
(PurpleMessageFlags)flags,
mtime);
} else if (type == PURPLE_CONV_TYPE_CHAT) {
purple_conv_chat_write(
PURPLE_CONV_CHAT(conv),
from.c_str(),
text.c_str(),
(PurpleMessageFlags)flags,
mtime);
} else {
purple_debug_warning("line", "write_message for weird conversation type: %d\n", type);
}
}
/* ------------------
* called on new conversations
* ------------------ */
void conversation_created_cb(PurpleConversation *conv, char* data)
{
char sys_msg_buffer[1000];
if (purple_conversation_get_type(conv) != PURPLE_CONV_TYPE_IM)
return;
purple_debug_info(PLUGIN_ID, "conversation name: %s\n",conv->name);
// check if the user with the jid=conv->name has signed his presence
char* bare_jid = get_bare_jid(conv->name);
// get stored info about user
struct list_item* item = g_hash_table_lookup(list_fingerprints,bare_jid);
if (item == NULL)
{
sprintf(sys_msg_buffer,"No encryption support in client of '%s'",bare_jid);
}else
{
sprintf(sys_msg_buffer,"Client of user %s supports encryption",bare_jid);
}
// display a basic message
purple_conversation_write(conv,"",sys_msg_buffer,PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LOG,time(NULL));
if (item != NULL)
{
char* userid = NULL;
// check if we have key locally
if (is_key_available(item->fpr,FALSE,FALSE,&userid) == FALSE)
{
if (userid != NULL)
free(userid);
userid = NULL;
sprintf(sys_msg_buffer,"User has key with ID '%s', but we do not have it locally, try Options->\"Try to retrieve key of '%s' from server\"",item->fpr,bare_jid);
purple_conversation_write(conv,"",sys_msg_buffer,PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LOG,time(NULL));
}else
{
// key is already available locally -> enable mode_enc
sprintf(sys_msg_buffer,"'%s' uses key with id '%s'/'%s'",bare_jid,userid,item->fpr);
purple_conversation_write(conv,"",sys_msg_buffer,PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LOG,time(NULL));
item->mode_sec = TRUE;
}
if (userid != NULL)
free(userid);
userid = NULL;
// if we have the key now, move to secure mode
if (item->mode_sec == TRUE)
sprintf(sys_msg_buffer,"Encryption enabled");
else
sprintf(sys_msg_buffer,"Encryption disabled");
}else
sprintf(sys_msg_buffer,"Encryption disabled");
// display message about received message
purple_conversation_write(conv,"",sys_msg_buffer,PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LOG,time(NULL));
free(bare_jid);
}
bool PurpleIMChat::addContactCbk(void * dataIn)
{
Mutex::ScopedLock lock(PurpleIMChat::_mutex);
PurpleIMChatCallbackData* cbData = (PurpleIMChatCallbackData*) dataIn;
PurpleIMChat* imChat = cbData->getPurpleIMChat();
IMChatSession* chatSession = cbData->getIMChatSession();
PurpleAccount* gAccount = getPurpleAccount( imChat->getIMAccount() );
// const char * contactId = (const char *)((misc_t *)data)->data_ptr2;
mConvInfo_t *mConv = FindChatStructById(chatSession->getId());
int BuddyNbr = chatSession->getIMContactSet().size();
PurpleConversation *gConv = NULL;
if (mConv)
gConv = mConv->purple_conv_session; //VOXOX - JRT - 2009.07.09
else
LOG_FATAL("ConvInfo not created !!!");
if (purple_conversation_get_type(gConv) == PURPLE_CONV_TYPE_IM)
{
GList *mlist = NULL;
IMContactSet& chatContact = const_cast<IMContactSet&>(chatSession->getIMContactSet());
IMContactSet::const_iterator it = chatContact.begin();
const std::string & firstContactId = it->getContactId();
PurpleConnection *gGC;
gConv = mConv->purple_conv_session; //VOXOX - JRT - 2009.07.09
gGC = purple_conversation_get_gc(gConv);
mlist = g_list_append(mlist, const_cast<char*>(cbData->getContactId().c_str()) );
mlist = g_list_append(mlist, (char *) firstContactId.c_str());
createPurpleChat(gGC, chatSession->getId(), mlist, *imChat, gAccount); //VOXOX - JRT - 2009.07.10
}
else if (purple_conversation_get_type(gConv) == PURPLE_CONV_TYPE_CHAT)
{
serv_chat_invite(purple_conversation_get_gc(gConv), purple_conv_chat_get_id(PURPLE_CONV_CHAT(gConv)), NULL, cbData->getContactId().c_str() );
}
timeoutRemove( cbData );
delete cbData;
return TRUE;
}
void SpectrumConversation::sendMessage(boost::shared_ptr<Swift::Message> &message) {
// escape and send
gchar *_markup = purple_markup_escape_text(message->getBody().c_str(), -1);
if (purple_conversation_get_type(m_conv) == PURPLE_CONV_TYPE_IM) {
purple_conv_im_send(PURPLE_CONV_IM(m_conv), _markup);
}
g_free(_markup);
}
static void
conv_placement_by_number(PidginConversation *conv)
{
PidginWindow *win = NULL;
GList *wins = NULL;
if (purple_prefs_get_bool("/plugins/gtk/extplacement/placement_number_separate"))
win = pidgin_conv_window_last_with_type(purple_conversation_get_type(conv->active_conv));
else if ((wins = pidgin_conv_windows_get_list()) != NULL)
win = g_list_last(wins)->data;
if (win == NULL) {
win = pidgin_conv_window_new();
pidgin_conv_window_add_gtkconv(win, conv);
pidgin_conv_window_show(win);
} else {
int max_count = purple_prefs_get_int("/plugins/gtk/extplacement/placement_number");
int count = pidgin_conv_window_get_gtkconv_count(win);
if (count < max_count)
pidgin_conv_window_add_gtkconv(win, conv);
else {
GList *l = NULL;
for (l = pidgin_conv_windows_get_list(); l != NULL; l = l->next) {
win = l->data;
if (purple_prefs_get_bool("/plugins/gtk/extplacement/placement_number_separate") &&
purple_conversation_get_type(pidgin_conv_window_get_active_conversation(win)) != purple_conversation_get_type(conv->active_conv))
continue;
count = pidgin_conv_window_get_gtkconv_count(win);
if (count < max_count) {
pidgin_conv_window_add_gtkconv(win, conv);
return;
}
}
win = pidgin_conv_window_new();
pidgin_conv_window_add_gtkconv(win, conv);
pidgin_conv_window_show(win);
}
}
}
static void
conv_menu_cb(PurpleConversation *conv, GList **list)
{
PurpleConversationType type = purple_conversation_get_type(conv);
gboolean enabled = ((type == PURPLE_CONV_TYPE_IM && purple_prefs_get_bool(PREF_IMS)) ||
(type == PURPLE_CONV_TYPE_CHAT && purple_prefs_get_bool(PREF_CHATS)));
PurpleMenuAction *action = purple_menu_action_new(_("Jump to markerline"),
enabled ? PURPLE_CALLBACK(jump_to_markerline) : NULL, NULL, NULL);
*list = g_list_append(*list, action);
}
/*------------------------------------------------------------------------
* This gets called when a new chat conversation is opened by the user
*
* @param conv The conversation object
* @param session The MXit session object
*/
static void mxit_cb_chat_created( PurpleConversation* conv, struct MXitSession* session )
{
PurpleConnection* gc;
struct contact* contact;
PurpleBuddy* buddy;
const char* who;
char* tmp;
gc = purple_conversation_get_gc( conv );
if ( session->con != gc ) {
/* not our conversation */
return;
}
else if ( purple_conversation_get_type( conv ) != PURPLE_CONV_TYPE_IM ) {
/* wrong type of conversation */
return;
}
/* get the contact name */
who = purple_conversation_get_name( conv );
if ( !who )
return;
purple_debug_info( MXIT_PLUGIN_ID, "Conversation started with '%s'\n", who );
/* find the buddy object */
buddy = purple_find_buddy( session->acc, who );
if ( !buddy )
return;
contact = purple_buddy_get_protocol_data( buddy );
if ( !contact )
return;
/* we ignore all conversations with which we have chatted with in this session */
if ( find_active_chat( session->active_chats, who ) )
return;
/* determine if this buddy is a MXit service */
switch ( contact->type ) {
case MXIT_TYPE_BOT :
case MXIT_TYPE_CHATROOM :
case MXIT_TYPE_GALLERY :
case MXIT_TYPE_INFO :
tmp = g_strdup_printf("<font color=\"#999999\">%s</font>\n", _( "Loading menu..." ));
serv_got_im( session->con, who, tmp, PURPLE_MESSAGE_NOTIFY, time( NULL ) );
g_free( tmp );
mxit_send_message( session, who, " ", FALSE, FALSE );
default :
break;
}
}
static void
timezone_createconv_cb(PurpleConversation * conv, void *data)
{
const char *name;
PurpleBuddy *buddy;
struct tm tm;
const char *timezone;
double diff;
int ret;
if (purple_conversation_get_type(conv) != PURPLE_CONV_TYPE_IM)
return;
name = purple_conversation_get_name(conv);
buddy = purple_find_buddy(purple_conversation_get_account(conv), name);
if (!buddy)
return;
timezone = buddy_get_timezone((PurpleBlistNode *) buddy, TRUE, NULL);
if (!timezone)
return;
ret = timezone_get_time(timezone, &tm, &diff, NULL);
if (ret == 0)
{
const char *text = purple_time_format(&tm);
char *str;
if (diff < 0)
{
diff = 0 - diff;
str = g_strdup_printf(dngettext(GETTEXT_PACKAGE,
"Remote Local Time: %s (%.4g hour behind)",
"Remote Local Time: %s (%.4g hours behind)", diff),
text, diff);
}
else
{
str = g_strdup_printf(dngettext(GETTEXT_PACKAGE,
"Remote Local Time: %s (%.4g hour ahead)",
"Remote Local Time: %s (%.4g hours ahead)", diff),
text, diff);
}
purple_conversation_write(conv, PLUGIN_STATIC_NAME, str, PURPLE_MESSAGE_SYSTEM, time(NULL));
g_free(str);
}
}
static int
notify(PurpleConversation *conv, gboolean increment)
{
gint count;
gboolean has_focus;
PidginWindow *purplewin = NULL;
if (conv == NULL || PIDGIN_CONVERSATION(conv) == NULL)
return 0;
/* We want to remove the notifications, but not reset the counter */
unnotify(conv, FALSE);
purplewin = PIDGIN_CONVERSATION(conv)->win;
/* If we aren't doing notifications for this type of conversation, return */
if (((purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) &&
!purple_prefs_get_bool("/plugins/gtk/X11/notify/type_im")) ||
((purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) &&
!purple_prefs_get_bool("/plugins/gtk/X11/notify/type_chat")))
return 0;
g_object_get(G_OBJECT(purplewin->window),
"has-toplevel-focus", &has_focus, NULL);
if (purple_prefs_get_bool("/plugins/gtk/X11/notify/type_focused") ||
!has_focus) {
if (increment) {
count = GPOINTER_TO_INT(purple_conversation_get_data(conv, "notify-message-count"));
count++;
purple_conversation_set_data(conv, "notify-message-count", GINT_TO_POINTER(count));
}
notify_win(purplewin, conv);
}
return 0;
}
static gboolean
message_displayed_cb(PurpleAccount *account, const char *who, char *message,
PurpleConversation *conv, PurpleMessageFlags flags)
{
if ((purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT &&
purple_prefs_get_bool("/plugins/gtk/X11/notify/type_chat_nick") &&
!(flags & PURPLE_MESSAGE_NICK)))
return FALSE;
if ((flags & PURPLE_MESSAGE_RECV) && !(flags & PURPLE_MESSAGE_DELAYED))
notify(conv, TRUE);
return FALSE;
}
/**
* A function to send a chat or im message to the specific conversation
* without emitting "sending-im" or "sending-chat" signal, which would
* cause an infinite loop for this plugin.
*
* taken from conversation.c with signal emission removed.
*/
static void
splitter_common_send(PurpleConversation *conv, const char *message,
PurpleMessageFlags msgflags)
{
PurpleConversationType type;
PurpleAccount *account;
PurpleConnection *gc;
char *sent = NULL;
if (strlen(message) == 0)
return;
account = purple_conversation_get_account(conv);
#if PURPLE_VERSION_CHECK(3,0,0)
gc = purple_conversation_get_connection(conv);
#else
gc = purple_conversation_get_gc(conv);
#endif
g_return_if_fail(account != NULL);
g_return_if_fail(gc != NULL);
type = purple_conversation_get_type(conv);
if ((purple_conversation_get_features(conv) & PURPLE_CONNECTION_HTML) &&
!(msgflags & PURPLE_MESSAGE_RAW))
{
sent = purple_markup_linkify(message);
}
else
sent = g_strdup(message);
msgflags |= PURPLE_MESSAGE_SEND;
splitter_injected_message = TRUE;
if (type == PURPLE_CONV_TYPE_IM) {
if (sent != NULL && sent[0] != '\0')
purple_conv_im_send_with_flags(PURPLE_CONV_IM(conv), sent, msgflags);
}
else {
if (sent != NULL && sent[0] != '\0')
purple_conv_chat_send_with_flags(PURPLE_CONV_CHAT(conv), sent, msgflags);
}
splitter_injected_message = FALSE;
g_free(sent);
}
static gboolean
conversation_nick_clicked(PurpleConversation* conv, gchar* nick, guint button)
{
GdkEvent* next_event = NULL;
PidginConversation* pidgin_conv = NULL;
gint event_timeout = 100; /* milliseconds */
if (purple_conversation_get_type(conv) != PURPLE_CONV_TYPE_CHAT)
{
purple_debug_warning(USERCAST_PLUGIN_NAME, "Conversation `%s' is not a chat\n", conv->name);
return FALSE;
}
if (!PIDGIN_IS_PIDGIN_CONVERSATION(conv))
{
purple_debug_warning(USERCAST_PLUGIN_NAME, "Conversation `%s' is not a pidgin conversation\n",
conv->name);
return FALSE;
}
if (button != 1)
return FALSE;
/* Wait for either GDK_2BUTTON_EVENT or something else to arrive */
for (; event_timeout > 0; event_timeout--)
{
if ((next_event = gdk_event_peek()))
break;
g_usleep(1000); /* 1 millisecond */
}
/* Pingin handles GDK_2BUTTON_PRESS separately */
if (next_event && next_event->type == GDK_2BUTTON_PRESS)
{
/* Remove GDK_2BUTTON_PRESS from event queue */
gdk_event_free(next_event);
gdk_event_free(gdk_event_get());
pidgin_conv = PIDGIN_CONVERSATION(conv);
cast_nick(pidgin_conv, nick);
gtk_widget_grab_focus(pidgin_conv->entry);
purple_debug_info(USERCAST_PLUGIN_NAME, "Casted user `%s' to `%s'\n", nick, conv->name);
return TRUE;
}
return FALSE;
}
static int
imhtml_expose_cb(GtkWidget *widget, GdkEventExpose *event, PidginConversation *gtkconv)
{
int y, last_y, offset;
GdkRectangle visible_rect;
GtkTextIter iter;
GdkRectangle buf;
int pad;
PurpleConversation *conv = gtkconv->active_conv;
PurpleConversationType type = purple_conversation_get_type(conv);
if ((type == PURPLE_CONV_TYPE_CHAT && !purple_prefs_get_bool(PREF_CHATS)) ||
(type == PURPLE_CONV_TYPE_IM && !purple_prefs_get_bool(PREF_IMS)))
return FALSE;
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(widget), &visible_rect);
offset = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "markerline"));
if (offset)
{
gtk_text_buffer_get_iter_at_offset(gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget)),
&iter, offset);
gtk_text_view_get_iter_location(GTK_TEXT_VIEW(widget), &iter, &buf);
last_y = buf.y + buf.height;
pad = (gtk_text_view_get_pixels_below_lines(GTK_TEXT_VIEW(widget)) +
gtk_text_view_get_pixels_above_lines(GTK_TEXT_VIEW(widget))) / 2;
last_y += pad;
}
else
last_y = 0;
gtk_text_view_buffer_to_window_coords(GTK_TEXT_VIEW(widget), GTK_TEXT_WINDOW_TEXT,
0, last_y, 0, &y);
if (y >= event->area.y)
{
GdkColor red = {0, 0xffff, 0, 0};
GdkGC *gc = gdk_gc_new(GDK_DRAWABLE(event->window));
gdk_gc_set_rgb_fg_color(gc, &red);
gdk_draw_line(event->window, gc,
0, y, visible_rect.width, y);
g_object_unref(G_OBJECT(gc));
}
return FALSE;
}
static PurpleCmdRet
cmd_func(PurpleConversation *conv, const gchar *cmd, gchar **args,
gchar *error, void *data)
{
GString *msgstr = NULL;
guint32 quotes = 0, quoteid = 0;
msgstr = g_string_new("");
srand(time(NULL));
if(!strcmp(cmd, "bash")) {
g_string_append(msgstr, "http://www.bash.org/?");
quotes = BASH_QUOTES;
} else {
g_string_append(msgstr, "http://qdb.us/");
quotes = QDB_QUOTES;
}
if(*args == NULL || args[0] == NULL)
quoteid = (rand() % quotes) + 1;
else
quoteid = atoi(args[0]);
if(quoteid > quotes)
quoteid %= quotes;
g_string_append_printf(msgstr, "%i", quoteid);
switch(purple_conversation_get_type(conv)) {
case PURPLE_CONV_TYPE_IM:
purple_conv_im_send(PURPLE_CONV_IM(conv), msgstr->str);
break;
case PURPLE_CONV_TYPE_CHAT:
purple_conv_chat_send(PURPLE_CONV_CHAT(conv), msgstr->str);
break;
default:
g_string_free(msgstr, TRUE);
return PURPLE_CMD_RET_FAILED;
}
g_string_free(msgstr, TRUE);
return PURPLE_CMD_RET_OK;
}
PurpleConversation *
jabber_find_unnormalized_conv(const char *name, PurpleAccount *account)
{
PurpleConversation *c = NULL;
GList *cnv;
g_return_val_if_fail(name != NULL, NULL);
for(cnv = purple_get_conversations(); cnv; cnv = cnv->next) {
c = (PurpleConversation*)cnv->data;
if(purple_conversation_get_type(c) == PURPLE_CONV_TYPE_IM &&
!purple_utf8_strcasecmp(name, purple_conversation_get_name(c)) &&
account == purple_conversation_get_account(c))
return c;
}
return NULL;
}
static void
bye_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
{
MsnSwitchBoard *swboard;
const char *user;
swboard = cmdproc->data;
user = cmd->params[0];
/* cmdproc->data is set to NULL when the switchboard is destroyed;
* we may get a bye shortly thereafter. */
g_return_if_fail(swboard != NULL);
if (!(swboard->flag & MSN_SB_FLAG_IM) && (swboard->conv != NULL))
purple_debug_error("msn", "bye_cmd: helper bug\n");
if (swboard->conv == NULL)
{
/* This is a helper switchboard */
msn_switchboard_destroy(swboard);
}
else if ((swboard->current_users > 1) ||
(purple_conversation_get_type(swboard->conv) == PURPLE_CONV_TYPE_CHAT))
{
GList *passport;
/* This is a switchboard used for a chat */
purple_conv_chat_remove_user(PURPLE_CONV_CHAT(swboard->conv), user, NULL);
passport = g_list_find_custom(swboard->users, user, (GCompareFunc)strcmp);
if (passport)
g_free(passport->data);
else
purple_debug_warning("msn", "Can't find user %s in the switchboard\n", user);
swboard->users = g_list_delete_link(swboard->users, passport);
swboard->current_users--;
if (swboard->current_users == 0)
msn_switchboard_destroy(swboard);
}
else
{
/* This is a switchboard used for a im session */
msn_switchboard_destroy(swboard);
}
}
static void _elim_conv_args ( xmlnode *alist, PurpleConversation *conv )
{
PurpleAccount *acct = purple_conversation_get_account( conv );
const char *aname = purple_account_get_username ( acct );
const char *proto = purple_account_get_protocol_id ( acct );
const char *title = purple_conversation_get_title ( conv );
const char *cname = purple_conversation_get_name ( conv );
PurpleConnectionFlags cflag = purple_conversation_get_features( conv );
PurpleConversationType ctype = purple_conversation_get_type ( conv );
fprintf( stderr, "(_elim_conv_args)\n" );
AL_STR ( alist, "account-name" , aname );
AL_STR ( alist, "im-protocol" , proto );
AL_PTR ( alist, "account-uid" , acct );
AL_PTR ( alist, "conv-uid" , conv );
AL_STR ( alist, "conv-name" , cname );
AL_STR ( alist, "conv-title" , title ? title : cname );
AL_ENUM( alist, "conv-type" , ctype , ":conversation-type" );
AL_ENUM( alist, "conv-features", cflag , ":connection-flags" );
}
void irc_msg_pong(struct irc_conn *irc, const char *name, const char *from, char **args)
{
PurpleConversation *convo;
PurpleConnection *gc;
char **parts, *msg;
time_t oldstamp;
if (!args || !args[1])
return;
parts = g_strsplit(args[1], " ", 2);
if (!parts[0] || !parts[1]) {
g_strfreev(parts);
return;
}
if (sscanf(parts[1], "%lu", &oldstamp) != 1) {
msg = g_strdup(_("Error: invalid PONG from server"));
} else {
msg = g_strdup_printf(_("PING reply -- Lag: %lu seconds"), time(NULL) - oldstamp);
}
convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_ANY, parts[0], irc->account);
g_strfreev(parts);
if (convo) {
if (purple_conversation_get_type (convo) == PURPLE_CONV_TYPE_CHAT)
purple_conv_chat_write(PURPLE_CONV_CHAT(convo), "PONG", msg, PURPLE_MESSAGE_SYSTEM|PURPLE_MESSAGE_NO_LOG, time(NULL));
else
purple_conv_im_write(PURPLE_CONV_IM(convo), "PONG", msg, PURPLE_MESSAGE_SYSTEM|PURPLE_MESSAGE_NO_LOG, time(NULL));
} else {
gc = purple_account_get_connection(irc->account);
if (!gc) {
g_free(msg);
return;
}
purple_notify_info(gc, NULL, "PONG", msg);
}
g_free(msg);
}
void
msn_switchboard_show_ink(MsnSwitchBoard *swboard, const char *passport,
const char *data)
{
PurpleConnection *gc;
guchar *image_data;
size_t image_len;
int imgid;
char *image_msg;
if (!purple_str_has_prefix(data, "base64:"))
{
purple_debug_error("msn", "Ignoring Ink not in Base64 format.\n");
return;
}
gc = purple_account_get_connection(swboard->session->account);
data += sizeof("base64:") - 1;
image_data = purple_base64_decode(data, &image_len);
if (!image_data || !image_len)
{
purple_debug_error("msn", "Unable to decode Ink from Base64 format.\n");
return;
}
imgid = purple_imgstore_add_with_id(image_data, image_len, NULL);
image_msg = g_strdup_printf("<IMG ID='%d'/>", imgid);
if (swboard->current_users > 1 ||
((swboard->conv != NULL) &&
purple_conversation_get_type(swboard->conv) == PURPLE_CONV_TYPE_CHAT))
serv_got_chat_in(gc, swboard->chat_id, passport, 0, image_msg,
time(NULL));
else
serv_got_im(gc, passport, image_msg, 0, time(NULL));
purple_imgstore_unref_by_id(imgid);
g_free(image_msg);
}
static gboolean
close_conv_cb(GtkButton *button, PidginConversation *gtkconv)
{
/* We are going to destroy the conversations immediately only if the 'close immediately'
* preference is selected. Otherwise, close the conversation after a reasonable timeout
* (I am going to consider 10 minutes as a 'reasonable timeout' here.
* For chats, close immediately if the chat is not in the buddylist, or if the chat is
* not marked 'Persistent' */
PurpleConversation *conv = gtkconv->active_conv;
PurpleAccount *account = purple_conversation_get_account(conv);
const char *name = purple_conversation_get_name(conv);
switch (purple_conversation_get_type(conv)) {
case PURPLE_CONV_TYPE_IM:
{
if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/im/close_immediately"))
close_this_sucker(gtkconv);
else
hide_conv(gtkconv, TRUE);
break;
}
case PURPLE_CONV_TYPE_CHAT:
{
PurpleChat *chat = purple_blist_find_chat(account, name);
if (!chat ||
!purple_blist_node_get_bool(&chat->node, "gtk-persistent"))
close_this_sucker(gtkconv);
else
hide_conv(gtkconv, FALSE);
break;
}
default:
;
}
return TRUE;
}
static void
bye_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
{
MsnSwitchBoard *swboard;
const char *user;
swboard = cmdproc->data;
user = cmd->params[0];
/* cmdproc->data is set to NULL when the switchboard is destroyed;
* we may get a bye shortly thereafter. */
g_return_if_fail(swboard != NULL);
if (!(swboard->flag & MSN_SB_FLAG_IM) && (swboard->conv != NULL))
purple_debug_error("msn", "bye_cmd: helper bug\n");
if (swboard->conv == NULL)
{
/* This is a helper switchboard */
msn_switchboard_destroy(swboard);
}
else if ((swboard->current_users > 1) ||
(purple_conversation_get_type(swboard->conv) == PURPLE_CONV_TYPE_CHAT))
{
/* This is a switchboard used for a chat */
purple_conv_chat_remove_user(PURPLE_CONV_CHAT(swboard->conv), user, NULL);
swboard->current_users--;
if (swboard->current_users == 0)
msn_switchboard_destroy(swboard);
}
else
{
/* This is a switchboard used for a im session */
msn_switchboard_destroy(swboard);
}
}
void irc_msg_nonick(struct irc_conn *irc, const char *name, const char *from, char **args)
{
PurpleConnection *gc;
PurpleConversation *convo;
convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_ANY, args[1], irc->account);
if (convo) {
if (purple_conversation_get_type(convo) == PURPLE_CONV_TYPE_CHAT) /* does this happen? */
purple_conv_chat_write(PURPLE_CONV_CHAT(convo), args[1], _("no such channel"),
PURPLE_MESSAGE_SYSTEM|PURPLE_MESSAGE_NO_LOG, time(NULL));
else
purple_conv_im_write(PURPLE_CONV_IM(convo), args[1], _("User is not logged in"),
PURPLE_MESSAGE_SYSTEM|PURPLE_MESSAGE_NO_LOG, time(NULL));
} else {
if ((gc = purple_account_get_connection(irc->account)) == NULL)
return;
purple_notify_error(gc, NULL, _("No such nick or channel"), args[1]);
}
if (irc->whois.nick && !purple_utf8_strcasecmp(irc->whois.nick, args[1])) {
g_free(irc->whois.nick);
irc->whois.nick = NULL;
}
}
static void historize(PurpleConversation *c)
{
PurpleAccount *account = purple_conversation_get_account(c);
const char *name = purple_conversation_get_name(c);
PurpleConversationType convtype;
GList *logs = NULL;
const char *alias = name;
PurpleLogReadFlags flags;
char *history;
char *header;
PurpleMessageFlags mflag;
convtype = purple_conversation_get_type(c);
if (convtype == PURPLE_CONV_TYPE_IM) {
GSList *buddies;
GSList *cur;
FinchConv *fc = FINCH_CONV(c);
if (fc->list && fc->list->next) /* We were already in the middle of a conversation. */
return;
/* If we're not logging, don't show anything.
* Otherwise, we might show a very old log. */
if (!purple_prefs_get_bool("/purple/logging/log_ims"))
return;
/* Find buddies for this conversation. */
buddies = purple_find_buddies(account, name);
/* If we found at least one buddy, save the first buddy's alias. */
if (buddies != NULL)
alias = purple_buddy_get_contact_alias((PurpleBuddy *)buddies->data);
for (cur = buddies; cur != NULL; cur = cur->next) {
PurpleBlistNode *node = cur->data;
if ((node != NULL) &&
((purple_blist_node_get_sibling_prev(node) != NULL) ||
(purple_blist_node_get_sibling_next(node) != NULL))) {
PurpleBlistNode *node2;
alias = purple_buddy_get_contact_alias((PurpleBuddy *)node);
/* We've found a buddy that matches this conversation. It's part of a
* PurpleContact with more than one PurpleBuddy. Loop through the PurpleBuddies
* in the contact and get all the logs. */
for (node2 = purple_blist_node_get_first_child(purple_blist_node_get_parent(node));
node2 != NULL ; node2 = purple_blist_node_get_sibling_next(node2)) {
logs = g_list_concat(
purple_log_get_logs(PURPLE_LOG_IM,
purple_buddy_get_name((PurpleBuddy *)node2),
purple_buddy_get_account((PurpleBuddy *)node2)),
logs);
}
break;
}
}
g_slist_free(buddies);
if (logs == NULL)
logs = purple_log_get_logs(PURPLE_LOG_IM, name, account);
else
logs = g_list_sort(logs, purple_log_compare);
} else if (convtype == PURPLE_CONV_TYPE_CHAT) {
/* If we're not logging, don't show anything.
* Otherwise, we might show a very old log. */
if (!purple_prefs_get_bool("/purple/logging/log_chats"))
return;
logs = purple_log_get_logs(PURPLE_LOG_CHAT, name, account);
}
if (logs == NULL)
return;
mflag = PURPLE_MESSAGE_NO_LOG | PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_DELAYED;
history = purple_log_read((PurpleLog*)logs->data, &flags);
header = g_strdup_printf(_("<b>Conversation with %s on %s:</b><br>"), alias,
purple_date_format_full(localtime(&((PurpleLog *)logs->data)->time)));
purple_conversation_write(c, "", header, mflag, time(NULL));
g_free(header);
if (flags & PURPLE_LOG_READ_NO_NEWLINE)
purple_str_strip_char(history, '\n');
purple_conversation_write(c, "", history, mflag, time(NULL));
g_free(history);
purple_conversation_write(c, "", "<hr>", mflag, time(NULL));
g_list_foreach(logs, (GFunc)purple_log_free, NULL);
g_list_free(logs);
}
static void
msn_switchboard_add_user(MsnSwitchBoard *swboard, const char *user)
{
MsnCmdProc *cmdproc;
PurpleAccount *account;
g_return_if_fail(swboard != NULL);
cmdproc = swboard->cmdproc;
account = cmdproc->session->account;
swboard->users = g_list_prepend(swboard->users, g_strdup(user));
swboard->current_users++;
swboard->empty = FALSE;
if (purple_debug_is_verbose())
purple_debug_info("msn", "user=[%s], total=%d\n",
user, swboard->current_users);
if (!(swboard->flag & MSN_SB_FLAG_IM) && (swboard->conv != NULL))
{
/* This is a helper switchboard. */
purple_debug_error("msn", "switchboard_add_user: conv != NULL\n");
return;
}
if ((swboard->conv != NULL) &&
(purple_conversation_get_type(swboard->conv) == PURPLE_CONV_TYPE_CHAT))
{
purple_conv_chat_add_user(PURPLE_CONV_CHAT(swboard->conv), user, NULL,
PURPLE_CBFLAGS_NONE, TRUE);
msn_servconn_set_idle_timeout(swboard->servconn, 0);
}
else if (swboard->current_users > 1 || swboard->total_users > 1)
{
msn_servconn_set_idle_timeout(swboard->servconn, 0);
if (swboard->conv == NULL ||
purple_conversation_get_type(swboard->conv) != PURPLE_CONV_TYPE_CHAT)
{
GList *l;
#if 0
/* this is bad - it causes msn_switchboard_close to be called on the
* switchboard we're in the middle of using :( */
if (swboard->conv != NULL)
purple_conversation_destroy(swboard->conv);
#endif
swboard->chat_id = msn_switchboard_get_chat_id();
swboard->flag |= MSN_SB_FLAG_IM;
swboard->conv = serv_got_joined_chat(account->gc,
swboard->chat_id,
"MSN Chat");
for (l = swboard->users; l != NULL; l = l->next)
{
const char *tmp_user;
tmp_user = l->data;
purple_conv_chat_add_user(PURPLE_CONV_CHAT(swboard->conv),
tmp_user, NULL, PURPLE_CBFLAGS_NONE, TRUE);
}
purple_conv_chat_add_user(PURPLE_CONV_CHAT(swboard->conv),
purple_account_get_username(account),
NULL, PURPLE_CBFLAGS_NONE, TRUE);
g_free(swboard->im_user);
swboard->im_user = NULL;
}
}
else if (swboard->conv == NULL)
{
swboard->conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM,
user, account);
}
else
{
purple_debug_warning("msn", "switchboard_add_user: This should not happen!\n");
}
}
PurpleCmdRet PurpleLine::cmd_open(PurpleConversation *conv,
const gchar *, gchar **args, gchar **error, void *)
{
static std::map<line::ContentType::type, std::string> attachment_extensions = {
{ line::ContentType::IMAGE, ".jpg" },
{ line::ContentType::VIDEO, ".mp4" },
{ line::ContentType::AUDIO, ".mp3" },
};
std::string token(args[0]);
Attachment *att = conv_attachment_get(conv, token);
if (!att) {
*error = g_strdup("No such attachment.");
return PURPLE_CMD_RET_FAILED;
}
if (att->path != "" && g_file_test(att->path.c_str(), G_FILE_TEST_EXISTS)) {
purple_notify_uri(conn, att->path.c_str());
return PURPLE_CMD_RET_OK;
}
// Ensure there's nothing funny about the id as we're going to use it as a path element
try {
std::stoll(att->id);
} catch (...) {
*error = g_strdup("Failed to download attachment.");
return PURPLE_CMD_RET_FAILED;
}
std::string ext = ".jpg";
if (attachment_extensions.count(att->type))
ext = attachment_extensions[att->type];
std::string dir = get_tmp_dir(true);
gchar *path_p = g_build_filename(
dir.c_str(),
(att->id + ext).c_str(),
nullptr);
std::string path(path_p);
g_free(path_p);
purple_conversation_write(
conv,
"",
"Downloading attachment...",
(PurpleMessageFlags)PURPLE_MESSAGE_SYSTEM,
time(NULL));
std::string url = std::string(LINE_OS_URL) + "os/m/"+ att->id;
PurpleConversationType ctype = purple_conversation_get_type(conv);
std::string cname = std::string(purple_conversation_get_name(conv));
http.request(url, HTTPFlag::AUTH | HTTPFlag::LARGE,
[this, path, token, ctype, cname]
(int status, const guchar *data, gsize len)
{
if (status == 200 && data && len > 0) {
g_file_set_contents(path.c_str(), (const char *)data, len, nullptr);
temp_files.push_back(path);
PurpleConversation *conv = purple_find_conversation_with_account(
ctype, cname.c_str(), acct);
if (conv) {
Attachment *att = conv_attachment_get(conv, token);
if (att)
att->path = path;
}
purple_notify_uri(conn, path.c_str());
} else {
notify_error("Failed to download attachment.");
}
});
return PURPLE_CMD_RET_OK;
}
