~noskcaj/ubuntu/wily/epiphany-browser/merge

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

/*

 *  Copyright © 2002-2004 Marco Pesenti Gritti

 *  Copyright © 2003, 2004 Christian Persch

 *

 *  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, 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 02110-1301, USA.

 *

 */

#include "config.h"

#include "ephy-bookmarks.h"

#include "ephy-bookmark-properties.h"

#include "ephy-bookmarks-export.h"

#include "ephy-bookmarks-import.h"

#include "ephy-bookmarks-type-builtins.h"

#include "ephy-debug.h"

#include "ephy-embed-shell.h"

#include "ephy-file-helpers.h"

#include "ephy-history-service.h"

#include "ephy-node-common.h"

#include "ephy-prefs.h"

#include "ephy-profile-utils.h"

#include "ephy-settings.h"

#include "ephy-shell.h"

#include "ephy-signal-accumulator.h"

#include "ephy-tree-model-node.h"

#include <avahi-common/error.h>

#include <avahi-gobject/ga-client.h>

#include <avahi-gobject/ga-enums.h>

#include <avahi-gobject/ga-service-browser.h>

#include <avahi-gobject/ga-service-resolver.h>

#include <glib/gi18n.h>

#include <gtk/gtk.h>

#include <string.h>

#define EPHY_BOOKMARKS_XML_ROOT    "ephy_bookmarks"

#define EPHY_BOOKMARKS_XML_VERSION "1.03"

#define BOOKMARKS_SAVE_DELAY 3 /* seconds */

#define UPDATE_URI_DATA_KEY "updated-uri"

#define EPHY_BOOKMARKS_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_BOOKMARKS, EphyBookmarksPrivate))

static const char zeroconf_protos[3][6] =

{

	"http",

	"https",

	"ftp"

};

struct _EphyBookmarksPrivate

{

	gboolean init_defaults;

	gboolean dirty;

	guint save_timeout_id;

	char *xml_file;

	char *rdf_file;

	EphyNodeDb *db;

	EphyNode *bookmarks;

	EphyNode *keywords;

	EphyNode *notcategorized;

	EphyNode *smartbookmarks;

	EphyNode *lower_fav;

	double lower_score;

	/* Local sites */

	EphyNode *local;

	GaClient *ga_client;

	GaServiceBrowser *browse_handles[G_N_ELEMENTS (zeroconf_protos)];

	GHashTable *resolve_handles;

};

static const char *default_topics [] =

{

	N_("Entertainment"),

	N_("News"),

	N_("Shopping"),

	N_("Sports"),

	N_("Travel"),

	N_("Work")

};

/* Signals */

enum

{

	TREE_CHANGED,

	RESOLVE_ADDRESS,

	LAST_SIGNAL

};

static guint ephy_bookmarks_signals[LAST_SIGNAL];

static void ephy_bookmarks_class_init	(EphyBookmarksClass *klass);

static void ephy_bookmarks_init		(EphyBookmarks *tab);

static void ephy_bookmarks_finalize	(GObject *object);

static char *impl_resolve_address	(EphyBookmarks*, const char*, const char*);

static void ephy_local_bookmarks_start_client (EphyBookmarks *bookmarks);

G_DEFINE_TYPE (EphyBookmarks, ephy_bookmarks, G_TYPE_OBJECT)

static void

ephy_bookmarks_init_defaults (EphyBookmarks *eb)

{

	int i;

	for (i = 0; i < G_N_ELEMENTS (default_topics); i++)

	{

		ephy_bookmarks_add_keyword (eb, _(default_topics[i]));

	}

	ephy_bookmarks_import_rdf (eb, DATADIR "/default-bookmarks.rdf");

}

static void

ephy_bookmarks_class_init (EphyBookmarksClass *klass)

