/* this is a confirmation of yahoo_chat_online(); */
void yahoo_process_chat_online(PurpleConnection *gc, struct yahoo_packet *pkt)
{
YahooData *yd = (YahooData *) gc->proto_data;
if (pkt->status == 1) {
yd->chat_online = TRUE;
/* We need to goto a user in chat */
if (yd->pending_chat_goto) {
struct yahoo_packet *pkt = yahoo_packet_new(YAHOO_SERVICE_CHATGOTO, YAHOO_STATUS_AVAILABLE, yd->session_id);
yahoo_packet_hash(pkt, "sss",
109, yd->pending_chat_goto,
1, purple_connection_get_display_name(gc),
62, "2");
yahoo_packet_send_and_free(pkt, yd);
} else if (yd->pending_chat_room) {
yahoo_chat_join(gc, purple_connection_get_display_name(gc), yd->pending_chat_room,
yd->pending_chat_topic, yd->pending_chat_id);
}
g_free(yd->pending_chat_room);
yd->pending_chat_room = NULL;
g_free(yd->pending_chat_id);
yd->pending_chat_id = NULL;
g_free(yd->pending_chat_topic);
yd->pending_chat_topic = NULL;
g_free(yd->pending_chat_goto);
yd->pending_chat_goto = NULL;
}
}
void yahoo_c_leave(PurpleConnection *gc, int id)
{
YahooData *yd = purple_connection_get_protocol_data(gc);
PurpleChatConversation *c;
if (!yd)
return;
c = purple_conversations_find_chat(gc, id);
if (!c)
return;
if (id != YAHOO_CHAT_ID) {
GList *users;
users = purple_chat_conversation_get_users(c);
yahoo_conf_leave(yd,
purple_conversation_get_name(PURPLE_CONVERSATION(c)),
purple_connection_get_display_name(gc), users);
g_list_free(users);
yd->confs = g_slist_remove(yd->confs, c);
} else {
yahoo_chat_leave(gc, purple_conversation_get_name(PURPLE_CONVERSATION(c)),
purple_connection_get_display_name(gc), TRUE);
}
purple_serv_got_chat_left(gc, id);
}
int yahoo_c_send(PurpleConnection *gc, int id, PurpleMessage *msg)
{
PurpleChatConversation *c;
int ret;
YahooData *yd;
const gchar *what = purple_message_get_contents(msg);
PurpleMessageFlags flags = purple_message_get_flags(msg);
yd = purple_connection_get_protocol_data(gc);
if (!yd)
return -1;
c = purple_conversations_find_chat(gc, id);
if (!c)
return -1;
if (id != YAHOO_CHAT_ID) {
GList *users;
users = purple_chat_conversation_get_users(c);
ret = yahoo_conf_send(gc,
purple_connection_get_display_name(gc),
purple_conversation_get_name(PURPLE_CONVERSATION(c)),
users, what);
g_list_free(users);
} else {
ret = yahoo_chat_send(gc, purple_connection_get_display_name(gc),
purple_conversation_get_name(PURPLE_CONVERSATION(c)), what, flags);
if (!ret)
purple_serv_got_chat_in(gc, purple_chat_conversation_get_id(c),
purple_connection_get_display_name(gc), flags, what, time(NULL));
}
return ret;
}
static int waprpl_send_chat(PurpleConnection *gc, int id, const char *message, PurpleMessageFlags flags) {
whatsapp_connection * wconn = purple_connection_get_protocol_data(gc);
PurpleAccount *account = purple_connection_get_account(gc);
PurpleConversation *convo = purple_find_chat(gc, id);
PurpleBlistNode* node = purple_blist_get_root();
GHashTable* hasht = NULL;
while (node != 0) {
if (PURPLE_BLIST_NODE_IS_CHAT(node)) {
PurpleChat * ch = PURPLE_CHAT(node);
if (purple_chat_get_account(ch) == account) {
hasht = purple_chat_get_components(ch);
if (chatid_to_convo(g_hash_table_lookup(hasht, "id")) == id) {
break;
}
}
}
node = purple_blist_node_next(node,FALSE);
}
char * chat_id = g_hash_table_lookup(hasht, "id");
waAPI_sendchat(wconn->waAPI,chat_id,message);
waprpl_check_output(gc);
serv_got_chat_in(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(convo)), purple_connection_get_display_name(gc), PURPLE_MESSAGE_SEND, message, time(NULL));
purple_conv_im_write(PURPLE_CONV_CHAT(convo), purple_connection_get_display_name(gc), message, PURPLE_MESSAGE_SEND, time(NULL));
return 1;
}
int yahoo_c_send(PurpleConnection *gc, int id, const char *what, PurpleMessageFlags flags)
{
PurpleConversation *c;
int ret;
YahooData *yd;
yd = (YahooData *) gc->proto_data;
if (!yd)
return -1;
c = purple_find_chat(gc, id);
if (!c)
return -1;
if (id != YAHOO_CHAT_ID) {
ret = yahoo_conf_send(gc, purple_connection_get_display_name(gc),
purple_conversation_get_name(c), purple_conv_chat_get_users(PURPLE_CONV_CHAT(c)), what);
} else {
ret = yahoo_chat_send(gc, purple_connection_get_display_name(gc),
purple_conversation_get_name(c), what, flags);
if (!ret)
serv_got_chat_in(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(c)),
purple_connection_get_display_name(gc), flags, what, time(NULL));
}
return ret;
}
void yahoo_c_join(PurpleConnection *gc, GHashTable *data)
{
YahooData *yd;
char *room, *topic, *type;
PurpleConversation *c;
yd = (YahooData *) gc->proto_data;
if (!yd)
return;
room = g_hash_table_lookup(data, "room");
if (!room)
return;
topic = g_hash_table_lookup(data, "topic");
if (!topic)
topic = "";
if ((type = g_hash_table_lookup(data, "type")) && !strcmp(type, "Conference")) {
int id;
const char *members = g_hash_table_lookup(data, "members");
id = yd->conf_id++;
c = serv_got_joined_chat(gc, id, room);
yd->confs = g_slist_prepend(yd->confs, c);
purple_conv_chat_set_topic(PURPLE_CONV_CHAT(c), purple_connection_get_display_name(gc), topic);
yahoo_conf_join(yd, c, purple_connection_get_display_name(gc), room, topic, members);
return;
} else {
const char *id;
/*if (yd->in_chat)
yahoo_chat_leave(gc, room,
purple_connection_get_display_name(gc),
FALSE);*/
id = g_hash_table_lookup(data, "id");
if (!yd->chat_online) {
yahoo_chat_online(gc);
g_free(yd->pending_chat_room);
yd->pending_chat_room = g_strdup(room);
g_free(yd->pending_chat_id);
yd->pending_chat_id = g_strdup(id);
g_free(yd->pending_chat_topic);
yd->pending_chat_topic = g_strdup(topic);
g_free(yd->pending_chat_goto);
yd->pending_chat_goto = NULL;
} else {
yahoo_chat_join(gc, purple_connection_get_display_name(gc), room, topic, id);
}
return;
}
}
void irc_msg_nick(struct irc_conn *irc, const char *name, const char *from, char **args)
{
PurpleConnection *gc = purple_account_get_connection(irc->account);
PurpleConversation *conv;
GSList *chats;
char *nick = irc_mask_nick(from);
irc->nickused = FALSE;
if (!gc) {
g_free(nick);
return;
}
chats = gc->buddy_chats;
if (!purple_utf8_strcasecmp(nick, purple_connection_get_display_name(gc))) {
purple_connection_set_display_name(gc, args[0]);
}
while (chats) {
PurpleConvChat *chat = PURPLE_CONV_CHAT(chats->data);
/* This is ugly ... */
if (purple_conv_chat_find_user(chat, nick))
purple_conv_chat_rename_user(chat, nick, args[0]);
chats = chats->next;
}
conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, nick,
irc->account);
if (conv != NULL)
purple_conversation_set_name(conv, args[0]);
g_free(nick);
}
void irc_msg_kick(struct irc_conn *irc, const char *name, const char *from, char **args)
{
PurpleConnection *gc = purple_account_get_connection(irc->account);
PurpleConversation *convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, args[0], irc->account);
char *nick = irc_mask_nick(from), *buf;
if (!gc) {
g_free(nick);
return;
}
if (!convo) {
purple_debug(PURPLE_DEBUG_ERROR, "irc", "Recieved a KICK for unknown channel %s\n", args[0]);
g_free(nick);
return;
}
if (!purple_utf8_strcasecmp(purple_connection_get_display_name(gc), args[1])) {
buf = g_strdup_printf(_("You have been kicked by %s: (%s)"), nick, args[2]);
purple_conv_chat_write(PURPLE_CONV_CHAT(convo), args[0], buf, PURPLE_MESSAGE_SYSTEM, time(NULL));
g_free(buf);
serv_got_chat_left(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(convo)));
} else {
buf = g_strdup_printf(_("Kicked by %s (%s)"), nick, args[2]);
purple_conv_chat_remove_user(PURPLE_CONV_CHAT(convo), args[1], buf);
g_free(buf);
}
g_free(nick);
return;
}
static void ycht_got_connected(gpointer data, gint source, const gchar *error_message)
{
YchtConn *ycht = data;
PurpleConnection *gc = ycht->gc;
YahooData *yd = purple_connection_get_protocol_data(gc);
YchtPkt *pkt;
char *buf;
if (source < 0) {
ycht_connection_error(ycht, _("Unable to connect"));
return;
}
ycht->fd = source;
pkt = ycht_packet_new(YCHT_VERSION, YCHT_SERVICE_LOGIN, 0);
buf = g_strdup_printf("%s\001Y=%s; T=%s", purple_connection_get_display_name(gc), yd->cookie_y, yd->cookie_t);
ycht_packet_append(pkt, buf);
g_free(buf);
ycht_packet_send(ycht, pkt);
ycht_packet_free(pkt);
ycht->inpa = purple_input_add(ycht->fd, PURPLE_INPUT_READ, ycht_pending, ycht);
}
void yahoo_c_invite(PurpleConnection *gc, int id, const char *msg, const char *name)
{
PurpleConversation *c;
c = purple_find_chat(gc, id);
if (!c || !c->name)
return;
if (id != YAHOO_CHAT_ID) {
yahoo_conf_invite(gc, c, purple_connection_get_display_name(gc), name,
purple_conversation_get_name(c), msg);
} else {
yahoo_chat_invite(gc, purple_connection_get_display_name(gc), name,
purple_conversation_get_name(c), msg);
}
}
void yahoo_chat_goto(PurpleConnection *gc, const char *name)
{
YahooData *yd;
struct yahoo_packet *pkt;
yd = gc->proto_data;
if (yd->wm) {
g_return_if_fail(yd->ycht != NULL);
ycht_chat_goto_user(yd->ycht, name);
return;
}
if (!yd->chat_online) {
yahoo_chat_online(gc);
g_free(yd->pending_chat_room);
yd->pending_chat_room = NULL;
g_free(yd->pending_chat_id);
yd->pending_chat_id = NULL;
g_free(yd->pending_chat_topic);
yd->pending_chat_topic = NULL;
g_free(yd->pending_chat_goto);
yd->pending_chat_goto = g_strdup(name);
return;
}
pkt = yahoo_packet_new(YAHOO_SERVICE_CHATGOTO, YAHOO_STATUS_AVAILABLE, yd->session_id);
yahoo_packet_hash(pkt, "sss", 109, name, 1, purple_connection_get_display_name(gc), 62, "2");
yahoo_packet_send_and_free(pkt, yd);
}
static void yahoo_chat_join(PurpleConnection *gc, const char *dn, const char *room, const char *topic, const char *id)
{
YahooData *yd = gc->proto_data;
struct yahoo_packet *pkt;
char *room2;
gboolean utf8 = TRUE;
if (yd->wm) {
g_return_if_fail(yd->ycht != NULL);
ycht_chat_join(yd->ycht, room);
return;
}
/* apparently room names are always utf8, or else always not utf8,
* so we don't have to actually pass the flag in the packet. Or something. */
room2 = yahoo_string_encode(gc, room, &utf8);
pkt = yahoo_packet_new(YAHOO_SERVICE_CHATJOIN, YAHOO_STATUS_AVAILABLE, yd->session_id);
yahoo_packet_hash(pkt, "ssss",
1, purple_connection_get_display_name(gc),
104, room2,
62, "2",
129, id ? id : "0");
yahoo_packet_send_and_free(pkt, yd);
g_free(room2);
}
static int irc_chat_send(PurpleConnection *gc, int id, const char *what, PurpleMessageFlags flags)
{
struct irc_conn *irc = gc->proto_data;
PurpleConversation *convo = purple_find_chat(gc, id);
const char *args[2];
char *tmp;
if (!convo) {
purple_debug(PURPLE_DEBUG_ERROR, "irc", "chat send on nonexistent chat\n");
return -EINVAL;
}
#if 0
if (*what == '/') {
return irc_parse_cmd(irc, convo->name, what + 1);
}
#endif
purple_markup_html_to_xhtml(what, NULL, &tmp);
args[0] = convo->name;
args[1] = tmp;
irc_cmd_privmsg(irc, "msg", NULL, args);
serv_got_chat_in(gc, id, purple_connection_get_display_name(gc), 0, what, time(NULL));
g_free(tmp);
return 0;
}
/* this is basicly the opposite of chat_online */
void yahoo_process_chat_logout(PurpleConnection *gc, struct yahoo_packet *pkt)
{
YahooData *yd = (YahooData *) gc->proto_data;
GSList *l;
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
if (pair->key == 1)
if (g_ascii_strcasecmp(pair->value,
purple_connection_get_display_name(gc)))
return;
}
if (pkt->status == 1) {
yd->chat_online = FALSE;
g_free(yd->pending_chat_room);
yd->pending_chat_room = NULL;
g_free(yd->pending_chat_id);
yd->pending_chat_id = NULL;
g_free(yd->pending_chat_topic);
yd->pending_chat_topic = NULL;
g_free(yd->pending_chat_goto);
yd->pending_chat_goto = NULL;
if (yd->in_chat)
yahoo_c_leave(gc, YAHOO_CHAT_ID);
}
}
void yahoo_set_userinfo(PurpleConnection *gc)
{
YahooData *yd = purple_connection_get_protocol_data(gc);
PurpleRequestFields *fields = request_fields_from_personal_details(&yd->ypd,
purple_connection_get_display_name(gc));
purple_request_fields(gc, NULL, _("Set User Info"), NULL, fields,
_("OK"), G_CALLBACK(yahoo_set_userinfo_cb),
_("Cancel"), NULL,
purple_connection_get_account(gc), NULL, NULL, gc);
}
static gboolean do_login(PurpleConnection *gc) {
char *buf, *tmp = NULL;
char hostname[256];
const char *username, *realname;
struct irc_conn *irc = gc->proto_data;
const char *pass = purple_connection_get_password(gc);
if (pass && *pass) {
buf = irc_format(irc, "vv", "PASS", pass);
if (irc_send(irc, buf) < 0) {
/* purple_connection_error(gc, "Error sending password"); */
g_free(buf);
return FALSE;
}
g_free(buf);
}
gethostname(hostname, sizeof(hostname));
hostname[sizeof(hostname) - 1] = '\0';
realname = purple_account_get_string(irc->account, "realname", "");
username = purple_account_get_string(irc->account, "username", "");
if (username == NULL || *username == '\0') {
username = g_get_user_name();
}
if (username != NULL && strchr(username, ' ') != NULL) {
tmp = g_strdup(username);
while ((buf = strchr(tmp, ' ')) != NULL) {
*buf = '_';
}
}
buf = irc_format(irc, "vvvv:", "USER", tmp ? tmp : username, hostname, irc->server,
strlen(realname) ? realname : IRC_DEFAULT_ALIAS);
g_free(tmp);
if (irc_send(irc, buf) < 0) {
/* purple_connection_error(gc, "Error registering with server");*/
g_free(buf);
return FALSE;
}
g_free(buf);
buf = irc_format(irc, "vn", "NICK", purple_connection_get_display_name(gc));
if (irc_send(irc, buf) < 0) {
/* purple_connection_error(gc, "Error sending nickname");*/
g_free(buf);
return FALSE;
}
g_free(buf);
irc->recv_time = time(NULL);
return TRUE;
}
void jabber_presence_fake_to_self(JabberStream *js, PurpleStatus *status)
{
PurpleAccount *account;
PurplePresence *presence;
JabberBuddy *jb;
JabberBuddyResource *jbr;
const char *username;
JabberBuddyState state;
char *msg;
int priority;
g_return_if_fail(js->user != NULL);
account = purple_connection_get_account(js->gc);
username = purple_connection_get_display_name(js->gc);
presence = purple_account_get_presence(account);
if (status == NULL)
status = purple_presence_get_active_status(presence);
purple_status_to_jabber(status, &state, &msg, &priority);
jb = js->user_jb;
if (state == JABBER_BUDDY_STATE_UNAVAILABLE ||
state == JABBER_BUDDY_STATE_UNKNOWN) {
jabber_buddy_remove_resource(jb, js->user->resource);
} else {
jbr = jabber_buddy_track_resource(jb, js->user->resource, priority,
state, msg);
jbr->idle = purple_presence_is_idle(presence) ?
purple_presence_get_idle_time(presence) : 0;
}
/*
* While we need to track the status of this resource, the core
* only cares if we're on our own buddy list.
*/
if (purple_find_buddy(account, username)) {
jbr = jabber_buddy_find_resource(jb, NULL);
if (jbr) {
purple_prpl_got_user_status(account, username,
jabber_buddy_state_get_status_id(jbr->state),
"priority", jbr->priority,
jbr->status ? "message" : NULL, jbr->status,
NULL);
purple_prpl_got_user_idle(account, username, jbr->idle, jbr->idle);
} else {
purple_prpl_got_user_status(account, username, "offline",
msg ? "message" : NULL, msg,
NULL);
}
}
g_free(msg);
}
void irc_msg_join(struct irc_conn *irc, const char *name, const char *from, char **args)
{
PurpleConnection *gc = purple_account_get_connection(irc->account);
PurpleConversation *convo;
char *nick = irc_mask_nick(from), *userhost;
struct irc_buddy *ib;
static int id = 1;
if (!gc) {
g_free(nick);
return;
}
if (!purple_utf8_strcasecmp(nick, purple_connection_get_display_name(gc))) {
/* We are joining a channel for the first time */
serv_got_joined_chat(gc, id++, args[0]);
g_free(nick);
convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT,
args[0],
irc->account);
if (convo == NULL) {
purple_debug_error("irc", "tried to join %s but couldn't\n", args[0]);
return;
}
purple_conversation_set_data(convo, IRC_NAMES_FLAG,
GINT_TO_POINTER(FALSE));
/* Until purple_conversation_present does something that
* one would expect in Pidgin, this call produces buggy
* behavior both for the /join and auto-join cases. */
/* purple_conversation_present(convo); */
return;
}
convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, args[0], irc->account);
if (convo == NULL) {
purple_debug(PURPLE_DEBUG_ERROR, "irc", "JOIN for %s failed\n", args[0]);
g_free(nick);
return;
}
userhost = irc_mask_userhost(from);
purple_conv_chat_add_user(PURPLE_CONV_CHAT(convo), nick, userhost, PURPLE_CBFLAGS_NONE, TRUE);
if ((ib = g_hash_table_lookup(irc->buddies, nick)) != NULL) {
ib->flag = TRUE;
irc_buddy_status(nick, ib, irc);
}
g_free(userhost);
g_free(nick);
}
void yahoo_c_leave(PurpleConnection *gc, int id)
{
YahooData *yd = (YahooData *) gc->proto_data;
PurpleConversation *c;
if (!yd)
return;
c = purple_find_chat(gc, id);
if (!c)
return;
if (id != YAHOO_CHAT_ID) {
yahoo_conf_leave(yd, purple_conversation_get_name(c),
purple_connection_get_display_name(gc), purple_conv_chat_get_users(PURPLE_CONV_CHAT(c)));
yd->confs = g_slist_remove(yd->confs, c);
} else {
yahoo_chat_leave(gc, purple_conversation_get_name(c), purple_connection_get_display_name(gc), TRUE);
}
serv_got_chat_left(gc, id);
}
/* special function to log us on to the yahoo chat service */
static void yahoo_chat_online(PurpleConnection *gc)
{
YahooData *yd = gc->proto_data;
struct yahoo_packet *pkt;
const char *rll;
if (yd->wm) {
ycht_connection_open(gc);
return;
}
rll = purple_account_get_string(purple_connection_get_account(gc),
"room_list_locale", YAHOO_ROOMLIST_LOCALE);
pkt = yahoo_packet_new(YAHOO_SERVICE_CHATONLINE, YAHOO_STATUS_AVAILABLE, yd->session_id);
yahoo_packet_hash(pkt, "sssss",
109, purple_connection_get_display_name(gc),
1, purple_connection_get_display_name(gc),
6, "abcde",
/* I'm not sure this is the correct way to set this. */
98, rll,
135, yd->jp ? YAHOO_CLIENT_VERSION : YAHOOJP_CLIENT_VERSION);
yahoo_packet_send_and_free(pkt, yd);
}
static void
yahoo_send_userinfo_to_user(struct yahoo_userinfo *yui, const char *who)
{
struct yahoo_packet *pkt;
PurpleConnection *gc;
gc = yui->yd->gc;
pkt = yahoo_packet_new(YAHOO_SERVICE_CONTACT_DETAILS, 0, 0);
yahoo_packet_hash(pkt, "siisis",
1, purple_connection_get_display_name(gc),
13, 1, /* This creates a conversation window in the official client */
302, 5,
5, who,
303, 5,
280, yui->xml);
yahoo_packet_send_and_free(pkt, yui->yd);
}
static void prplcb_conn_connected(PurpleConnection *gc)
{
struct im_connection *ic = purple_ic_by_gc(gc);
const char *dn;
set_t *s;
imcb_connected(ic);
if ((dn = purple_connection_get_display_name(gc)) &&
(s = set_find(&ic->acc->set, "display_name"))) {
g_free(s->value);
s->value = g_strdup(dn);
}
// user list needs to be requested for Gadu-Gadu
purple_gg_buddylist_import(gc);
ic->flags |= OPT_DOES_HTML;
}
static void irc_msg_handle_privmsg(struct irc_conn *irc, const char *name, const char *from, const char *to, const char *rawmsg, gboolean notice)
{
PurpleConnection *gc = purple_account_get_connection(irc->account);
PurpleConversation *convo;
char *tmp;
char *msg;
char *nick;
if (!gc)
return;
nick = irc_mask_nick(from);
tmp = irc_parse_ctcp(irc, nick, to, rawmsg, notice);
if (!tmp) {
g_free(nick);
return;
}
msg = irc_escape_privmsg(tmp, -1);
g_free(tmp);
tmp = irc_mirc2html(msg);
g_free(msg);
msg = tmp;
if (notice) {
tmp = g_strdup_printf("(notice) %s", msg);
g_free(msg);
msg = tmp;
}
if (!purple_utf8_strcasecmp(to, purple_connection_get_display_name(gc))) {
serv_got_im(gc, nick, msg, 0, time(NULL));
} else {
convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, to, irc->account);
if (convo)
serv_got_chat_in(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(convo)), nick, 0, msg, time(NULL));
else
purple_debug_error("irc", "Got a %s on %s, which does not exist\n",
notice ? "NOTICE" : "PRIVMSG", to);
}
g_free(msg);
g_free(nick);
}
static void
signed_on_cb(PurpleConnection *gc)
{
/* should this be done on a timeout? */
PurpleAccount *account = NULL;
const gchar *nick = NULL, *setmodes = NULL, *unsetmodes = NULL, *autojoin = NULL;
gchar *msg = NULL, *msg2 = NULL;
account = purple_connection_get_account(gc);
/* hopefully prevent crashes related to non-IRC accounts signing on */
if(strcmp("prpl-irc", purple_account_get_protocol_id(account)))
return;
nick = purple_connection_get_display_name(gc);
setmodes = SET_UMODES;
unsetmodes = UNSET_UMODES;
autojoin = AUTOJOIN;
if(setmodes && *setmodes) {
msg = g_strdup_printf("MODE %s +%s\r\n", nick, setmodes);
purple_debug_info("irc-more", "Sending command: %s\n", msg);
irc_info->send_raw(gc, msg, strlen(msg));
g_free(msg);
}
if(unsetmodes && *unsetmodes) {
msg2 = g_strdup_printf("MODE %s -%s\r\n", nick, unsetmodes);
purple_debug_info("irc-more", "Sending command: %s\n", msg);
irc_info->send_raw(gc, msg2, strlen(msg2));
g_free(msg2);
}
if(autojoin && *autojoin)
purple_timeout_add_seconds(6, autojoin_cb, account);
return;
}
void irc_msg_part(struct irc_conn *irc, const char *name, const char *from, char **args)
{
PurpleConnection *gc = purple_account_get_connection(irc->account);
PurpleConversation *convo;
char *nick, *msg, *channel;
if (!args || !args[0] || !gc)
return;
/* Undernet likes to :-quote the channel name, for no good reason
* that I can see. This catches that. */
channel = (args[0][0] == ':') ? &args[0][1] : args[0];
convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, channel, irc->account);
if (!convo) {
purple_debug(PURPLE_DEBUG_INFO, "irc", "Got a PART on %s, which doesn't exist -- probably closed\n", channel);
return;
}
nick = irc_mask_nick(from);
if (!purple_utf8_strcasecmp(nick, purple_connection_get_display_name(gc))) {
char *escaped = g_markup_escape_text(args[1], -1);
msg = g_strdup_printf(_("You have parted the channel%s%s"),
(args[1] && *args[1]) ? ": " : "",
(escaped && *escaped) ? escaped : "");
g_free(escaped);
purple_conv_chat_write(PURPLE_CONV_CHAT(convo), channel, msg, PURPLE_MESSAGE_SYSTEM, time(NULL));
g_free(msg);
serv_got_chat_left(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(convo)));
} else {
msg = args[1] ? irc_mirc2txt(args[1]) : NULL;
purple_conv_chat_remove_user(PURPLE_CONV_CHAT(convo), nick, msg);
g_free(msg);
}
g_free(nick);
}
static void
yahoo_fetch_aliases_cb(PurpleUtilFetchUrlData *url_data, gpointer user_data, const gchar *url_text, size_t len, const gchar *error_message)
{
PurpleConnection *gc = user_data;
YahooData *yd = gc->proto_data;
yd->url_datas = g_slist_remove(yd->url_datas, url_data);
if (len == 0) {
purple_debug_info("yahoo", "No Aliases to process.%s%s\n",
error_message ? " Error:" : "", error_message ? error_message : "");
} else {
gchar *full_name, *nick_name;
const char *yid, *id, *fn, *ln, *nn, *alias, *mn;
const char *hp, *wp, *mo;
YahooFriend *f;
PurpleBuddy *b;
xmlnode *item, *contacts;
PurpleAccount *account;
account = purple_connection_get_account(gc);
/* Put our web response into a xmlnode for easy management */
contacts = xmlnode_from_str(url_text, -1);
if (contacts == NULL) {
purple_debug_error("yahoo", "Badly formed Alias XML\n");
return;
}
purple_debug_info("yahoo", "Fetched %" G_GSIZE_FORMAT
" bytes of alias data\n", len);
/* Loop around and around and around until we have gone through all the received aliases */
for(item = xmlnode_get_child(contacts, "ct"); item; item = xmlnode_get_next_twin(item)) {
/* Yahoo replies with two types of contact (ct) record, we are only interested in the alias ones */
if ((yid = xmlnode_get_attrib(item, "yi"))) {
YahooPersonalDetails *ypd = NULL;
/* Grab all the bits of information we can */
fn = xmlnode_get_attrib(item, "fn");
ln = xmlnode_get_attrib(item, "ln");
nn = xmlnode_get_attrib(item, "nn");
mn = xmlnode_get_attrib(item, "mn");
id = xmlnode_get_attrib(item, "id");
hp = xmlnode_get_attrib(item, "hp");
wp = xmlnode_get_attrib(item, "wp");
mo = xmlnode_get_attrib(item, "mo");
full_name = nick_name = NULL;
alias = NULL;
/* Yahoo stores first and last names separately, lets put them together into a full name */
if (yd->jp)
full_name = g_strstrip(g_strdup_printf("%s %s", (ln != NULL ? ln : "") , (fn != NULL ? fn : "")));
else
full_name = g_strstrip(g_strdup_printf("%s %s", (fn != NULL ? fn : "") , (ln != NULL ? ln : "")));
nick_name = (nn != NULL ? g_strstrip(g_strdup(nn)) : NULL);
if (nick_name != NULL)
alias = nick_name; /* If we have a nickname from Yahoo, let's use it */
else if (strlen(full_name) != 0)
alias = full_name; /* If no Yahoo nickname, we can use the full_name created above */
/* Find the local buddy that matches */
f = yahoo_friend_find(gc, yid);
b = purple_find_buddy(account, yid);
/* If we don't find a matching buddy, ignore the alias !! */
if (f != NULL && b != NULL) {
const char *buddy_alias = purple_buddy_get_alias(b);
yahoo_friend_set_alias_id(f, id);
/* Finally, if we received an alias, we better update the buddy list */
if (alias != NULL) {
serv_got_alias(gc, yid, alias);
purple_debug_info("yahoo", "Fetched alias '%s' (%s)\n", alias, id);
} else if (buddy_alias != NULL && strcmp(buddy_alias, "") != 0) {
/* Or if we have an alias that Yahoo doesn't, send it up */
yahoo_update_alias(gc, yid, buddy_alias);
purple_debug_info("yahoo", "Sent updated alias '%s'\n", buddy_alias);
}
}
if (f != NULL)
ypd = &f->ypd;
else {
/* May be the alias is for the account? */
const char *yidn = purple_normalize(account, yid);
if (purple_strequal(yidn, purple_connection_get_display_name(gc))) {
ypd = &yd->ypd;
}
}
if (ypd) {
yahoo_personal_details_reset(ypd, TRUE);
ypd->id = g_strdup(id);
ypd->names.first = g_strdup(fn);
ypd->names.middle = g_strdup(mn);
ypd->names.last = g_strdup(ln);
ypd->names.nick = g_strdup(nn);
ypd->phone.work = g_strdup(wp);
ypd->phone.home = g_strdup(hp);
ypd->phone.mobile = g_strdup(mo);
}
g_free(full_name);
g_free(nick_name);
}
}
xmlnode_free(contacts);
}
}
static void yahoo_sendfile_connected(gpointer data, gint source, const gchar *error_message)
{
PurpleXfer *xfer;
struct yahoo_xfer_data *xd;
struct yahoo_packet *pkt;
gchar *size, *filename, *encoded_filename, *header;
guchar *pkt_buf;
const char *host;
int port;
size_t content_length, header_len, pkt_buf_len;
PurpleConnection *gc;
PurpleAccount *account;
struct yahoo_data *yd;
purple_debug(PURPLE_DEBUG_INFO, "yahoo",
"AAA - in yahoo_sendfile_connected\n");
if (!(xfer = data))
return;
if (!(xd = xfer->data))
return;
if (source < 0) {
purple_xfer_error(PURPLE_XFER_RECEIVE, purple_xfer_get_account(xfer),
xfer->who, _("Unable to connect."));
purple_xfer_cancel_remote(xfer);
return;
}
xfer->fd = source;
/* Assemble the tx buffer */
gc = xd->gc;
account = purple_connection_get_account(gc);
yd = gc->proto_data;
pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANSFER,
YAHOO_STATUS_AVAILABLE, yd->session_id);
size = g_strdup_printf("%" G_GSIZE_FORMAT, purple_xfer_get_size(xfer));
filename = g_path_get_basename(purple_xfer_get_local_filename(xfer));
encoded_filename = yahoo_string_encode(gc, filename, NULL);
yahoo_packet_hash(pkt, "sssss", 0, purple_connection_get_display_name(gc),
5, xfer->who, 14, "", 27, encoded_filename, 28, size);
g_free(size);
g_free(encoded_filename);
g_free(filename);
content_length = YAHOO_PACKET_HDRLEN + yahoo_packet_length(pkt);
pkt_buf_len = yahoo_packet_build(pkt, 8, FALSE, yd->jp, &pkt_buf);
yahoo_packet_free(pkt);
host = purple_account_get_string(account, "xfer_host", YAHOO_XFER_HOST);
port = purple_account_get_int(account, "xfer_port", YAHOO_XFER_PORT);
header = g_strdup_printf(
"POST http://%s:%d/notifyft HTTP/1.0\r\n"
"Content-length: %" G_GSIZE_FORMAT "\r\n"
"Host: %s:%d\r\n"
"Cookie: Y=%s; T=%s\r\n"
"\r\n",
host, port, content_length + 4 + purple_xfer_get_size(xfer),
host, port, yd->cookie_y, yd->cookie_t);
header_len = strlen(header);
xd->txbuflen = header_len + pkt_buf_len + 4;
xd->txbuf = g_malloc(xd->txbuflen);
memcpy(xd->txbuf, header, header_len);
g_free(header);
memcpy(xd->txbuf + header_len, pkt_buf, pkt_buf_len);
g_free(pkt_buf);
memcpy(xd->txbuf + header_len + pkt_buf_len, "29\xc0\x80", 4);
xd->txbuf_written = 0;
if (xd->tx_handler == 0)
{
xd->tx_handler = purple_input_add(source, PURPLE_INPUT_WRITE,
yahoo_sendfile_send_cb, xfer);
yahoo_sendfile_send_cb(xfer, source, PURPLE_INPUT_WRITE);
}
}
static gboolean do_login(PurpleConnection *gc) {
char *buf, *tmp = NULL;
char *server;
const char *nickname, *identname, *realname;
struct irc_conn *irc = gc->proto_data;
const char *pass = purple_connection_get_password(gc);
#ifdef HAVE_CYRUS_SASL
const gboolean use_sasl = purple_account_get_bool(irc->account, "sasl", FALSE);
#endif
if (pass && *pass) {
#ifdef HAVE_CYRUS_SASL
if (use_sasl)
buf = irc_format(irc, "vv:", "CAP", "REQ", "sasl");
else /* intended to fall through */
#endif
buf = irc_format(irc, "v:", "PASS", pass);
if (irc_send(irc, buf) < 0) {
g_free(buf);
return FALSE;
}
g_free(buf);
}
realname = purple_account_get_string(irc->account, "realname", "");
identname = purple_account_get_string(irc->account, "username", "");
if (identname == NULL || *identname == '\0') {
identname = g_get_user_name();
}
if (identname != NULL && strchr(identname, ' ') != NULL) {
tmp = g_strdup(identname);
while ((buf = strchr(tmp, ' ')) != NULL) {
*buf = '_';
}
}
if (*irc->server == ':') {
/* Same as hostname, above. */
server = g_strdup_printf("0%s", irc->server);
} else {
server = g_strdup(irc->server);
}
buf = irc_format(irc, "vvvv:", "USER", tmp ? tmp : identname, "*", server,
strlen(realname) ? realname : IRC_DEFAULT_ALIAS);
g_free(tmp);
g_free(server);
if (irc_send(irc, buf) < 0) {
g_free(buf);
return FALSE;
}
g_free(buf);
nickname = purple_connection_get_display_name(gc);
buf = irc_format(irc, "vn", "NICK", nickname);
irc->reqnick = g_strdup(nickname);
irc->nickused = FALSE;
if (irc_send(irc, buf) < 0) {
g_free(buf);
return FALSE;
}
g_free(buf);
irc->recv_time = time(NULL);
return TRUE;
}
static void
yahoo_set_userinfo_cb(PurpleConnection *gc, PurpleRequestFields *fields)
{
xmlnode *node = xmlnode_new("ab");
xmlnode *ct = xmlnode_new_child(node, "ct");
YahooData *yd = purple_connection_get_protocol_data(gc);
PurpleAccount *account;
PurpleUtilFetchUrlData *url_data;
char *webaddress, *webpage;
char *request, *content;
int len;
int i;
char * yfields[] = { "fn", "ln", "nn", "mn", "hp", "wp", "mo", NULL };
account = purple_connection_get_account(gc);
xmlnode_set_attrib(node, "k", purple_connection_get_display_name(gc));
xmlnode_set_attrib(node, "cc", "1"); /* XXX: ? */
xmlnode_set_attrib(ct, "e", "1");
xmlnode_set_attrib(ct, "yi", purple_request_fields_get_string(fields, "yname"));
xmlnode_set_attrib(ct, "id", purple_request_fields_get_string(fields, "yid"));
xmlnode_set_attrib(ct, "pr", "0");
for (i = 0; yfields[i]; i++) {
const char *v = purple_request_fields_get_string(fields, yfields[i]);
xmlnode_set_attrib(ct, yfields[i], v ? v : "");
}
content = xmlnode_to_formatted_str(node, &len);
xmlnode_free(node);
purple_url_parse(yd->jp ? YAHOOJP_USERINFO_URL : YAHOO_USERINFO_URL, &webaddress, NULL, &webpage, NULL, NULL);
request = g_strdup_printf("POST %s HTTP/1.1\r\n"
"User-Agent: " YAHOO_CLIENT_USERAGENT "\r\n"
"Cookie: T=%s; path=/; domain=.yahoo.com; Y=%s;\r\n"
"Host: %s\r\n"
"Content-Length: %d\r\n"
"Cache-Control: no-cache\r\n\r\n"
"%s\r\n\r\n",
webpage,
yd->cookie_t, yd->cookie_y,
webaddress,
len + 4,
content);
#if 0
{
/* This is if we wanted to send our contact details to everyone
* in the buddylist. But this cannot be done now, because in the
* official messenger, doing this pops a conversation window at
* the receiver's end, which is stupid, and thus not really
* surprising. */
struct yahoo_userinfo *ui = g_new(struct yahoo_userinfo, 1);
node = xmlnode_new("contact");
for (i = 0; yfields[i]; i++) {
const char *v = purple_request_fields_get_string(fields, yfields[i]);
if (v) {
xmlnode *nd = xmlnode_new_child(node, yfields[i]);
xmlnode_insert_data(nd, v, -1);
}
}
ui->yd = yd;
ui->xml = xmlnode_to_str(node, NULL);
xmlnode_free(node);
}
#endif
url_data = purple_util_fetch_url_request_len_with_account(account, webaddress, FALSE,
YAHOO_CLIENT_USERAGENT, TRUE, request, FALSE, -1,
yahoo_fetch_aliases_cb, gc);
if (url_data != NULL)
yd->url_datas = g_slist_prepend(yd->url_datas, url_data);
g_free(webaddress);
g_free(webpage);
g_free(content);
g_free(request);
}
void yahoo_process_chat_join(PurpleConnection *gc, struct yahoo_packet *pkt)
{
PurpleAccount *account = purple_connection_get_account(gc);
YahooData *yd = (YahooData *) gc->proto_data;
PurpleConversation *c = NULL;
GSList *l;
GList *members = NULL;
GList *roomies = NULL;
char *room = NULL;
char *topic = NULL;
char *someid, *someotherid, *somebase64orhashosomething, *somenegativenumber;
if (pkt->status == -1) {
/* We can't join */
struct yahoo_pair *pair = pkt->hash->data;
gchar const *failed_to_join = _("Failed to join chat");
switch (atoi(pair->value)) {
case 0xFFFFFFFA: /* -6 */
purple_notify_error(gc, NULL, failed_to_join, _("Unknown room"));
break;
case 0xFFFFFFF1: /* -15 */
purple_notify_error(gc, NULL, failed_to_join, _("Maybe the room is full"));
break;
case 0xFFFFFFDD: /* -35 */
purple_notify_error(gc, NULL, failed_to_join, _("Not available"));
break;
default:
purple_notify_error(gc, NULL, failed_to_join,
_("Unknown error. You may need to logout and wait five minutes before being able to rejoin a chatroom"));
}
return;
}
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
switch (pair->key) {
case 104:
g_free(room);
room = yahoo_string_decode(gc, pair->value, TRUE);
break;
case 105:
g_free(topic);
topic = yahoo_string_decode(gc, pair->value, TRUE);
break;
case 128:
someid = pair->value;
break;
case 108: /* number of joiners */
break;
case 129:
someotherid = pair->value;
break;
case 130:
somebase64orhashosomething = pair->value;
break;
case 126:
somenegativenumber = pair->value;
break;
case 13: /* this is 1. maybe its the type of room? (normal, user created, private, etc?) */
break;
case 61: /*this looks similar to 130 */
break;
/* the previous section was just room info. this next section is
info about individual room members, (including us) */
case 109: /* the yahoo id */
members = g_list_append(members, pair->value);
break;
case 110: /* age */
break;
case 141: /* nickname */
break;
case 142: /* location */
break;
case 113: /* bitmask */
break;
}
}
if (room && yd->chat_name && purple_utf8_strcasecmp(room, yd->chat_name))
yahoo_chat_leave(gc, room,
purple_connection_get_display_name(gc), FALSE);
c = purple_find_chat(gc, YAHOO_CHAT_ID);
if (room && (!c || purple_conv_chat_has_left(PURPLE_CONV_CHAT(c))) &&
members && (members->next ||
!g_ascii_strcasecmp(members->data, purple_connection_get_display_name(gc)))) {
GList *l;
GList *flags = NULL;
for (l = members; l; l = l->next)
flags = g_list_prepend(flags, GINT_TO_POINTER(PURPLE_CBFLAGS_NONE));
if (c && purple_conv_chat_has_left(PURPLE_CONV_CHAT(c))) {
/* this might be a hack, but oh well, it should nicely */
char *tmpmsg;
purple_conversation_set_name(c, room);
c = serv_got_joined_chat(gc, YAHOO_CHAT_ID, room);
if (topic) {
purple_conv_chat_set_topic(PURPLE_CONV_CHAT(c), NULL, topic);
/* Also print the topic to the backlog so that the captcha link is clickable */
purple_conv_chat_write(PURPLE_CONV_CHAT(c), "", topic, PURPLE_MESSAGE_SYSTEM, time(NULL));
}
yd->in_chat = 1;
yd->chat_name = g_strdup(room);
purple_conv_chat_add_users(PURPLE_CONV_CHAT(c), members, NULL, flags, FALSE);
tmpmsg = g_strdup_printf(_("You are now chatting in %s."), room);
purple_conv_chat_write(PURPLE_CONV_CHAT(c), "", tmpmsg, PURPLE_MESSAGE_SYSTEM, time(NULL));
g_free(tmpmsg);
} else {
c = serv_got_joined_chat(gc, YAHOO_CHAT_ID, room);
if (topic) {
purple_conv_chat_set_topic(PURPLE_CONV_CHAT(c), NULL, topic);
/* Also print the topic to the backlog so that the captcha link is clickable */
purple_conv_chat_write(PURPLE_CONV_CHAT(c), "", topic, PURPLE_MESSAGE_SYSTEM, time(NULL));
}
yd->in_chat = 1;
yd->chat_name = g_strdup(room);
purple_conv_chat_add_users(PURPLE_CONV_CHAT(c), members, NULL, flags, FALSE);
}
g_list_free(flags);
} else if (c) {
if (topic) {
const char *cur_topic = purple_conv_chat_get_topic(PURPLE_CONV_CHAT(c));
if (cur_topic == NULL || strcmp(cur_topic, topic) != 0)
purple_conv_chat_set_topic(PURPLE_CONV_CHAT(c), NULL, topic);
}
yahoo_chat_add_users(PURPLE_CONV_CHAT(c), members);
}
if (account->deny && c) {
PurpleConversationUiOps *ops = purple_conversation_get_ui_ops(c);
for (l = account->deny; l != NULL; l = l->next) {
for (roomies = members; roomies; roomies = roomies->next) {
if (!purple_utf8_strcasecmp((char *)l->data, roomies->data)) {
purple_debug_info("yahoo", "Ignoring room member %s in room %s\n" , (char *)roomies->data, room ? room : "");
purple_conv_chat_ignore(PURPLE_CONV_CHAT(c),roomies->data);
ops->chat_update_user(c, roomies->data);
}
}
}
}
g_list_free(roomies);
g_list_free(members);
g_free(room);
g_free(topic);
}
