libpurple/protocols/facebook/data.c

/* purple
 *
 * Purple is the legal property of its developers, whose names are too numerous
 * to list here.  Please refer to the COPYRIGHT file distributed with this
 * source distribution.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
 */

#include <libsoup/soup.h>
#include <string.h>

#include <purple.h>
#include "libpurple/glibcompat.h"

#include "api.h"
#include "data.h"

/**
 * FbData:
 *
 * Represents the connection data used by #FacebookProtocol.
 */
struct _FbData {
	GObject parent;

	FbApi *api;
	SoupSession *cons;
	PurpleConnection *gc;
	PurpleRoomlist *roomlist;
	GQueue *msgs;
	GHashTable *imgs;
	GHashTable *unread;
	GHashTable *evs;
};

/**
 * FbDataImage:
 *
 * Represents the data used for fetching images.
 */
struct _FbDataImage {
	GObject parent;

	FbData *fata;
	gchar *url;
	FbDataImageFunc func;
	gpointer data;
	GDestroyNotify dunc;

	gboolean active;
	const guint8 *image;
	gsize size;
};

static const gchar *fb_props_strs[] = {
	"cid",
	"did",
	"stoken",
	"token"
};

G_DEFINE_TYPE(FbData, fb_data, G_TYPE_OBJECT);
G_DEFINE_TYPE(FbDataImage, fb_data_image, G_TYPE_OBJECT);

static void
fb_data_dispose(GObject *obj)
{
	FbData *fata = FB_DATA(obj);

	if(fata->cons != NULL) {
		soup_session_abort(fata->cons);
	}

	if(fata->evs != NULL) {
		GHashTableIter iter;
		gpointer ptr = NULL;

		g_hash_table_iter_init(&iter, fata->evs);
		while (g_hash_table_iter_next(&iter, NULL, &ptr)) {
			g_source_remove(GPOINTER_TO_UINT(ptr));
		}
	}

	g_clear_object(&fata->api);

	g_clear_object(&fata->cons);
	if(fata->msgs != NULL) {
		g_queue_free_full(fata->msgs, (GDestroyNotify)fb_api_message_free);
		fata->msgs = NULL;
	}

	g_clear_pointer(&fata->imgs, g_hash_table_destroy);
	g_clear_pointer(&fata->unread, g_hash_table_destroy);
	g_clear_pointer(&fata->evs, g_hash_table_destroy);
}

static void
fb_data_class_init(FbDataClass *klass)
{
	GObjectClass *gklass = G_OBJECT_CLASS(klass);

	gklass->dispose = fb_data_dispose;
}

static void
fb_data_init(FbData *fata)
{
	fata->msgs = g_queue_new();

	fata->imgs = g_hash_table_new_full(g_direct_hash, g_direct_equal,
	                                   g_object_unref, NULL);
	fata->unread = g_hash_table_new_full(fb_id_hash, fb_id_equal,
	                                     g_free, NULL);
	fata->evs = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
}

static void
fb_data_image_dispose(GObject *obj)
{
	FbDataImage *img = FB_DATA_IMAGE(obj);
	FbData *fata = img->fata;

	if (img->dunc != NULL && img->data != NULL) {
		img->dunc(img->data);
		img->dunc = NULL;
	}

	g_clear_pointer(&img->url, g_free);
	g_hash_table_steal(fata->imgs, img);
}

static void
fb_data_image_class_init(FbDataImageClass *klass)
{
	GObjectClass *gklass = G_OBJECT_CLASS(klass);

	gklass->dispose = fb_data_image_dispose;
}

static void
fb_data_image_init(FbDataImage *img)
{
}

FbData *
fb_data_new(PurpleConnection *gc, GProxyResolver *resolver)
{
	FbData *fata;

	fata = g_object_new(FB_TYPE_DATA, NULL);

	fata->cons = soup_session_new_with_options("proxy-resolver", resolver,
	                                           NULL);
	fata->api = fb_api_new(gc, resolver);
	fata->gc = gc;

	return fata;
}

gboolean
fb_data_load(FbData *fata)
{
	const gchar *str;
	FbId id;
	gboolean ret = TRUE;
	guint i;
	guint64 uint;
	GValue val = G_VALUE_INIT;
	PurpleAccount *acct;

	g_return_val_if_fail(FB_IS_DATA(fata), FALSE);
	acct = purple_connection_get_account(fata->gc);

	for (i = 0; i < G_N_ELEMENTS(fb_props_strs); i++) {
		str = purple_account_get_string(acct, fb_props_strs[i], NULL);

		if (str == NULL) {
			ret = FALSE;
		}

		g_value_init(&val, G_TYPE_STRING);
		g_value_set_string(&val, str);
		g_object_set_property(G_OBJECT(fata->api), fb_props_strs[i],
		                      &val);
		g_value_unset(&val);
	}

	str = purple_account_get_string(acct, "mid", NULL);

	if (str != NULL) {
		uint = g_ascii_strtoull(str, NULL, 10);
		g_value_init(&val, G_TYPE_UINT64);
		g_value_set_uint64(&val, uint);
		g_object_set_property(G_OBJECT(fata->api), "mid", &val);
		g_value_unset(&val);
	} else {
		ret = FALSE;
	}

	str = purple_account_get_string(acct, "uid", NULL);

	if (str != NULL) {
		id = FB_ID_FROM_STR(str);
		g_value_init(&val, FB_TYPE_ID);
		g_value_set_int64(&val, id);
		g_object_set_property(G_OBJECT(fata->api), "uid", &val);
		g_value_unset(&val);
	} else {
		ret = FALSE;
	}

	fb_api_rehash(fata->api);
	return ret;
}

