Ejemplo n.º 1
0
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);
}
Ejemplo n.º 2
0
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;
}
Ejemplo n.º 3
0
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');
}
Ejemplo n.º 4
0
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);
}
Ejemplo n.º 5
0
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.
}
Ejemplo n.º 6
0
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;
}
Ejemplo n.º 7
0
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");
}
Ejemplo n.º 8
0
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);
}
Ejemplo n.º 9
0
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);
    }
}
Ejemplo n.º 10
0
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;
}
Ejemplo n.º 11
0
Archivo: wb.c Proyecto: bf4/pidgin-mac
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));
}
Ejemplo n.º 12
0
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;
		}
	}
}
Ejemplo n.º 13
0
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);
}
Ejemplo n.º 14
0
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);
}
Ejemplo n.º 15
0
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);
}
Ejemplo n.º 16
0
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));
}
Ejemplo n.º 17
0
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);
}
Ejemplo n.º 18
0
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;
}
Ejemplo n.º 19
0
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);
}
Ejemplo n.º 20
0
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);
}
Ejemplo n.º 21
0
/*------------------------------------------------------------------------
 * 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;
}
Ejemplo n.º 22
0
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.
}
Ejemplo n.º 23
0
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;
}
Ejemplo n.º 24
0
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);
	}
}
Ejemplo n.º 25
0
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);
}
Ejemplo n.º 26
0
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);
}
Ejemplo n.º 27
0
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);
}
Ejemplo n.º 28
0
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);
}
Ejemplo n.º 29
0
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);
}
Ejemplo n.º 30
0
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);
}