/* 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; }