void
fb_data_save(FbData *fata)
{
	const gchar *str;
	gchar *dup;
	guint i;
	guint64 uint;
	GValue val = G_VALUE_INIT;
	PurpleAccount *acct;

	g_return_if_fail(FB_IS_DATA(fata));
	acct = purple_connection_get_account(fata->gc);

	for (i = 0; i < G_N_ELEMENTS(fb_props_strs); i++) {
		g_value_init(&val, G_TYPE_STRING);
		g_object_get_property(G_OBJECT(fata->api), fb_props_strs[i],
		                      &val);
		str = g_value_get_string(&val);

		if (purple_strequal(fb_props_strs[i], "token") && !purple_account_get_remember_password(acct)) {
			str = "";
		}
		purple_account_set_string(acct, fb_props_strs[i], str);
		g_value_unset(&val);
	}

	g_value_init(&val, G_TYPE_UINT64);
	g_object_get_property(G_OBJECT(fata->api), "mid", &val);
	uint = g_value_get_uint64(&val);
	g_value_unset(&val);

	dup = g_strdup_printf("%" G_GINT64_FORMAT, uint);
	purple_account_set_string(acct, "mid", dup);
	g_free(dup);

	g_value_init(&val, G_TYPE_INT64);
	g_object_get_property(G_OBJECT(fata->api), "uid", &val);
	uint = g_value_get_int64(&val);
	g_value_unset(&val);

	dup = g_strdup_printf("%" FB_ID_FORMAT, uint);
	purple_account_set_string(acct, "uid", dup);
	g_free(dup);
}

void
fb_data_save_timeout(FbData *fata, const gchar *name, guint id)
{
	g_return_if_fail(FB_IS_DATA(fata));

	fb_data_clear_timeout(fata, name, TRUE);

	g_hash_table_replace(fata->evs, g_strdup(name), GUINT_TO_POINTER(id));
}

void
fb_data_clear_timeout(FbData *fata, const gchar *name, gboolean remove)
{
	gpointer ptr;
	guint id;

	g_return_if_fail(FB_IS_DATA(fata));

	ptr = g_hash_table_lookup(fata->evs, name);
	id = GPOINTER_TO_UINT(ptr);

	if ((id > 0) && remove) {
		g_source_remove(id);
	}

	g_hash_table_remove(fata->evs, name);
}

FbApi *
fb_data_get_api(FbData *fata)
{

	g_return_val_if_fail(FB_IS_DATA(fata), NULL);

	return fata->api;
}

PurpleConnection *
fb_data_get_connection(FbData *fata)
{
	g_return_val_if_fail(FB_IS_DATA(fata), NULL);

	return fata->gc;
}

PurpleRoomlist *
fb_data_get_roomlist(FbData *fata)
{
	g_return_val_if_fail(FB_IS_DATA(fata), NULL);

	return fata->roomlist;
}

gboolean
fb_data_get_unread(FbData *fata, FbId id)
{
	gpointer *ptr;

	g_return_val_if_fail(FB_IS_DATA(fata), FALSE);
	g_return_val_if_fail(id != 0, FALSE);

	ptr = g_hash_table_lookup(fata->unread, &id);
	return GPOINTER_TO_INT(ptr);
}

void
fb_data_set_roomlist(FbData *fata, PurpleRoomlist *list)
{
	g_return_if_fail(FB_IS_DATA(fata));

	fata->roomlist = list;
}

void
fb_data_set_unread(FbData *fata, FbId id, gboolean unread)
{
	gpointer key;

	g_return_if_fail(FB_IS_DATA(fata));
	g_return_if_fail(id != 0);

	if (!unread) {
		g_hash_table_remove(fata->unread, &id);
		return;
	}

	key = g_memdup2(&id, sizeof id);
	g_hash_table_replace(fata->unread, key, GINT_TO_POINTER(unread));
}

void
fb_data_add_message(FbData *fata, FbApiMessage *msg)
{
	g_return_if_fail(FB_IS_DATA(fata));

	g_queue_push_tail(fata->msgs, msg);
}