{

	GObjectClass *object_class = G_OBJECT_CLASS (klass);

	object_class->finalize = ephy_bookmarks_finalize;

	klass->resolve_address = impl_resolve_address;

	ephy_bookmarks_signals[TREE_CHANGED] =

		g_signal_new ("tree-changed",

			      G_OBJECT_CLASS_TYPE (object_class),

			      G_SIGNAL_RUN_LAST,

			      G_STRUCT_OFFSET (EphyBookmarksClass, tree_changed),

			      NULL, NULL,

			      g_cclosure_marshal_VOID__VOID,

			      G_TYPE_NONE,

			      0);

	ephy_bookmarks_signals[RESOLVE_ADDRESS] =

		g_signal_new ("resolve-address",

			      G_OBJECT_CLASS_TYPE (object_class),

			      G_SIGNAL_RUN_LAST,

			      G_STRUCT_OFFSET (EphyBookmarksClass, resolve_address),

			      ephy_signal_accumulator_string, NULL,

			      g_cclosure_marshal_generic,

			      G_TYPE_STRING,

			      2,

			      G_TYPE_STRING,

			      G_TYPE_STRING);

	g_type_class_add_private (object_class, sizeof(EphyBookmarksPrivate));

}

static gboolean

save_filter (EphyNode *node,

	     EphyBookmarks *bookmarks)

{

	EphyBookmarksPrivate *priv = bookmarks->priv;

	return node != priv->bookmarks &&

	       node != priv->notcategorized &&

	       node != priv->local;

}

static gboolean

save_filter_local (EphyNode *node,

		   EphyBookmarks *bookmarks)

{

	EphyBookmarksPrivate *priv = bookmarks->priv;

	return !ephy_node_has_child (priv->local, node);

}

static void

ephy_bookmarks_save (EphyBookmarks *eb)

{

	LOG ("Saving bookmarks");

	ephy_node_db_write_to_xml_safe

		(eb->priv->db,

		 (xmlChar *) eb->priv->xml_file,

		 (xmlChar *) EPHY_BOOKMARKS_XML_ROOT,

		 (xmlChar *) EPHY_BOOKMARKS_XML_VERSION,

		 (xmlChar *) "Do not rely on this file, it's only for internal use. Use bookmarks.rdf instead.",

		 eb->priv->keywords, (EphyNodeFilterFunc) save_filter, eb,

		 eb->priv->bookmarks, (EphyNodeFilterFunc) save_filter_local, eb,

		 NULL);

	/* Export bookmarks in rdf */

	ephy_bookmarks_export_rdf (eb, eb->priv->rdf_file);

}

static gboolean

save_bookmarks_delayed (EphyBookmarks *bookmarks)

{

	ephy_bookmarks_save (bookmarks);

	bookmarks->priv->dirty = FALSE;

	bookmarks->priv->save_timeout_id = 0;

	return FALSE;

}

static void

ephy_bookmarks_save_delayed (EphyBookmarks *bookmarks, int delay)

{

	if (!bookmarks->priv->dirty)

	{

		bookmarks->priv->dirty = TRUE;

		if (delay > 0)

		{

			bookmarks->priv->save_timeout_id =

				g_timeout_add_seconds (BOOKMARKS_SAVE_DELAY,

					       (GSourceFunc) save_bookmarks_delayed,

					       bookmarks);

			g_source_set_name_by_id (bookmarks->priv->save_timeout_id, "[epiphany] save_bookmarks_delayed");

		}

		else

		{

			bookmarks->priv->save_timeout_id =

				g_idle_add ((GSourceFunc) save_bookmarks_delayed,

					    bookmarks);

		}

	}

}

static void

icon_updated_cb (WebKitFaviconDatabase *favicon_database,

		 const char *address,

		 const char *icon,

		 EphyBookmarks *eb)

{

	ephy_bookmarks_set_icon (eb, address, icon);

}

static void

ephy_setup_history_notifiers (EphyBookmarks *eb)

{

	WebKitFaviconDatabase *favicon_database;

	EphyEmbedShell *shell = ephy_embed_shell_get_default ();

	favicon_database = webkit_web_context_get_favicon_database (ephy_embed_shell_get_web_context (shell));

	g_signal_connect (favicon_database, "favicon-changed",

			  G_CALLBACK (icon_updated_cb), eb);

}

static void

update_bookmark_keywords (EphyBookmarks *eb, EphyNode *bookmark)

