/* this should be called upon signin, even when we did not open group chat window */
void qq_room_data_initial(PurpleConnection *gc)
{
PurpleAccount *account;
PurpleChat *chat;
PurpleGroup *purple_group;
PurpleBlistNode *node;
qq_data *qd;
qq_room_data *rmd;
gint count;
account = purple_connection_get_account(gc);
qd = (qq_data *) gc->proto_data;
purple_debug_info("QQ", "Initial QQ Qun configurations\n");
purple_group = purple_find_group(PURPLE_GROUP_QQ_ROOM);
if (purple_group == NULL) {
purple_debug_info("QQ", "We have no QQ Qun\n");
return;
}
count = 0;
for (node = purple_blist_node_get_first_child((PurpleBlistNode *)purple_group);
node != NULL;
node = purple_blist_node_get_sibling_next(node))
{
if ( !PURPLE_BLIST_NODE_IS_CHAT(node)) {
continue;
}
/* got one */
chat = (PurpleChat *) node;
if (account != purple_chat_get_account(chat)) /* not qq account*/
continue;
rmd = room_data_new_by_hashtable(gc, purple_chat_get_components(chat));
rmd->my_role = QQ_ROOM_ROLE_NO; //now set all old qun data detached 'cause we don't know if we are still in
qd->rooms = g_slist_append(qd->rooms, rmd);
count++;
}
purple_debug_info("QQ", "Load %d QQ Qun configurations\n", count);
}
static void
ggp_avatar_own_got_token(PurpleConnection *gc, const gchar *token,
gpointer _img)
{
PurpleHttpRequest *req;
PurpleImage *img = _img;
ggp_avatar_own_data *own_data = ggp_avatar_get_avdata(gc)->own_data;
gchar *img_data, *img_data_e, *request_data;
PurpleAccount *account = purple_connection_get_account(gc);
uin_t uin = ggp_str_to_uin(purple_account_get_username(account));
if (img != own_data->img) {
purple_debug_warning("gg", "ggp_avatar_own_got_token: "
"avatar was changed in meantime\n");
return;
}
own_data->img = NULL;
img_data = purple_base64_encode(purple_image_get_data(img),
purple_image_get_size(img));
img_data_e = g_uri_escape_string(img_data, NULL, FALSE);
g_free(img_data);
request_data = g_strdup_printf("uin=%d&photo=%s", uin, img_data_e);
g_free(img_data_e);
purple_debug_misc("gg", "ggp_avatar_own_got_token: "
"uploading new avatar...\n");
req = purple_http_request_new("http://avatars.nowe.gg/upload");
purple_http_request_set_max_len(req, GGP_AVATAR_RESPONSE_MAX);
purple_http_request_set_method(req, "POST");
purple_http_request_header_set(req, "Authorization", token);
purple_http_request_header_set(req, "From", "avatars to avatars");
purple_http_request_header_set(req, "Content-Type",
"application/x-www-form-urlencoded");
purple_http_request_set_contents(req, request_data, -1);
purple_http_request(gc, req, ggp_avatar_own_sent, NULL);
purple_http_request_unref(req);
g_free(request_data);
}
PurpleXfer * ggp_edisc_xfer_send_new(PurpleConnection *gc, const char *who)
{
PurpleXfer *xfer;
ggp_edisc_xfer *edisc_xfer;
g_return_val_if_fail(gc != NULL, NULL);
g_return_val_if_fail(who != NULL, NULL);
xfer = purple_xfer_new(purple_connection_get_account(gc),
PURPLE_XFER_TYPE_SEND, who);
edisc_xfer = g_new0(ggp_edisc_xfer, 1);
purple_xfer_set_protocol_data(xfer, edisc_xfer);
edisc_xfer->gc = gc;
purple_xfer_set_init_fnc(xfer, ggp_edisc_xfer_send_init);
purple_xfer_set_start_fnc(xfer, ggp_edisc_xfer_send_start);
purple_xfer_set_cancel_send_fnc(xfer, ggp_edisc_xfer_cancel);
return xfer;
}
static PurpleXfer *
yahoo_ft_new_xfer_struct(PurpleConnection *gc, PurpleXferType type, const char *who)
{
PurpleXfer *xfer;
g_return_val_if_fail(gc != NULL, NULL);
g_return_val_if_fail(who != NULL, NULL);
xfer = purple_xfer_new(purple_connection_get_account(gc), type, who);
g_return_val_if_fail(xfer != NULL, NULL);
purple_xfer_set_init_fnc(xfer, yahoo_xfer_init_15);
purple_xfer_set_start_fnc(xfer, yahoo_xfer_start);
purple_xfer_set_end_fnc(xfer, yahoo_xfer_end);
purple_xfer_set_cancel_send_fnc(xfer, yahoo_xfer_cancel_send);
purple_xfer_set_cancel_recv_fnc(xfer, yahoo_xfer_cancel_recv);
purple_xfer_set_request_denied_fnc(xfer, yahoo_xfer_cancel_recv);
return xfer;
}
static int nullprpl_chat_send(PurpleConnection *gc, int id, const char *message,
PurpleMessageFlags flags) {
const char *username = purple_account_get_username(purple_connection_get_account(gc));
PurpleChatConversation *chat = purple_conversations_find_chat(gc, id);
if (chat) {
purple_debug_info("nullprpl",
"%s is sending message to chat room %s: %s\n", username,
purple_conversation_get_name(PURPLE_CONVERSATION(chat)), message);
/* send message to everyone in the chat room */
foreach_gc_in_chat(receive_chat_message, gc, id, (gpointer)message);
return 0;
} else {
purple_debug_info("nullprpl",
"tried to send message from %s to chat room #%d: %s\n"
"but couldn't find chat room",
username, id, message);
return -1;
}
}
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);
PurpleChat *ch = blist_find_chat_by_convo(gc, id);
GHashTable *hasht = purple_chat_get_components(ch);
char *chat_id = g_hash_table_lookup(hasht, "id");
char *plain;
purple_markup_html_to_xhtml(message, NULL, &plain);
waAPI_sendchat(wconn->waAPI, chat_id, plain);
g_free(plain);
waprpl_check_output(gc);
const char *me = purple_account_get_string(account, "nick", "");
purple_conv_chat_write(PURPLE_CONV_CHAT(convo), me, message, PURPLE_MESSAGE_SEND, time(NULL));
return 1;
}
static gchar *
yahoo_ft_url_gen(PurpleXfer *xfer, const gchar *host)
{
struct yahoo_xfer_data *xfer_data;
PurpleAccount *account;
g_return_val_if_fail(host != NULL, NULL);
xfer_data = purple_xfer_get_protocol_data(xfer);
account = purple_connection_get_account(xfer_data->gc);
if (!xfer_data->is_relay) {
purple_debug_fatal("yahoo", "Non-relay FT aren't tested yet\n");
return NULL;
}
return g_strdup_printf("http://%s/relay?token=%s&sender=%s&recver=%s",
host, purple_url_encode(xfer_data->xfer_idstring_for_relay),
purple_normalize(account, purple_account_get_username(account)),
purple_xfer_get_remote_user(xfer));
}
/* Checks if the WA protocol has data to output and schedules a write handler */
static void waprpl_check_output(PurpleConnection * gc)
{
whatsapp_connection *wconn = purple_connection_get_protocol_data(gc);
if (wconn->fd < 0)
return;
if (waAPI_hasoutdata(wconn->waAPI) > 0) {
/* Need to watch for output data (if we are not doing it already) */
if (wconn->wh == 0)
wconn->wh = purple_input_add(wconn->fd, PURPLE_INPUT_WRITE, waprpl_output_cb, gc);
} else {
if (wconn->wh != 0)
purple_input_remove(wconn->wh);
wconn->wh = 0;
}
check_ssl_requests(purple_connection_get_account(gc));
waprpl_check_complete_uploads(gc);
}
void ycht_connection_open(PurpleConnection *gc)
{
YchtConn *ycht;
YahooData *yd = purple_connection_get_protocol_data(gc);
PurpleAccount *account = purple_connection_get_account(gc);
ycht = g_new0(YchtConn, 1);
ycht->gc = gc;
ycht->fd = -1;
yd->ycht = ycht;
if (purple_proxy_connect(gc, account,
purple_account_get_string(account, "ycht-server", YAHOO_YCHT_HOST),
purple_account_get_int(account, "ycht-port", YAHOO_YCHT_PORT),
ycht_got_connected, ycht) == NULL)
{
ycht_connection_error(ycht, _("Unable to connect"));
return;
}
}
void
fb_mqtt_open(FbMqtt *mqtt, const gchar *host, gint port)
{
FbMqttPrivate *priv;
PurpleAccount *acc;
g_return_if_fail(FB_IS_MQTT(mqtt));
priv = mqtt->priv;
acc = purple_connection_get_account(priv->gc);
fb_mqtt_close(mqtt);
priv->gsc = purple_ssl_connect(acc, host, port, fb_mqtt_cb_open,
fb_mqtt_cb_open_error, mqtt);
if (priv->gsc == NULL) {
fb_mqtt_cb_open_error(NULL, 0, mqtt);
return;
}
fb_mqtt_timeout(mqtt);
}
static void waprpl_connect_cb(gpointer data, gint source, const gchar * error_message)
{
PurpleConnection *gc = data;
whatsapp_connection *wconn = purple_connection_get_protocol_data(gc);
PurpleAccount *acct = purple_connection_get_account(gc);
const char *resource = purple_account_get_string(acct, "resource", default_resource);
if (source < 0) {
gchar *tmp = g_strdup_printf("Unable to connect: %s", error_message);
purple_connection_error_reason(gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
g_free(tmp);
} else {
wconn->fd = source;
waAPI_login(wconn->waAPI, resource);
wconn->rh = purple_input_add(wconn->fd, PURPLE_INPUT_READ, waprpl_input_cb, gc);
wconn->timer = purple_timeout_add_seconds(20, wa_timer_cb, gc);
waprpl_check_output(gc);
}
}
static PurpleBuddy* spin_sync_buddy(SpinData* spin,
GSList* buddies,const gchar* id,
const gchar* name,guint online,
const gchar* away,const gchar* photo)
{
PurpleAccount* account = purple_connection_get_account(spin->gc);
/* gchar* lower_name = g_utf8_strdown(name,-1); */
PurpleBuddy* buddy = spin_find_buddy_in_list(buddies,id);
if(!buddy)
{
purple_debug_info("spin","adding buddy: %s\n",/*lower_*/name);
buddy = purple_buddy_new(account,/*lower_*/name,NULL);
purple_blist_add_buddy(buddy,NULL,NULL,NULL);
purple_blist_node_set_string(&buddy->node,"spin-id",id);
}
/* purple_normalize here? */
if(g_strcmp0(purple_buddy_get_name(buddy),name) != 0)
{
spin_notify_nick_changed(spin,purple_buddy_get_name(buddy),name);
purple_blist_rename_buddy(buddy,name);
}
spin_sync_photo(spin,buddy,photo);
/* do not set status if we got a status after the HTTP request */
if(g_hash_table_lookup(spin->updated_status_list,
purple_normalize(account,name)))
return buddy;
if(online && *away)
purple_prpl_got_user_status(account,/*lower_*/name,"away",
"message",away,NULL);
else if(online)
purple_prpl_got_user_status(account,/*lower_*/name,"available",NULL);
else
purple_prpl_got_user_status(account,/*lower_*/name,"offline",NULL);
return buddy;
/* g_free(lower_name); */
}
guint32 qq_room_get_next_conv(PurpleConnection *gc, guint32 room_id)
{
GSList *list;
qq_room_data *rmd;
qq_data *qd;
gboolean is_find;
qd = (qq_data *) gc->proto_data;
list = qd->rooms;
if (room_id > 0) {
/* search next room */
is_find = FALSE;
while (list != NULL) {
rmd = (qq_room_data *) list->data;
list = list->next;
if (rmd->id == room_id) {
is_find = TRUE;
break;
}
}
g_return_val_if_fail(is_find, 0);
}
while (list != NULL) {
rmd = (qq_room_data *) list->data;
g_return_val_if_fail(rmd != NULL, 0);
if (rmd->my_role == QQ_ROOM_ROLE_YES || rmd->my_role == QQ_ROOM_ROLE_ADMIN) {
if (NULL != purple_find_conversation_with_account(
PURPLE_CONV_TYPE_CHAT,rmd->name, purple_connection_get_account(gc))) {
/* In convseration*/
return rmd->id;
}
}
list = list->next;
}
return 0;
}
static GntWidget*
create_account_field(PurpleRequestField *field)
{
gboolean all;
PurpleAccount *def;
GList *list;
GntWidget *combo = gnt_combo_box_new();
all = purple_request_field_account_get_show_all(field);
def = purple_request_field_account_get_value(field);
if (!def)
def = purple_request_field_account_get_default_value(field);
if (all)
list = purple_accounts_get_all();
else
list = purple_connections_get_all();
for (; list; list = list->next)
{
PurpleAccount *account;
char *text;
if (all)
account = list->data;
else
account = purple_connection_get_account(list->data);
text = g_strdup_printf("%s (%s)",
purple_account_get_username(account),
purple_account_get_protocol_name(account));
gnt_combo_box_add_data(GNT_COMBO_BOX(combo), account, text);
g_free(text);
if (account == def)
gnt_combo_box_set_selected(GNT_COMBO_BOX(combo), account);
}
gnt_widget_set_size(combo, 20, 3); /* ew */
return combo;
}
static void _elim_notice ( PurpleConnection *conn, const char *msg )
{
PurpleAccount *acct = purple_connection_get_account( conn );
if( acct )
{
char *ID = new_elim_id();
xmlnode *alist = xnode_new( "alist" );
xmlnode *mcall = func_call( "elim-connection-state", ID, alist );
const char *aname = purple_account_get_username ( acct );
const char *proto = purple_account_get_protocol_id( acct );
int state = purple_connection_get_state ( conn );
g_free( ID );
AL_PTR ( alist, "account-uid" , acct );
AL_STR ( alist, "account-name", aname );
AL_STR ( alist, "im-protocol" , proto );
AL_STR ( alist, "message" , msg );
AL_ENUM( alist, "state" , state , ":connection-state" );
add_outbound_sexp( mcall );
}
}
static void nullprpl_reject_chat(PurpleConnection *gc, GHashTable *components) {
const char *invited_by = g_hash_table_lookup(components, "invited_by");
const char *room = g_hash_table_lookup(components, "room");
const char *username = purple_account_get_username(purple_connection_get_account(gc));
PurpleConnection *invited_by_gc = get_nullprpl_gc(invited_by);
char *message = g_strdup_printf(
"%s %s %s.",
username,
_("has rejected your invitation to join the chat room"),
room);
purple_debug_info("nullprpl",
"%s has rejected %s's invitation to join chat room %s\n",
username, invited_by, room);
purple_notify_info(invited_by_gc,
_("Chat invitation rejected"),
_("Chat invitation rejected"),
message,
purple_request_cpar_from_connection(gc));
g_free(message);
}
static PurpleXmlNode *
jabber_bosh_connection_parse(PurpleJabberBOSHConnection *conn,
PurpleHttpResponse *response)
{
PurpleXmlNode *root;
const gchar *data;
size_t data_len;
const gchar *type;
g_return_val_if_fail(conn != NULL, NULL);
g_return_val_if_fail(response != NULL, NULL);
if (conn->is_terminating || purple_account_is_disconnecting(
purple_connection_get_account(conn->js->gc)))
{
return NULL;
}
if (!purple_http_response_is_successful(response)) {
purple_connection_error(conn->js->gc,
PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
_("Unable to connect"));
return NULL;
}
data = purple_http_response_get_data(response, &data_len);
root = purple_xmlnode_from_str(data, data_len);
type = purple_xmlnode_get_attrib(root, "type");
if (g_strcmp0(type, "terminate") == 0) {
purple_connection_error(conn->js->gc,
PURPLE_CONNECTION_ERROR_OTHER_ERROR, _("The BOSH "
"connection manager terminated your session."));
purple_xmlnode_free(root);
return NULL;
}
return root;
}
PurpleXfer *irc_dccsend_new_xfer(PurpleConnection *gc, const char *who) {
PurpleXfer *xfer;
struct irc_xfer_send_data *xd;
/* Build the file transfer handle */
xfer = purple_xfer_new(purple_connection_get_account(gc), PURPLE_XFER_SEND, who);
if (xfer)
{
xd = g_new0(struct irc_xfer_send_data, 1);
xd->fd = -1;
xfer->data = xd;
/* Setup our I/O op functions */
purple_xfer_set_init_fnc(xfer, irc_dccsend_send_init);
purple_xfer_set_write_fnc(xfer, irc_dccsend_send_write);
purple_xfer_set_end_fnc(xfer, irc_dccsend_send_destroy);
purple_xfer_set_request_denied_fnc(xfer, irc_dccsend_send_destroy);
purple_xfer_set_cancel_send_fnc(xfer, irc_dccsend_send_destroy);
}
return xfer;
}
PurpleRoomlist *
campfire_roomlist_get_list(PurpleConnection * gc)
{
CampfireConn *campfire = gc->proto_data;
GList *fields = NULL;
PurpleRoomlistField *f;
purple_debug_info("campfire", "initiating ROOMLIST GET LIST\n");
if (campfire->roomlist) {
purple_roomlist_unref(campfire->roomlist);
}
campfire->roomlist =
purple_roomlist_new(purple_connection_get_account(gc));
/*f = purple_roomlist_field_new(PURPLE_ROOMLIST_FIELD_STRING, "", "room", TRUE); */
/*fields = g_list_append(fields, f); */
f = purple_roomlist_field_new(PURPLE_ROOMLIST_FIELD_STRING, _("Topic"),
"topic", FALSE);
fields = g_list_append(fields, f);
f = purple_roomlist_field_new(PURPLE_ROOMLIST_FIELD_STRING, "", "id",
TRUE);
fields = g_list_append(fields, f);
purple_roomlist_set_fields(campfire->roomlist, fields);
purple_roomlist_set_in_progress(campfire->roomlist, TRUE);
campfire_room_query(campfire);
/*purple_roomlist_set_in_progress(campfire->roomlist, FALSE); */
/*purple_roomlist_unref(campfire->roomlist); */
/*campfire->roomlist = NULL; */
return campfire->roomlist;
}
PurpleRequestField *
purple_request_field_account_new(const char *id, const char *text,
PurpleAccount *account)
{
PurpleRequestField *field;
g_return_val_if_fail(id != NULL, NULL);
g_return_val_if_fail(text != NULL, NULL);
field = purple_request_field_new(id, text, PURPLE_REQUEST_FIELD_ACCOUNT);
if (account == NULL && purple_connections_get_all() != NULL)
{
account = purple_connection_get_account(
(PurpleConnection *)purple_connections_get_all()->data);
}
purple_request_field_account_set_default_value(field, account);
purple_request_field_account_set_value(field, account);
return field;
}
static void
reset_account_list(PurpleAccount *account)
{
GList *list;
GntComboBox *accounts = GNT_COMBO_BOX(froomlist.accounts);
gnt_combo_box_remove_all(accounts);
for (list = purple_connections_get_all(); list; list = list->next) {
PurplePluginProtocolInfo *prpl_info = NULL;
PurpleConnection *gc = list->data;
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(gc));
if (PURPLE_CONNECTION_IS_CONNECTED(gc) &&
prpl_info->roomlist_get_list != NULL) {
PurpleAccount *account = purple_connection_get_account(gc);
char *text = g_strdup_printf("%s (%s)",
purple_account_get_username(account),
purple_account_get_protocol_name(account));
gnt_combo_box_add_data(accounts, account, text);
g_free(text);
}
}
}
static void nullprpl_join_chat(PurpleConnection *gc, GHashTable *components) {
const char *username = purple_account_get_username(purple_connection_get_account(gc));
const char *room = g_hash_table_lookup(components, "room");
int chat_id = g_str_hash(room);
purple_debug_info("nullprpl", "%s is joining chat room %s\n", username, room);
if (!purple_conversations_find_chat(gc, chat_id)) {
purple_serv_got_joined_chat(gc, chat_id, room);
/* tell everyone that we joined, and add them if they're already there */
foreach_gc_in_chat(joined_chat, gc, chat_id, NULL);
} else {
char *tmp = g_strdup_printf(_("%s is already in chat room %s."),
username,
room);
purple_debug_info("nullprpl", "%s is already in chat room %s\n", username,
room);
purple_notify_info(gc, _("Join chat"), _("Join chat"), tmp,
purple_request_cpar_from_connection(gc));
g_free(tmp);
}
}
/* When you ask other people for authorization */
void
oscar_auth_sendrequest(PurpleConnection *gc, const char *bname, const char *msg)
{
OscarData *od;
PurpleAccount *account;
PurpleBuddy *buddy;
PurpleGroup *group;
const char *gname;
od = purple_connection_get_protocol_data(gc);
account = purple_connection_get_account(gc);
buddy = purple_find_buddy(account, bname);
if (buddy != NULL)
group = purple_buddy_get_group(buddy);
else
group = NULL;
if (group != NULL)
{
gname = purple_group_get_name(group);
purple_debug_info("oscar", "ssi: adding buddy %s to group %s\n",
bname, gname);
aim_ssi_sendauthrequest(od, bname, msg ? msg : _("Please authorize me so I can add you to my buddy list."));
if (!aim_ssi_itemlist_finditem(od->ssi.local, gname, bname, AIM_SSI_TYPE_BUDDY))
{
aim_ssi_addbuddy(od, bname, gname, NULL, purple_buddy_get_alias_only(buddy), NULL, NULL, TRUE);
/* Mobile users should always be online */
if (bname[0] == '+') {
purple_prpl_got_user_status(account,
purple_buddy_get_name(buddy),
OSCAR_STATUS_ID_AVAILABLE, NULL);
purple_prpl_got_user_status(account,
purple_buddy_get_name(buddy),
OSCAR_STATUS_ID_MOBILE, NULL);
}
}
}
}
static void do_room_join_request(PurpleConnection *gc, qq_room_data *rmd)
{
gchar *msg;
qq_room_req *add_req;
g_return_if_fail(rmd != NULL);
purple_debug_info("QQ", "Room id %u needs authentication\n", rmd->id);
msg = g_strdup_printf("QQ Qun %u needs authentication\n", rmd->ext_id);
add_req = g_new0(qq_room_req, 1);
add_req->gc = gc;
add_req->id = rmd->id;
purple_request_input(gc, _("Join QQ Qun"), msg,
_("Input request here"),
_("Would you be my friend?"), TRUE, FALSE, NULL,
_("Send"),
G_CALLBACK(group_join_cb),
_("Cancel"), G_CALLBACK(room_join_cancel_cb),
purple_connection_get_account(gc), rmd->title_utf8, NULL,
add_req);
g_free(msg);
}
static void plainprpl_close(PurpleConnection *gc)
{
purple_debug_info("plainprpl", "plainprpl_close\n");
PurpleAccount *account;
PurpleBuddy *buddy;
plain_plugin_state *pstate;
plain_buddy_state *bstate;
const char *on_logout;
/* notify other plainprpl accounts */
account = purple_connection_get_account(gc);
pstate = purple_connection_get_protocol_data(gc);
/* Notifiy all buddies that we are gone */
GSList *iter = pstate->all_buddies;
while (iter) {
buddy = iter->data;
bstate = purple_buddy_get_protocol_data(buddy);
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
PurpleStatusType *status_type = purple_status_get_type(status);
PurpleStatusPrimitive status_primitive = purple_status_type_get_primitive(status_type);
if (bstate && status_primitive == PURPLE_STATUS_AVAILABLE) {
send_msg(pstate, bstate, "/bye");
}
iter = iter->next;
}
//remove timers
purple_timeout_remove(pstate->receive_timer);
on_logout = purple_account_get_string(account, "on_logout", NULL);
exec_process(on_logout, NULL, NULL, gc, NULL);
free_plugin_data(pstate);
}
qq_buddy_data *qq_buddy_data_find(PurpleConnection *gc, guint32 uid)
{
gchar *who;
PurpleBuddy *buddy;
g_return_val_if_fail(gc != NULL, NULL);
who = uid_to_purple_name(uid);
if (who == NULL) return NULL;
buddy = purple_find_buddy(purple_connection_get_account(gc), who);
g_free(who);
if (buddy == NULL) {
purple_debug_error("QQ", "Can not find purple buddy of %u\n", uid);
return NULL;
}
if (buddy->proto_data == NULL) {
purple_debug_error("QQ", "Can not find buddy data of %u\n", uid);
return NULL;
}
return (qq_buddy_data *)buddy->proto_data;
}
static void yahoo_doodle_command_got_confirm(PurpleConnection *gc, const char *from)
{
PurpleAccount *account;
PurpleWhiteboard *wb;
purple_debug_info("yahoo", "doodle: Got Confirm (%s)\n", from);
/* Get the doodle session */
account = purple_connection_get_account(gc);
/* Only handle this if local client requested Doodle session (else local
* client would have sent one)
*/
wb = purple_whiteboard_get_session(account, from);
if(wb == NULL)
return;
/* TODO Combine the following IF's? */
/* Check if we requested a doodle session */
/*if(wb->state == DOODLE_STATE_REQUESTING)
{
wb->state = DOODLE_STATE_ESTABLISHED;
purple_whiteboard_start(wb);
yahoo_doodle_command_send_confirm(gc, from);
}*/
/* Check if we accepted a request for a doodle session */
if(wb->state == DOODLE_STATE_REQUESTED)
{
wb->state = DOODLE_STATE_ESTABLISHED;
purple_whiteboard_start(wb);
}
}
void *
purple_notify_userinfo(PurpleConnection *gc, const char *who,
PurpleNotifyUserInfo *user_info, PurpleNotifyCloseCallback cb, gpointer user_data)
{
PurpleNotifyUiOps *ops;
g_return_val_if_fail(who != NULL, NULL);
ops = purple_notify_get_ui_ops();
if (ops != NULL && ops->notify_userinfo != NULL) {
void *ui_handle;
purple_signal_emit(purple_notify_get_handle(), "displaying-userinfo",
purple_connection_get_account(gc), who, user_info);
ui_handle = ops->notify_userinfo(gc, who, user_info);
if (ui_handle != NULL) {
PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
info->type = PURPLE_NOTIFY_USERINFO;
info->handle = gc;
info->ui_handle = ui_handle;
info->cb = cb;
info->cb_user_data = user_data;
handles = g_list_append(handles, info);
return info->ui_handle;
}
}
if (cb != NULL)
cb(user_data);
return NULL;
}
static void *
pidgin_notify_userinfo(PurpleConnection *gc, const char *who,
PurpleNotifyUserInfo *user_info)
{
char *info;
void *ui_handle;
char *key = userinfo_hash(purple_connection_get_account(gc), who);
PidginUserInfo *pinfo = NULL;
if (!userinfo) {
userinfo = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
}
info = purple_notify_user_info_get_text_with_newline(user_info, "<br />");
pinfo = g_hash_table_lookup(userinfo, key);
if (pinfo != NULL) {
GtkIMHtml *imhtml = g_object_get_data(G_OBJECT(pinfo->window), "info-widget");
char *linked_text = purple_markup_linkify(info);
gtk_imhtml_clear(imhtml);
gtk_imhtml_append_text(imhtml, linked_text, notify_imhtml_options());
g_free(linked_text);
g_free(key);
ui_handle = pinfo->window;
pinfo->count++;
} else {
char *primary = g_strdup_printf(_("Info for %s"), who);
ui_handle = pidgin_notify_formatted(_("Buddy Information"), primary, NULL, info);
g_signal_handlers_disconnect_by_func(G_OBJECT(ui_handle), G_CALLBACK(formatted_close_cb), NULL);
g_signal_connect(G_OBJECT(ui_handle), "destroy", G_CALLBACK(remove_userinfo), key);
g_free(primary);
pinfo = g_new0(PidginUserInfo, 1);
pinfo->window = ui_handle;
pinfo->count = 1;
g_hash_table_insert(userinfo, key, pinfo);
}
g_free(info);
return ui_handle;
}
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;
}