void
fb_data_remove_message(FbData *fata, FbApiMessage *msg)
{
	g_return_if_fail(FB_IS_DATA(fata));

	g_queue_remove(fata->msgs, msg);
}

GSList *
fb_data_take_messages(FbData *fata, FbId uid)
{
	FbApiMessage *msg;
	GList *l;
	GList *prev;
	GSList *msgs = NULL;

	g_return_val_if_fail(FB_IS_DATA(fata), NULL);
	l = fata->msgs->tail;

	while (l != NULL) {
		msg = l->data;
		prev = l->prev;

		if (msg->uid == uid) {
			msgs = g_slist_prepend(msgs, msg);
			g_queue_delete_link(fata->msgs, l);
		}

		l = prev;
	}

	return msgs;
}

FbDataImage *
fb_data_image_add(FbData *fata, const gchar *url, FbDataImageFunc func,
                  gpointer data, GDestroyNotify dunc)
{
	FbDataImage *img;

	g_return_val_if_fail(FB_IS_DATA(fata), NULL);
	g_return_val_if_fail(url != NULL, NULL);
	g_return_val_if_fail(func != NULL, NULL);

	img = g_object_new(FB_TYPE_DATA_IMAGE, NULL);

	img->fata = fata;
	img->url = g_strdup(url);
	img->func = func;
	img->data = data;
	img->dunc = dunc;

	g_hash_table_insert(fata->imgs, img, img);
	return img;
}

gboolean
fb_data_image_get_active(FbDataImage *img)
{
	g_return_val_if_fail(FB_IS_DATA_IMAGE(img), FALSE);

	return img->active;
}

gpointer
fb_data_image_get_data(FbDataImage *img)
{
	g_return_val_if_fail(FB_IS_DATA_IMAGE(img), NULL);

	return img->data;
}

FbData *
fb_data_image_get_fata(FbDataImage *img)
{
	g_return_val_if_fail(FB_IS_DATA_IMAGE(img), NULL);

	return img->fata;
}

const guint8 *
fb_data_image_get_image(FbDataImage *img, gsize *size)
{
	g_return_val_if_fail(FB_IS_DATA_IMAGE(img), NULL);

	if (size != NULL) {
		*size = img->size;
	}

	return img->image;
}

guint8 *
fb_data_image_dup_image(FbDataImage *img, gsize *size)
{
	g_return_val_if_fail(FB_IS_DATA_IMAGE(img), NULL);

	if (size != NULL) {
		*size = img->size;
	}

	if (img->size < 1) {
		return NULL;
	}

	return g_memdup2(img->image, img->size);
}

const gchar *
fb_data_image_get_url(FbDataImage *img)
{
	g_return_val_if_fail(FB_IS_DATA_IMAGE(img), NULL);

	return img->url;
}

static void
fb_data_image_cb(GObject *source, GAsyncResult *result, gpointer data) {
	SoupMessage *msg = data;
	FbDataImage *img = g_object_get_data(G_OBJECT(msg), "facebook-data-image");
	GError *err = NULL;

	if(fb_http_error_chk(msg, &err)) {
		GBytes *bytes = NULL;

		bytes = soup_session_send_and_read_finish(SOUP_SESSION(source),
		                                          result, &err);
		if(bytes != NULL) {
			img->image = g_bytes_unref_to_data(bytes, &img->size);
		}
	}

	img->func(img, err);

	if (G_LIKELY(err == NULL)) {
		fb_data_image_queue(img->fata);
	} else {
		g_error_free(err);
	}

	g_object_unref(img);
	g_object_unref(msg);
}

void
fb_data_image_queue(FbData *fata)
{
	const gchar *url;
	FbDataImage *img;
	GHashTableIter iter;
	guint active = 0;

	g_return_if_fail(FB_IS_DATA(fata));
	g_hash_table_iter_init(&iter, fata->imgs);

	while (g_hash_table_iter_next(&iter, (gpointer *) &img, NULL)) {
		if (fb_data_image_get_active(img)) {
			active++;
		}
	}

	if (active >= FB_DATA_ICON_MAX) {
		return;
	}

	g_hash_table_iter_init(&iter, fata->imgs);

	while (g_hash_table_iter_next(&iter, (gpointer *) &img, NULL)) {
		SoupMessage *msg;

		if (fb_data_image_get_active(img)) {
			continue;
		}

		img->active = TRUE;
		url = fb_data_image_get_url(img);

		msg = soup_message_new("GET", url);
		g_object_set_data(G_OBJECT(msg), "facebook-data-image", img);
		// purple_http_request_set_max_len(req, FB_DATA_ICON_SIZE_MAX);
		soup_session_send_and_read_async(fata->cons, msg, G_PRIORITY_DEFAULT,
		                                 NULL, fb_data_image_cb, msg);

		if (++active >= FB_DATA_ICON_MAX) {
			break;
		}
	}
}