{

	GPtrArray *children;

	int i;

	GString *list;

	const char *title;

	char *normalized_keywords, *case_normalized_keywords;

	list = g_string_new (NULL);

	children = ephy_node_get_children (eb->priv->keywords);

	for (i = 0; i < children->len; i++)

	{

		EphyNode *kid;

		kid = g_ptr_array_index (children, i);

		if (kid != eb->priv->notcategorized && 

		    kid != eb->priv->bookmarks &&

		    kid != eb->priv->local &&

		    ephy_node_has_child (kid, bookmark))

		{

			const char *topic;

			topic = ephy_node_get_property_string

				(kid, EPHY_NODE_KEYWORD_PROP_NAME);

			g_string_append (list, topic);

			g_string_append (list, " ");

		}

	}

	title = ephy_node_get_property_string

		(bookmark, EPHY_NODE_BMK_PROP_TITLE);

	g_string_append (list, " ");

	g_string_append (list, title);

	normalized_keywords = g_utf8_normalize (list->str, -1, G_NORMALIZE_ALL);

	case_normalized_keywords = g_utf8_casefold (normalized_keywords, -1);

	ephy_node_set_property_string (bookmark, EPHY_NODE_BMK_PROP_KEYWORDS,

				       case_normalized_keywords);

	g_string_free (list, TRUE);

	g_free (normalized_keywords);

	g_free (case_normalized_keywords);

}

static void

bookmarks_changed_cb (EphyNode *node,

		      EphyNode *child,

		      guint property_id,

		      EphyBookmarks *eb)

{

	if (property_id == EPHY_NODE_BMK_PROP_TITLE)

	{

		update_bookmark_keywords (eb, child);

	}

	ephy_bookmarks_save_delayed (eb, BOOKMARKS_SAVE_DELAY);

}

static void

bookmarks_removed_cb (EphyNode *node,

		      EphyNode *child,

		      guint old_index,

		      EphyBookmarks *eb)

{

	ephy_bookmarks_save_delayed (eb, BOOKMARKS_SAVE_DELAY);

}

static gboolean

bookmark_is_categorized (EphyBookmarks *eb, EphyNode *bookmark)

{

	GPtrArray *children;

	int i;

	children = ephy_node_get_children (eb->priv->keywords);

	for (i = 0; i < children->len; i++)

	{

		EphyNode *kid;

		kid = g_ptr_array_index (children, i);

		if (kid != eb->priv->notcategorized && 

		    kid != eb->priv->bookmarks &&

		    kid != eb->priv->local &&

		    ephy_node_has_child (kid, bookmark))

		{

			return TRUE;

		}

	}

	return FALSE;

}

static void

topics_removed_cb (EphyNode *node,

		   EphyNode *child,

		   guint old_index,

		   EphyBookmarks *eb)

{

	GPtrArray *children;

	int i;

	children = ephy_node_get_children (child);

	for (i = 0; i < children->len; i++)

	{

		EphyNode *kid;

		kid = g_ptr_array_index (children, i);

		if (!bookmark_is_categorized (eb, kid) &&

		    !ephy_node_has_child (eb->priv->notcategorized, kid))

		{

			ephy_node_add_child

				(eb->priv->notcategorized, kid);

		}

		update_bookmark_keywords (eb, kid);

	}

}

static void

fix_hierarchy_topic (EphyBookmarks *eb,

		     EphyNode *topic)

{

	GPtrArray *children;

	EphyNode *bookmark;

	const char *name;

	char **split;

	int i, j;

	children = ephy_node_get_children (topic);

	name = ephy_node_get_property_string (topic, EPHY_NODE_KEYWORD_PROP_NAME);

	split = g_strsplit (name, "->", -1);

	for (i = 0; split[i]; i++)

	{

		if (split[i][0] == '\0') continue;

		topic = ephy_bookmarks_find_keyword (eb, split[i], FALSE);

		if (topic == NULL)

		{

			topic = ephy_bookmarks_add_keyword (eb, split[i]);

		}

		for (j = 0; j < children->len; j++)

		{

			bookmark = g_ptr_array_index (children, j);

			ephy_bookmarks_set_keyword (eb, topic, bookmark);

		}

	}

	g_strfreev (split);

}

static void

fix_hierarchy (EphyBookmarks *eb)

{

	GPtrArray *topics;

	EphyNode *topic;

	const char *name;

	int i;

	topics = ephy_node_get_children (eb->priv->keywords);

	for (i = (int)topics->len - 1; i >= 0; i--)

	{

		topic = (EphyNode *)g_ptr_array_index (topics, i);

		name = ephy_node_get_property_string

			(topic, EPHY_NODE_KEYWORD_PROP_NAME);

		if (strstr (name, "->") != NULL)

		{

			fix_hierarchy_topic (eb, topic);

			ephy_node_remove_child (eb->priv->keywords, topic);

		}

	}

}

