void fb_buddy_delete(PurpleConnection *pc, PurpleBuddy *buddy, PurpleGroup *group) { FacebookAccount *fba = pc->proto_data; gchar *buddy_tmp, *postdata; //This function removes a buddy from our friends list on facebook //and shouldn't really be used if (!purple_account_get_bool(fba->account, "facebook_manage_friends", FALSE)) { purple_debug_warning("facebook", "attempted to add %s but was blocked\n", buddy->name); return; } buddy_tmp = g_strdup(purple_url_encode(buddy->name)); postdata = g_strdup_printf( "uid=%s&post_form_id=%s&fb_dtsg=%s&" "post_form_id_source=AsyncRequest&__a=1", buddy_tmp, fba->post_form_id, fba->dtsg); g_free(buddy_tmp); fb_post_or_get(fba, FB_METHOD_POST, NULL, "/ajax/profile/removefriend.php", postdata, NULL, NULL, FALSE); g_free(postdata); }
PeerConnection * peer_connection_new(OscarData *od, guint64 type, const char *bn) { PeerConnection *conn; PurpleAccount *account; account = purple_connection_get_account(od->gc); conn = g_new0(PeerConnection, 1); conn->od = od; conn->type = type; conn->bn = g_strdup(bn); conn->buffer_outgoing = purple_circ_buffer_new(0); conn->listenerfd = -1; conn->fd = -1; conn->lastactivity = time(NULL); conn->use_proxy |= purple_account_get_bool(account, "always_use_rv_proxy", FALSE); if (type == OSCAR_CAPABILITY_DIRECTIM) memcpy(conn->magic, "ODC2", 4); else if (type == OSCAR_CAPABILITY_SENDFILE) memcpy(conn->magic, "OFT2", 4); od->peer_connections = g_slist_prepend(od->peer_connections, conn); return conn; }
static void server_list_create(PurpleAccount *account) { PurpleConnection *gc; qq_data *qd; const gchar *custom_server; gc = purple_account_get_connection(account); g_return_if_fail(gc != NULL && gc->proto_data != NULL); qd = gc->proto_data; qd->use_tcp = purple_account_get_bool(account, "use_tcp", TRUE); custom_server = purple_account_get_string(account, "server", NULL); if (custom_server != NULL) { purple_debug_info("QQ", "Select server '%s'\n", custom_server); if (*custom_server != '\0' && g_ascii_strcasecmp(custom_server, "auto") != 0) { qd->servers = g_list_append(qd->servers, g_strdup(custom_server)); return; } } if (qd->use_tcp) { qd->servers = server_list_build('T'); return; } qd->servers = server_list_build('U'); }
void fb_buddy_remove(PurpleConnection *pc, PurpleBuddy *buddy, PurpleGroup *group) { // This method should only remove a buddy from a friend list. // Nothing more. It should not defriend a user ever. See issue // #185 for a good explaination of why this is a bad idea. // // Moreover, defriending is such a rare operation that we should // never make it easy. Facebook intentionally hides such a action // behind multiple layers of links and dialogs. // // If the plugin is ever to perform an actual defriending, it needs // to provide a dialog and user prompt at the absolute bare minimum. FacebookAccount *fba; if (!purple_account_get_bool(pc->account, "facebook_use_groups", TRUE)) { //Dont do anything if we're ignoring groups return; } purple_debug_info("facebook", "handing removal of buddy %s\n", buddy->name); fba = pc->proto_data; fb_group_buddy_move(pc, buddy->name, purple_group_get_name(group), DEFAULT_GROUP_NAME); }
void fb_group_rename(PurpleConnection *pc, const char *old_name, PurpleGroup *group, GList *moved_buddies) { if (!purple_account_get_bool(pc->account, "facebook_use_groups", TRUE)) { //Dont do anything if we're ignoring groups return; } purple_debug_info("facebook", "handling group rename of %s to %s\n", old_name, purple_group_get_name(group)); // We don't do anything here. Facebook's AJAX API for renaming groups // is horribly, horribly overcomplicated. There is no simple rename // call, instead you must also pass in all the current data about the // friend list and port it over. While it is possible to implement // this, it is risky and could potentially destroy a friend list if // the API changes. That's a Bad Thing(tm). Given the risk involved // with this operation and how rare it is, it's not worth it. // // The problem is compounded by the fact that renaming groups triggers // all sorts of weird behaviors in Pidgin. Renaming to a new name is // simple. Renaming to an existing group name (hence a merge) // triggers completely different behavior with calls to group_buddy // before the call to rename. This completely defeats the purpose of // having a rename function because group_buddy is called instead. // // Thus, the final decision is to use the buddy_move call. // TODO: warn users that renaming has no effect here. }
static VALUE get_bool_setting(VALUE self, VALUE name, VALUE default_value) { PurpleAccount *account; Data_Get_Struct(self, PurpleAccount, account); gboolean value = purple_account_get_bool(account, StringValueCStr(name), RTEST(default_value) ? TRUE : FALSE); return (TRUE == value) ? Qtrue : Qfalse; }
void gfire_update_games_list_cb(PurpleUtilFetchUrlData *p_url_data, gpointer p_data, const gchar *p_buf, gsize p_len, const gchar *p_error_message) { gfire_games_update_done(); if (!p_data || !p_buf || !p_len) purple_debug_error("gfire", "An error occured while updating the games list. Website down?\n"); else if(purple_util_write_data_to_file("gfire_games.xml", p_buf, p_len)) { gfire_game_load_games_xml(); gchar *version = gfire_game_get_version_str(); gchar *msg = g_strdup_printf(_("The Games List has been updated to version: %s."), version); g_free(version); #ifdef USE_NOTIFICATIONS if(purple_account_get_bool(purple_connection_get_account(p_data), "use_notify", TRUE)) gfire_notify_system(_("New Gfire Game List Version"), msg); else #endif // USE_NOTIFICATIONS purple_notify_message(NULL, PURPLE_NOTIFY_MSG_INFO, _("New Gfire Game List Version"), _("New Gfire Game List Version"), msg, NULL, NULL); g_free(msg); } else purple_debug_error("gfire", "An error occured while updating the games list. Website down?\n"); }
void yahoo_process_chat_addinvite(PurpleConnection *gc, struct yahoo_packet *pkt) { PurpleAccount *account; GSList *l; char *room = NULL; char *msg = NULL; char *who = NULL; account = purple_connection_get_account(gc); 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 129: /* room id? */ break; case 126: /* ??? */ break; case 117: g_free(msg); msg = yahoo_string_decode(gc, pair->value, FALSE); break; case 119: if (g_utf8_validate(pair->value, -1, NULL)) { who = pair->value; } else { purple_debug_warning("yahoo", "yahoo_process_chat_addinvite " "got non-UTF-8 string for key %d\n", pair->key); } break; case 118: /* us */ break; } } if (room && who) { GHashTable *components; if (!purple_account_privacy_check(account, who) || (purple_account_get_bool(account, "ignore_invites", FALSE))) { purple_debug_info("yahoo", "Invite to room %s from %s has been dropped.\n", room, who); g_free(room); g_free(msg); return; } components = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); g_hash_table_replace(components, g_strdup("room"), g_strdup(room)); purple_serv_got_chat_invite(gc, room, who, msg, components); } g_free(room); g_free(msg); }
gboolean twitter_option_use_oauth(PurpleAccount * account) { if (!strcmp(purple_account_get_protocol_id(account), TWITTER_PROTOCOL_ID)) { return TRUE; } else { return purple_account_get_bool(account, TWITTER_PREF_USE_OAUTH, TWITTER_PREF_USE_OAUTH_DEFAULT); } }
static VALUE get_bool_setting(VALUE self, VALUE name, VALUE default_value) { PurpleAccount *account; Data_Get_Struct(self, PurpleAccount, account); gboolean value = purple_account_get_bool(account, RSTRING_PTR(name), (default_value == Qfalse || default_value == Qnil) ? FALSE : TRUE); return (TRUE == value) ? Qtrue : Qfalse; }
static void silcpurple_wb_request(SilcClient client, const unsigned char *message, SilcUInt32 message_len, SilcClientEntry sender, SilcChannelEntry channel) { char tmp[256]; SilcPurpleWbRequest req; PurpleConnection *gc; SilcPurple sg; gc = client->application; sg = gc->proto_data; /* Open whiteboard automatically if requested */ if (purple_account_get_bool(sg->account, "open-wb", FALSE)) { PurpleWhiteboard *wb; if (!channel) wb = silcpurple_wb_init(sg, sender); else wb = silcpurple_wb_init_ch(sg, channel); silcpurple_wb_parse(wb->proto_data, wb, (unsigned char *)message, message_len); return; } /* Close any previous unaccepted requests */ purple_request_close_with_handle(sender); if (!channel) { g_snprintf(tmp, sizeof(tmp), _("%s sent message to whiteboard. Would you like " "to open the whiteboard?"), sender->nickname); } else { g_snprintf(tmp, sizeof(tmp), _("%s sent message to whiteboard on %s channel. " "Would you like to open the whiteboard?"), sender->nickname, channel->channel_name); } req = silc_calloc(1, sizeof(*req)); if (!req) return; req->message = silc_memdup(message, message_len); req->message_len = message_len; req->sender = sender; req->channel = channel; req->sg = sg; purple_request_action(gc, _("Whiteboard"), tmp, NULL, 1, sg->account, sender->nickname, NULL, req, 2, _("Yes"), G_CALLBACK(silcpurple_wb_request_cb), _("No"), G_CALLBACK(silcpurple_wb_request_cb)); }
static void irc_login(PurpleAccount *account) { PurpleConnection *gc; struct irc_conn *irc; char **userparts; const char *username = purple_account_get_username(account); gc = purple_account_get_connection(account); gc->flags |= PURPLE_CONNECTION_NO_NEWLINES; if (strpbrk(username, " \t\v\r\n") != NULL) { purple_connection_error(gc, _("IRC nicks may not contain whitespace")); return; } gc->proto_data = irc = g_new0(struct irc_conn, 1); irc->fd = -1; irc->account = account; irc->outbuf = purple_circ_buffer_new(512); userparts = g_strsplit(username, "@", 2); purple_connection_set_display_name(gc, userparts[0]); irc->server = g_strdup(userparts[1]); g_strfreev(userparts); irc->buddies = g_hash_table_new_full((GHashFunc)irc_nick_hash, (GEqualFunc)irc_nick_equal, NULL, (GDestroyNotify)irc_buddy_free); irc->cmds = g_hash_table_new(g_str_hash, g_str_equal); irc_cmd_table_build(irc); irc->msgs = g_hash_table_new(g_str_hash, g_str_equal); irc_msg_table_build(irc); purple_connection_update_progress(gc, _("Connecting"), 1, 2); if (purple_account_get_bool(account, "ssl", FALSE)) { if (purple_ssl_is_supported()) { irc->gsc = purple_ssl_connect(account, irc->server, purple_account_get_int(account, "port", IRC_DEFAULT_SSL_PORT), irc_login_cb_ssl, irc_ssl_connect_failure, gc); } else { purple_connection_error(gc, _("SSL support unavailable")); return; } } if (!irc->gsc) { if (purple_proxy_connect(gc, account, irc->server, purple_account_get_int(account, "port", IRC_DEFAULT_PORT), irc_login_cb, gc) == NULL) { purple_connection_error(gc, _("Couldn't create socket")); return; } } }
void flist_login(PurpleAccount *pa) { PurpleConnection *pc = purple_account_get_connection(pa); FListAccount *fla; gchar **ac_split; fla = g_new0(FListAccount, 1); fla->pa = pa; fla->pc = pc; fla->all_characters = g_hash_table_new_full((GHashFunc)flist_str_hash, (GEqualFunc)flist_str_equal, g_free, (GDestroyNotify)flist_character_free); fla->rx_buf = g_malloc0(256); fla->rx_len = 0; pc->proto_data = fla; ac_split = g_strsplit(purple_account_get_username(pa), ":", 2); fla->username = g_strdup(ac_split[0]); fla->character = g_strdup(ac_split[1]); fla->password = g_strdup(purple_account_get_password(pa)); //we don't want to display the whole username:character thing if(purple_account_get_alias(pa) == NULL || flist_str_equal(purple_account_get_username(pa), purple_account_get_alias(pa))) { purple_account_set_alias(pa, fla->character); } /* login options */ fla->server_address = g_strdup(purple_account_get_string(pa, "server_address", "chat.f-list.net")); fla->server_port = purple_account_get_int(pa, "server_port", FLIST_PORT); fla->sync_bookmarks = purple_account_get_bool(pa, "sync_bookmarks", FALSE); fla->sync_friends = purple_account_get_bool(pa, "sync_friends", TRUE); fla->debug_mode = purple_account_get_bool(pa, "debug_mode", FALSE); flist_channel_subsystem_load(fla); flist_clear_filter(fla); flist_global_kinks_load(pc); flist_profile_load(pc); flist_friends_load(fla); flist_ticket_timer(fla, 0); g_strfreev(ac_split); }
void tgp_chat_on_loaded_chat_full (struct tgl_state *TLS, struct tgl_chat *C) { PurpleChat *PC = tgp_blist_chat_find (TLS, C->id); if (!PC) { PC = p2tgl_chat_new (TLS, C); if (purple_account_get_bool (tls_get_pa (TLS), TGP_KEY_JOIN_GROUP_CHATS, TGP_DEFAULT_JOIN_GROUP_CHATS)) { purple_blist_add_chat (PC, tgp_blist_group_init ("Telegram Chats"), NULL); } } p2tgl_chat_update (TLS, PC, C->id, C->admin_id, C->print_title); }
void tgp_chat_on_loaded_chat_full (struct tgl_state *TLS, struct tgl_chat *C) { connection_data *conn = TLS->ev_base; PurpleChat *PC = p2tgl_chat_find (TLS, C->id); if (!PC) { PC = p2tgl_chat_new (TLS, C); if (purple_account_get_bool (conn->pa, TGP_KEY_JOIN_GROUP_CHATS, TGP_DEFAULT_JOIN_GROUP_CHATS)) { purple_blist_add_chat (PC, NULL, NULL); } } p2tgl_chat_update (PC, C->id, C->admin_id, C->print_title); }
AccountWindow::BoolOption::BoolOption(PurpleAccount *account_, PurpleAccountOption *option_) : account(account_), option(option_), type(TYPE_PURPLE) { g_assert(account); g_assert(option); setText(purple_account_option_get_text(option)); setChecked(purple_account_get_bool(account, purple_account_option_get_setting(option), purple_account_option_get_default_bool(option))); signal_toggle.connect(sigc::mem_fun(this, &BoolOption::onToggle)); }
void pending_reads_send_all (struct tgl_state *TLS) { if (! purple_account_get_bool (tls_get_pa (TLS), TGP_KEY_SEND_READ_NOTIFICATIONS, TGP_DEFAULT_SEND_READ_NOTIFICATIONS)) { debug ("automatic read recipes disabled, not sending recipes"); return; } if (! p2tgl_status_is_present (purple_account_get_active_status (tls_get_pa (TLS)))) { debug ("user is not present, not sending recipes"); return; } debug ("sending all pending recipes"); g_hash_table_foreach (tls_get_data (TLS)->pending_reads, tgl_do_mark_read_gw, TLS); g_hash_table_remove_all (tls_get_data (TLS)->pending_reads); }
gboolean fb_check_friend_requests(gpointer data) { FacebookAccount *fba; fba = data; if (purple_account_get_bool( fba->account, "facebook_manage_friends", FALSE)) { fb_post_or_get(fba, FB_METHOD_GET, NULL, "/reqs.php", NULL, fb_check_friend_request_cb, NULL, FALSE); } return TRUE; }
void twitter_send_request(PurpleAccount *account, gboolean post, const char *url, const char *query_string, TwitterSendRequestSuccessFunc success_callback, TwitterSendRequestErrorFunc error_callback, gpointer data) { gchar *request; const char *pass = purple_connection_get_password(purple_account_get_connection(account)); const char *sn = purple_account_get_username(account); char *auth_text = g_strdup_printf("%s:%s", sn, pass); char *auth_text_b64 = purple_base64_encode((guchar *) auth_text, strlen(auth_text)); gboolean use_https = purple_account_get_bool(account, "use_https", FALSE) && purple_ssl_is_supported(); char *host = "twitter.com"; TwitterSendRequestData *request_data = g_new0(TwitterSendRequestData, 1); char *full_url = g_strdup_printf("%s://%s%s", use_https ? "https" : "http", host, url); request_data->account = account; request_data->user_data = data; request_data->success_func = success_callback; request_data->error_func = error_callback; g_free(auth_text); request = g_strdup_printf( "%s %s%s%s HTTP/1.0\r\n" "User-Agent: Mozilla/4.0 (compatible; MSIE 5.5)\r\n" "Host: %s\r\n" "Authorization: Basic %s\r\n" "Content-Length: %d\r\n\r\n" "%s", post ? "POST" : "GET", full_url, (!post && query_string ? "?" : ""), (!post && query_string ? query_string : ""), host, auth_text_b64, query_string && post ? strlen(query_string) : 0, query_string && post ? query_string : ""); g_free(auth_text_b64); purple_util_fetch_url_request(full_url, TRUE, "Mozilla/4.0 (compatible; MSIE 5.5)", TRUE, request, FALSE, twitter_send_request_cb, request_data); g_free(full_url); g_free(request); }
static void pb_got_phonebook(PushBulletAccount *pba, JsonNode *node, gpointer user_data) { PurpleAccount *account = pba->account; JsonObject *rootobj = json_node_get_object(node); JsonArray *phonebook = json_object_get_array_member(rootobj, "phonebook"); gint i; guint len; gchar *device = user_data; PurpleGroup *pbgroup; pbgroup = purple_find_group("PushBullet"); if (!pbgroup) { pbgroup = purple_group_new("PushBullet"); purple_blist_add_group(pbgroup, NULL); } for(i = 0, len = json_array_get_length(phonebook); i < len; i++) { JsonObject *number = json_array_get_object_element(phonebook, i); const gchar *name = json_object_get_string_member(number, "name"); const gchar *phone = json_object_get_string_member(number, "phone"); const gchar *phone_type = json_object_get_string_member(number, "phone_type"); PurpleBuddy *pbuddy; //Only handle the right 'type' of phone number. //home, mobile, work, other if (purple_account_get_bool(account, "mobile_contacts_only", FALSE) && phone_type[0] != 'm') continue; pbuddy = purple_find_buddy(account, phone); if (!pbuddy) { pbuddy = purple_buddy_new(account, phone, name); purple_blist_add_buddy(pbuddy, NULL, pbgroup, NULL); purple_debug_info("pushbullet", "Added buddy %s %s\n", phone, name); } purple_prpl_got_user_status(account, phone, "mobile", NULL); purple_prpl_got_user_status(account, phone, purple_primitive_get_id_from_type(PURPLE_STATUS_AVAILABLE), NULL); } g_free(device); }
/*------------------------------------------------------------------------ * Create a new mxit session object * * @return The MXit session object */ static struct MXitSession* mxit_create_object( PurpleAccount* account ) { PurpleConnection* con = purple_account_get_connection( account ); struct MXitSession* session = NULL; /* currently the wapsite does not handle a '+' in front of the username (mxitid) so we just strip it */ { const char* username = purple_account_get_username( account ); if ( username[0] == '+' ) { char* fixed = g_strdup( &username[1] ); purple_account_set_username( account, fixed ); g_free( fixed ); } } session = g_new0( struct MXitSession, 1 ); session->con = con; session->acc = account; /* configure the connection (reference: "libpurple/connection.h") */ purple_connection_set_protocol_data( con, session ); purple_connection_set_flags( con, PURPLE_CONNECTION_FLAG_NO_BGCOLOR | PURPLE_CONNECTION_FLAG_NO_URLDESC | PURPLE_CONNECTION_FLAG_HTML | PURPLE_CONNECTION_FLAG_SUPPORT_MOODS ); /* configure the session (reference: "libpurple/account.h") */ g_strlcpy( session->server, purple_account_get_string( account, MXIT_CONFIG_SERVER_ADDR, DEFAULT_SERVER ), sizeof( session->server ) ); g_strlcpy( session->http_server, purple_account_get_string( account, MXIT_CONFIG_HTTPSERVER, DEFAULT_HTTP_SERVER ), sizeof( session->http_server ) ); session->port = purple_account_get_int( account, MXIT_CONFIG_SERVER_PORT, DEFAULT_PORT ); g_strlcpy( session->distcode, purple_account_get_string( account, MXIT_CONFIG_DISTCODE, "" ), sizeof( session->distcode ) ); g_strlcpy( session->clientkey, purple_account_get_string( account, MXIT_CONFIG_CLIENTKEY, "" ), sizeof( session->clientkey ) ); g_strlcpy( session->dialcode, purple_account_get_string( account, MXIT_CONFIG_DIALCODE, "" ), sizeof( session->dialcode ) ); session->http = purple_account_get_bool( account, MXIT_CONFIG_USE_HTTP, FALSE ); session->iimages = g_hash_table_new( g_str_hash, g_str_equal ); session->rx_state = RX_STATE_RLEN; session->http_interval = MXIT_HTTP_POLL_MIN; session->http_last_poll = mxit_now_milli(); session->async_http_reqs = purple_http_connection_set_new(); return session; }
void fb_group_remove(PurpleConnection *pc, PurpleGroup *group) { if (!purple_account_get_bool(pc->account, "facebook_use_groups", TRUE)) { //Dont do anything if we're ignoring groups return; } purple_debug_info("facebook", "got group removal of %s\n", purple_group_get_name(group)); // We don't do anything here. This is because a group rename also // fires a group removal event. This assumes that the new group is // equivalent to the old group, but Facebook friend lists are much more // than simple groups- they are privacy control lists too. There is // no easy way to port the settings between groups. Better off not // deleting, and the user can do the cleanup with their browser. }
gboolean fb_get_notifications_feed(FacebookAccount *fba) { const gchar *feed_url; if (purple_account_get_bool(fba->account, "facebook_get_notifications", TRUE)) { feed_url = purple_account_get_string(fba->account, "notifications_feed_url", NULL); if (!feed_url) { purple_debug_info("facebook", "no notifications feed url available, searching for it\n"); fb_find_feed_url(fba); return TRUE; } fb_post_or_get(fba, FB_METHOD_GET, NULL, feed_url, NULL, fb_got_notifications_cb, NULL, FALSE); } return TRUE; }
void fb_group_buddy_move(PurpleConnection *pc, const char *who, const char *old_group, const char *new_group) { FacebookAccount *fba; MoveRequest *request; const gchar *new_list_id; if (!purple_account_get_bool(pc->account, "facebook_use_groups", TRUE)) { //Dont do anything if we're ignoring groups return; } fba = pc->proto_data; purple_debug_info("facebook", "handling move of %s from %s to %s\n", who, old_group, new_group); // Don't do anything if groups are not actually changing. if (!purple_utf8_strcasecmp(old_group, new_group)) { purple_debug_info("facebook", "groups are same, not moving\n"); return; } // Facebook doesn't support moving yourself because you can't be in a // friend list. Let buddy list be updated as appropriate. if (atoll(who) == fba->uid) { purple_debug_info("facebook", "moving self, do not update server\n"); return; } request = g_new0(MoveRequest, 1); request->old_group = g_utf8_strdown(old_group, -1); request->new_group = g_utf8_strdown(new_group, -1); request->who = g_strdup(who); new_list_id = fb_get_list_id(fba, request->new_group); if (new_list_id) { handle_move_request(fba, request); } else { create_friend_list(fba, new_group, request); } }
static char *irc_recv_convert(struct irc_conn *irc, const char *string) { char *utf8 = NULL; const gchar *charset, *enclist; gchar **encodings; gboolean autodetect; int i; enclist = purple_account_get_string(irc->account, "encoding", IRC_DEFAULT_CHARSET); encodings = g_strsplit(enclist, ",", -1); if (encodings[0] == NULL) { g_strfreev(encodings); return purple_utf8_salvage(string); } autodetect = purple_account_get_bool(irc->account, "autodetect_utf8", IRC_DEFAULT_AUTODETECT); if (autodetect && g_utf8_validate(string, -1, NULL)) { return g_strdup(string); } for (i = 0; encodings[i] != NULL; i++) { charset = encodings[i]; while (*charset == ' ') charset++; if (!g_ascii_strcasecmp("UTF-8", charset)) { if (g_utf8_validate(string, -1, NULL)) utf8 = g_strdup(string); } else { utf8 = g_convert(string, -1, "UTF-8", charset, NULL, NULL, NULL); } if (utf8) { g_strfreev(encodings); return utf8; } } g_strfreev(encodings); return purple_utf8_salvage(string); }
void fb_add_buddy(PurpleConnection *pc, PurpleBuddy *buddy, PurpleGroup *group) { gchar *postdata; FacebookAccount *fba = pc->proto_data; gchar *buddy_tmp; if (!purple_account_get_bool( fba->account, "facebook_manage_friends", FALSE)) { /* * We used to pop up dialogs here but if a user renamed a group, * this would spawn message for each person in the buddy list. Bad! purple_notify_info(fba->pc, _("Friend not added"), _("Adding Facebook friends via Pidgin is disabled"), _("Either add a friend via Facebook.com or edit your account preferences")); */ purple_debug_warning("facebook", "attempted to add %s but was blocked\n", buddy->name); return; } if (atoll(buddy->name) == fba->uid) { purple_account_set_bool(fba->account, "facebook_hide_self", FALSE); return; } buddy_tmp = g_strdup(purple_url_encode(buddy->name)); postdata = g_strdup_printf( "user=%" G_GINT64_FORMAT "&profile_id=%s&message=&" "source=&submit=1&post_form_id=%s&fb_dtsg=%s&" "post_form_id_source=AsyncRequest&__a=1", fba->uid, buddy_tmp, fba->post_form_id, fba->dtsg); g_free(buddy_tmp); fb_post_or_get(fba, FB_METHOD_POST, NULL, "/ajax/profile/connect.php", postdata, NULL, NULL, FALSE); g_free(postdata); }
void fb_add_buddy(PurpleConnection *pc, PurpleBuddy *buddy, PurpleGroup *group) { gchar *postdata; gchar *url; FacebookAccount *fba = pc->proto_data; gchar *buddy_tmp; if (!purple_account_get_bool( fba->account, "facebook_manage_friends", FALSE)) { purple_notify_info(fba->pc, _("Friend not added"), _("Adding Facebook friends via Pidgin is disabled"), _("Either add a friend via Facebook.com or edit your account preferences")); // TODO: Message here return; } if (atoi(buddy->name) == fba->uid) { purple_account_set_bool(fba->account, "facebook_hide_self", FALSE); return; } buddy_tmp = g_strdup(purple_url_encode(buddy->name)); postdata = g_strdup_printf( "confirmed=1&add=Add+Friend&action=follow_up&uid=%s&flids=&flid_name=&source=search&is_from_whitelist=0&message=&failed_captcha=0&post_form_id=%s", buddy_tmp, fba->post_form_id); url = g_strdup_printf("/ajax/addfriend.php?id=%s", buddy_tmp); g_free(buddy_tmp); fb_post_or_get(fba, FB_METHOD_POST, NULL, url, postdata, NULL, NULL, FALSE); g_free(postdata); g_free(url); }
static void send_start_oscar_session(OscarData *od, const char *token, const char *session_key, time_t hosttime) { char *query_string, *signature, *url; PurpleAccount *account; gboolean use_tls; account = purple_connection_get_account(od->gc); use_tls = purple_account_get_bool(account, "use_ssl", OSCAR_DEFAULT_USE_SSL); /* * Construct the GET parameters. 0x00000611 is the distid given to * us by AOL for use as the default libpurple distid. */ query_string = g_strdup_printf("a=%s" "&distId=%d" "&f=xml" "&k=%s" "&ts=%" PURPLE_TIME_T_MODIFIER "&useTLS=%d", purple_url_encode(token), oscar_get_ui_info_int(od->icq ? "prpl-icq-distid" : "prpl-aim-distid", 0x00000611), get_client_key(od), hosttime, use_tls); signature = generate_signature("GET", URL_START_OSCAR_SESSION, query_string, session_key); url = g_strdup_printf(URL_START_OSCAR_SESSION "?%s&sig_sha256=%s", query_string, signature); g_free(query_string); g_free(signature); /* Make the request */ od->url_data = purple_util_fetch_url_request_len_with_account(account, url, TRUE, NULL, FALSE, NULL, FALSE, -1, start_oscar_session_cb, od); g_free(url); }
static void send_start_oscar_session(OscarData *od, const char *token, const char *session_key, time_t hosttime) { char *query_string, *signature, *url; gboolean use_tls = purple_account_get_bool(purple_connection_get_account(od->gc), "use_ssl", OSCAR_DEFAULT_USE_SSL); /* Construct the GET parameters */ query_string = g_strdup_printf("a=%s" "&f=xml" "&k=%s" "&ts=%" PURPLE_TIME_T_MODIFIER "&useTLS=%d", purple_url_encode(token), get_client_key(od), hosttime, use_tls); signature = generate_signature("GET", URL_START_OSCAR_SESSION, query_string, session_key); url = g_strdup_printf(URL_START_OSCAR_SESSION "?%s&sig_sha256=%s", query_string, signature); g_free(query_string); g_free(signature); /* Make the request */ od->url_data = purple_util_fetch_url(url, TRUE, NULL, FALSE, start_oscar_session_cb, od); g_free(url); }
static void ssl_cdsa_create_context(gpointer data) { PurpleSslConnection *gsc = (PurpleSslConnection *)data; PurpleAccount *account = gsc->account; PurpleSslCDSAData *cdsa_data; OSStatus err; bool requireFS = purple_account_get_bool(account, "require_forward_secrecy", FALSE); /* * allocate some memory to store variables for the cdsa connection. * the memory comes zero'd from g_new0 so we don't need to null the * pointers held in this struct. */ cdsa_data = g_new0(PurpleSslCDSAData, 1); gsc->private_data = cdsa_data; connections = g_list_append(connections, gsc); /* * allocate a new SSLContextRef object */ err = SSLNewContext(false, &cdsa_data->ssl_ctx); if (err != noErr) { purple_debug_error("cdsa", "SSLNewContext failed\n"); if (gsc->error_cb != NULL) gsc->error_cb(gsc, PURPLE_SSL_HANDSHAKE_FAILED, gsc->connect_cb_data); purple_ssl_close(gsc); return; } /* * Set up our callbacks for reading/writing the file descriptor */ err = SSLSetIOFuncs(cdsa_data->ssl_ctx, SocketRead, SocketWrite); if (err != noErr) { purple_debug_error("cdsa", "SSLSetIOFuncs failed\n"); if (gsc->error_cb != NULL) gsc->error_cb(gsc, PURPLE_SSL_HANDSHAKE_FAILED, gsc->connect_cb_data); purple_ssl_close(gsc); return; } /* * Pass the connection information to the connection to be used by our callbacks */ err = SSLSetConnection(cdsa_data->ssl_ctx, (SSLConnectionRef)(intptr_t)gsc->fd); if (err != noErr) { purple_debug_error("cdsa", "SSLSetConnection failed: %d\n", err); if (gsc->error_cb != NULL) gsc->error_cb(gsc, PURPLE_SSL_HANDSHAKE_FAILED, gsc->connect_cb_data); purple_ssl_close(gsc); return; } size_t numCiphers = 0; err = SSLGetNumberEnabledCiphers(cdsa_data->ssl_ctx, &numCiphers); if (err != noErr) { purple_debug_error("cdsa", "SSLGetNumberEnabledCiphers failed: %d\n", err); if (gsc->error_cb != NULL) gsc->error_cb(gsc, PURPLE_SSL_HANDSHAKE_FAILED, gsc->connect_cb_data); purple_ssl_close(gsc); return; } SSLCipherSuite ciphers[numCiphers]; err = SSLGetEnabledCiphers(cdsa_data->ssl_ctx, ciphers, &numCiphers); if (err != noErr) { purple_debug_error("cdsa", "SSLGetSupportedCiphers failed: %d\n", err); if (gsc->error_cb != NULL) gsc->error_cb(gsc, PURPLE_SSL_HANDSHAKE_FAILED, gsc->connect_cb_data); purple_ssl_close(gsc); return; } SSLCipherSuite enabledCiphers[numCiphers]; size_t numEnabledCiphers = 0; int i; for (i = 0; i < numCiphers; i++) { if (ssl_cdsa_use_cipher(ciphers[i], requireFS)) { enabledCiphers[numEnabledCiphers] = ciphers[i]; numEnabledCiphers++; } } err = SSLSetEnabledCiphers(cdsa_data->ssl_ctx, enabledCiphers, numEnabledCiphers); if (err != noErr) { purple_debug_error("cdsa", "SSLSetEnabledCiphers failed: %d\n", err); if (gsc->error_cb != NULL) gsc->error_cb(gsc, PURPLE_SSL_HANDSHAKE_FAILED, gsc->connect_cb_data); purple_ssl_close(gsc); return; } if (purple_account_get_bool(account, PURPLE_SSL_CDSA_BUGGY_TLS_WORKAROUND, false)) { purple_debug_info("cdsa", "Explicitly disabling TLS 1.1 and above to try and work around buggy TLS stacks\n"); OSStatus protoErr; protoErr = SSLSetProtocolVersionEnabled(cdsa_data->ssl_ctx, kSSLProtocolAll, false); if (protoErr != noErr) { purple_debug_error("cdsa", "SSLSetProtocolVersionEnabled failed to disable protocols\n"); if (gsc->error_cb != NULL) gsc->error_cb(gsc, PURPLE_SSL_HANDSHAKE_FAILED, gsc->connect_cb_data); purple_ssl_close(gsc); return; } protoErr = SSLSetProtocolVersionEnabled(cdsa_data->ssl_ctx, kSSLProtocol3, true); protoErr = SSLSetProtocolVersionEnabled(cdsa_data->ssl_ctx, kTLSProtocol1, true); } if(gsc->host) { /* * Set the peer's domain name so CDSA can check the certificate's CN */ err = SSLSetPeerDomainName(cdsa_data->ssl_ctx, gsc->host, strlen(gsc->host)); if (err != noErr) { purple_debug_error("cdsa", "SSLSetPeerDomainName failed\n"); if (gsc->error_cb != NULL) gsc->error_cb(gsc, PURPLE_SSL_HANDSHAKE_FAILED, gsc->connect_cb_data); purple_ssl_close(gsc); return; } } /* * Disable verifying the certificate chain. * We have to do that manually later on! This is the only way to be able to continue with a connection, even though the user * had to manually accept the certificate. */ err = SSLSetEnableCertVerify(cdsa_data->ssl_ctx, false); if (err != noErr) { purple_debug_error("cdsa", "SSLSetEnableCertVerify failed\n"); /* error is not fatal */ } cdsa_data->handshake_handler = purple_input_add(gsc->fd, PURPLE_INPUT_READ, ssl_cdsa_handshake_cb, gsc); }