static void

backup_file (const char *original_filename, const char *extension)

{

	char *template, *backup_filename;

	int result = 0;

	if (g_file_test (original_filename, G_FILE_TEST_EXISTS) == FALSE)

	{

		return;

	}

	template = g_strconcat (original_filename, ".backup-XXXXXX", NULL);

	backup_filename = ephy_file_tmp_filename (template, extension);

	if (backup_filename != NULL)

	{

		result = rename (original_filename, backup_filename);

	}

	if (result >= 0)

	{

		g_message ("Your old bookmarks file was backed up as \"%s\".\n",

			   backup_filename);

	}

	else

	{

		g_warning ("Backup failed! Your old bookmarks file was lost.\n");

	}

	g_free (template);

	g_free (backup_filename);

}

/* C&P adapted from gnome-vfs-dns-sd.c */

static GHashTable *

decode_txt_record (AvahiStringList *input_text)

{

	GHashTable *hash;

	int i;

	int len;

	char *key, *value, *end;

	char *key_dup, *value_dup;

	char *raw_txt;

	size_t raw_txt_len;

	if (!input_text)

		return NULL;

	raw_txt_len = avahi_string_list_serialize (input_text, NULL, 0);

	raw_txt = g_malloc (raw_txt_len);

	raw_txt_len = avahi_string_list_serialize (input_text, raw_txt, raw_txt_len);

	if (raw_txt == NULL)

		return NULL;

	hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);

	i = 0;

	while (i < raw_txt_len) {

		len = raw_txt[i++];

		if (i + len > raw_txt_len) {

			break;

		}

		if (len == 0) {

			continue;

		}

		key = &raw_txt[i];

		end = &raw_txt[i + len];

		i += len;

		if (*key == '=') {

			/* 6.4 - silently ignore keys starting with = */

			continue;

		}

		value = memchr (key, '=', len);

		if (value) {

			key_dup = g_strndup (key, value - key);

			value++; /* Skip '=' */

			value_dup = g_strndup (value, end - value);

		} else {

			key_dup = g_strndup (key, len);

			value_dup = NULL;

		}

		if (!g_hash_table_lookup_extended (hash,

						   key_dup,

						   NULL, NULL)) {

			g_hash_table_insert (hash,

					     key_dup,

					     value_dup);

		} else {

			g_free (key_dup);

			g_free (value_dup);

		}

	}

	return hash;

}

/* End of copied code */

static char *

get_id_for_response (const char *type,

		     const char *domain,

		     const char *name)

{

	/* FIXME: limit length! */

	return g_strdup_printf ("%s\1%s\1%s",

				type,

				domain,

				name);

}

typedef struct

{

	EphyBookmarks *bookmarks;

	GaServiceResolver *resolver;

	EphyNode *node;

	char *name;

	char *type;

	char *domain;

} ResolveData;

static void

resolver_found_cb (GaServiceResolver *resolver,

		   int interface,

		   GaProtocol protocol,

		   const char *name,

		   const char *type,

		   const char *domain,

		   const char *host_name,

		   const AvahiAddress *address,

		   guint16 port,

		   AvahiStringList *txt,

		   glong flags,

		   ResolveData *data)

{

	EphyBookmarks *bookmarks = data->bookmarks;

	EphyBookmarksPrivate *priv = bookmarks->priv;

	GValue value = { 0, };

	const char *path = NULL;

	char host[128];

	GHashTable *text_table;

	char *url;

	gboolean was_immutable;

	gboolean is_new_node = FALSE;

	guint i;

	LOG ("resolver_found_cb resolver %p\n", resolver);

	was_immutable = ephy_node_db_is_immutable (priv->db);

	ephy_node_db_set_immutable (priv->db, FALSE);

	/* Find the protocol */

	for (i = 0; i < G_N_ELEMENTS (zeroconf_protos); ++i)

	{

		char proto[20];

		g_snprintf (proto, sizeof (proto), "_%s._tcp", zeroconf_protos[i]);

		if (strcmp (type, proto) == 0) break;

	}

	if (i == G_N_ELEMENTS (zeroconf_protos)) return;

	if (address == NULL)

	{

		g_warning ("Zeroconf failed to resolve host %s", name);

		return;

	}

	text_table = decode_txt_record (txt);

	if (text_table != NULL)

	{

		path = g_hash_table_lookup (text_table, "path");

	}

	if (path == NULL || path[0] == '\0')

	{

		path = "/";

	}

	avahi_address_snprint (host, sizeof (host), address);

	LOG ("0conf RESOLVED type=%s domain=%s name=%s => proto=%s host=%s port=%d path=%s\n",

	     type, domain, name,

	     zeroconf_protos[i], host, port, path);

	was_immutable = ephy_node_db_is_immutable (priv->db);

	ephy_node_db_set_immutable (priv->db, FALSE);

	if (data->node == NULL)

	{

		is_new_node = TRUE;

		data->node = ephy_node_new (priv->db);

		g_assert (data->node != NULL);

		/* don't allow dragging this node */

		ephy_node_set_is_drag_source (data->node, FALSE);

		g_value_init (&value, G_TYPE_STRING);

		g_value_take_string (&value,

				     get_id_for_response (data->type, 

							  data->domain,

							  data->name));

		ephy_node_set_property (data->node, EPHY_NODE_BMK_PROP_SERVICE_ID, &value);

		g_value_unset (&value);

		/* FIXME: limit length! */

		ephy_node_set_property_string (data->node,

					       EPHY_NODE_BMK_PROP_TITLE,

					       name);

		ephy_node_set_property_boolean (data->node,

						EPHY_NODE_BMK_PROP_IMMUTABLE,

						TRUE);

	}

	/* FIXME: limit length! */

	url = g_strdup_printf ("%s://%s:%d%s", zeroconf_protos[i], host, port, path);

	g_value_init (&value, G_TYPE_STRING);

	g_value_take_string (&value, url);

	ephy_node_set_property (data->node, EPHY_NODE_BMK_PROP_LOCATION, &value);

	g_value_unset (&value);

	if (is_new_node)

	{

		ephy_node_add_child (priv->bookmarks, data->node);

		ephy_node_add_child (priv->local, data->node);

	}

	ephy_node_db_set_immutable (priv->db, was_immutable);

	if (text_table != NULL)

	{

		g_hash_table_unref (text_table);

	}

}

static void

resolver_failure_cb (GaServiceResolver *resolver,

		     GError *error,

		     ResolveData *data)

{

	LOG ("resolver_failure_cb resolver %p: %s\n", resolver, error?error->message:"(null)");

	/* Remove the node, if present */

	if (data->node != NULL)

	{	

		EphyBookmarks *bookmarks = data->bookmarks;

		EphyBookmarksPrivate *priv = bookmarks->priv;

		gboolean was_immutable;

		was_immutable = ephy_node_db_is_immutable (priv->db);

		ephy_node_db_set_immutable (priv->db, FALSE);	

		ephy_node_unref (data->node);

		data->node = NULL;

		ephy_node_db_set_immutable (priv->db, was_immutable);

	}

}

static void

resolve_data_free (ResolveData* data)

{

	if (data->resolver)

		g_object_unref (data->resolver);

	g_free (data->type);

	g_free (data->name);

	g_free (data->domain);

	g_slice_free (ResolveData, data);

}

static void

browser_new_service_cb (GaServiceBrowser *browser,

			int interface,

			GaProtocol protocol,

			const char *name,

			const char *type,

			const char *domain,

			glong flags,

			EphyBookmarks *bookmarks)

{

	EphyBookmarksPrivate *priv = bookmarks->priv;

	ResolveData *data;

	char *node_id;

	GError *error = NULL;

	node_id = get_id_for_response (type, domain, name);

	LOG ("0conf ADD: type=%s domain=%s name=%s\n",

	     type, domain, name);

	if (g_hash_table_lookup (priv->resolve_handles, node_id) != NULL)

	{

		g_free (node_id);

		return;

	}

	data = g_slice_new0 (ResolveData);

	data->bookmarks = bookmarks;

	data->node = NULL;

	data->type = g_strdup (type);

	data->name = g_strdup (name);

	data->domain = g_strdup (domain);

	data->resolver = ga_service_resolver_new (AVAHI_IF_UNSPEC,

						  AVAHI_PROTO_UNSPEC,

						  name, type, domain,

						  AVAHI_PROTO_UNSPEC,

						  GA_LOOKUP_USE_MULTICAST);

	g_signal_connect (data->resolver, "found",

			  G_CALLBACK (resolver_found_cb), data);