Moved from Mate-Extra repository

1 files changed, 381 insertions, 0 deletions

diff --git a/baobab/src/baobab-scan.c b/baobab/src/baobab-scan.c
new file mode 100644
index 00000000..8c85d859
--- /dev/null
+++ b/baobab/src/baobab-scan.c
@@ -0,0 +1,381 @@
+/*
+ * baobab-scan.c
+ * This file is part of baobab
+ *
+ * Copyright (C) 2005-2006 Fabio Marzocca  <[email protected]>
+ *
+ * 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 St, Fifth Floor, 
+ * Boston, MA  02110-1301  USA
+ */
+
+
+#include <config.h>
+
+#include <string.h>
+
+#include <glib.h>
+#include <gtk/gtk.h>
+#include <gio/gio.h>
+
+#include "baobab.h"
+#include "baobab-utils.h"
+
+
+/*
+   Hardlinks handling.
+
+   As long as we're optimistic about hardlinks count
+   over the whole system (250 files with st_nlink > 1 here),
+   we keep linear search. If it turns out to be an bottleneck
+   we can switch to an hash table or tree.
+
+   TODO: get real timings about this code. find out the average
+   number of files with st_nlink > 1 on average computer.
+
+   To save memory, we store only { inode, dev } instead of full
+   GFileInfo.
+
+   EDIT: /me stupid. I realize that this code was not called that often
+   1 call per file with st_nlink > 1. BUT, i'm using pdumpfs to backup
+   my /etc. pdumpfs massively uses hard links. So there are more than
+   5000 files with st_nlink > 1. I believe this is the worst case.
+*/
+
+typedef struct {
+	guint64		    inode;
+	dev_t               device;
+} BaobabHardLink;
+
+typedef GArray BaobabHardLinkArray;
+
+static BaobabHardLinkArray *
+baobab_hardlinks_array_create (void)
+{
+	return g_array_new (FALSE, FALSE, sizeof(BaobabHardLink));
+}
+
+static gboolean
+baobab_hardlinks_array_has (BaobabHardLinkArray *a,
+			    BaobabHardLink      *s)
+{
+	guint i;
+
+	for (i = 0; i < a->len; ++i) {
+		BaobabHardLink *cur = &g_array_index (a, BaobabHardLink, i);
+
+		/*
+		 * cur->st_dev == s->st_dev is the common case and may be more
+		 * expansive than cur->st_ino == s->st_ino
+		 * so keep this order */
+		if (cur->inode == s->inode && cur->device == s->device)
+			return TRUE;
+	}
+
+	return FALSE;
+}
+
+/* return FALSE if the element was already in the array */
+static gboolean
+baobab_hardlinks_array_add (BaobabHardLinkArray *a,
+			    GFileInfo           *s)
+{
+
+	if (g_file_info_has_attribute (s, G_FILE_ATTRIBUTE_UNIX_INODE) &&
+	    g_file_info_has_attribute (s, G_FILE_ATTRIBUTE_UNIX_DEVICE))
+	{
+		BaobabHardLink hl;
+
+		hl.inode = g_file_info_get_attribute_uint64 (s,
+				G_FILE_ATTRIBUTE_UNIX_INODE);
+		hl.device = g_file_info_get_attribute_uint32 (s,
+				G_FILE_ATTRIBUTE_UNIX_DEVICE);
+
+		if (baobab_hardlinks_array_has (a, &hl))
+			return FALSE;
+
+		g_array_append_val (a, hl);
+
+		return TRUE;
+	}
+	else
+	{
+		g_warning ("Could not obtain inode and device for hardlink");
+	}
+
+	return FALSE;
+}
+
+static void
+baobab_hardlinks_array_free (BaobabHardLinkArray *a)
+{
+/*	g_print ("HL len was %d\n", a->len); */
+
+	g_array_free (a, TRUE);
+}
+
+#define BLOCK_SIZE 512
+
+struct allsizes {
+	goffset size;
+	goffset alloc_size;
+	gint depth;
+};
+
+static const char *dir_attributes = \
+	G_FILE_ATTRIBUTE_STANDARD_NAME "," \
+	G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME "," \
+	G_FILE_ATTRIBUTE_STANDARD_TYPE "," \
+	G_FILE_ATTRIBUTE_STANDARD_SIZE "," \
+	G_FILE_ATTRIBUTE_UNIX_BLOCKS "," \
+	G_FILE_ATTRIBUTE_UNIX_NLINK "," \
+	G_FILE_ATTRIBUTE_UNIX_INODE "," \
+	G_FILE_ATTRIBUTE_UNIX_DEVICE "," \
+	G_FILE_ATTRIBUTE_ACCESS_CAN_READ;
+
+
+static gboolean
+is_in_dot_gvfs (GFile *file)
+{
+	static GFile *dot_gvfs_dir = NULL;
+	GFile *parent;
+	gboolean res = FALSE;
+
+	if (dot_gvfs_dir == NULL)
+	{
+		gchar *dot_gvfs;
+
+		dot_gvfs = g_build_filename (g_get_home_dir (), ".gvfs", NULL);
+
+		dot_gvfs_dir = g_file_new_for_path (dot_gvfs);
+
+		g_free (dot_gvfs);
+	}
+
+	parent = g_file_get_parent (file);
+
+	if (parent != NULL)
+	{
+		res = g_file_equal (parent, dot_gvfs_dir);
+		g_object_unref (parent);
+	}
+
+	return res;
+}
+
+static struct allsizes
+loopdir (GFile *file,
+	 GFileInfo *info,
+	 guint count,
+	 BaobabHardLinkArray *hla,
+	 gint current_depth)
+{
+	guint64 tempHLsize = 0;
+	gint elements = 0;
+	struct chan_data data;
+	struct allsizes retloop, temp;
+	GFileInfo *temp_info;
+	GFileEnumerator *file_enum;
+	gchar *dir_uri = NULL;
+	gchar *display_name = NULL;
+	gchar *parse_name = NULL;
+	GError *err = NULL;
+
+	count++;
+	retloop.size = 0;
+	retloop.alloc_size = 0;
+	retloop.depth = 0;
+
+	/* Skip the user excluded folders */
+	if (baobab_is_excluded_location (file))
+		goto exit;
+
+	/* Skip the virtual file systems */
+	if (is_virtual_filesystem (file))
+ 		goto exit;
+
+	/* FIXME: skip dirs in ~/.gvfs. It would be better to have a way
+	 * to check if a file is a FUSE mountpoint instead of just
+	 * hardcoding .gvfs */
+	if (is_in_dot_gvfs (file))
+		goto exit;
+
+	parse_name = g_file_get_parse_name (file);	
+
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SIZE))
+		retloop.size = g_file_info_get_size (info);
+
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_UNIX_BLOCKS))
+		retloop.alloc_size = BLOCK_SIZE * 
+			g_file_info_get_attribute_uint64 (info,
+							  G_FILE_ATTRIBUTE_UNIX_BLOCKS);
+
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME))
+		display_name = g_strdup (g_file_info_get_display_name (info));
+	else
+		/* paranoid fallback */
+		display_name = g_filename_display_basename (g_file_info_get_name (info));
+
+	/* load up the file enumerator */
+	file_enum = g_file_enumerate_children (file,
+					       dir_attributes,
+					       G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
+					       NULL,
+					       &err);
+
+	if (file_enum == NULL) {
+		if (!g_error_matches (err, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED)) {
+			g_warning ("couldn't get dir enum for dir %s: %s\n",
+			   	parse_name, err->message);
+		}
+		goto exit;
+	}
+
+	/* All skipped folders (i.e. bad type, excluded, /proc) must be
+	   skept *before* this point. Everything passes the prefill-model
+	   will be part of the GUI. */
+
+	/* prefill the model */
+	data.size = 1;
+	data.alloc_size = 1;
+	data.depth = count - 1;
+	data.elements = -1;
+	data.display_name = display_name;
+	data.parse_name = parse_name;
+	data.tempHLsize = tempHLsize;
+	baobab_fill_model (&data);
+
+	g_clear_error (&err);
+	while ((temp_info = g_file_enumerator_next_file (file_enum,
+							 NULL,
+							 &err)) != NULL) {
+		GFileType temp_type = g_file_info_get_file_type (temp_info);
+		if (baobab.STOP_SCANNING) {
+			g_object_unref (temp_info);
+			g_object_unref (file_enum);
+			goto exit;
+		}
+
+		/* is a directory? */
+		if (temp_type == G_FILE_TYPE_DIRECTORY) {
+			GFile *child_dir = g_file_get_child (file, 
+						g_file_info_get_name (temp_info));
+			temp = loopdir (child_dir, temp_info, count, hla, current_depth+1);
+			retloop.size += temp.size;
+			retloop.alloc_size += temp.alloc_size;
+			retloop.depth = ((temp.depth + 1) > retloop.depth) ? temp.depth + 1 : retloop.depth;
+			elements++;
+			g_object_unref (child_dir);
+		}
+
+		/* is it a regular file? */
+		else if (temp_type == G_FILE_TYPE_REGULAR) {
+ 
+			/* check for hard links only on local files */
+			if (g_file_info_has_attribute (temp_info,
+						       G_FILE_ATTRIBUTE_UNIX_NLINK) &&
+				g_file_info_get_attribute_uint32 (temp_info,
+							    G_FILE_ATTRIBUTE_UNIX_NLINK) > 1) {
+ 
+				if (!baobab_hardlinks_array_add (hla, temp_info)) {
+
+					/* we already acconted for it */
+					tempHLsize += g_file_info_get_size (temp_info);
+					g_object_unref (temp_info);
+					continue;
+				}
+			}
+
+			if (g_file_info_has_attribute (temp_info, G_FILE_ATTRIBUTE_UNIX_BLOCKS)) {
+				retloop.alloc_size += BLOCK_SIZE *
+					g_file_info_get_attribute_uint64 (temp_info,
+							G_FILE_ATTRIBUTE_UNIX_BLOCKS);
+			}
+			retloop.size += g_file_info_get_size (temp_info);
+			elements++;
+		}
+
+		/* ignore other types (symlinks, sockets, devices, etc) */
+
+		g_object_unref (temp_info);
+	}
+
+	/* won't be an error if we've finished normally */
+	if (err != NULL) {
+		g_warning ("error in dir %s: %s\n", 
+			   parse_name, err->message);
+	}
+
+	data.display_name = display_name;
+	data.parse_name = parse_name;
+	data.size = retloop.size;
+	data.alloc_size = retloop.alloc_size;
+	data.depth = count - 1;
+	data.elements = elements;
+	data.tempHLsize = tempHLsize;
+	baobab_fill_model (&data);
+	g_object_unref (file_enum);
+
+ exit:
+	g_free (dir_uri);
+	g_free (display_name);
+	g_free (parse_name);
+	if (err)
+		g_error_free (err);
+
+	return retloop;
+}
+
+void
+baobab_scan_execute (GFile *location)
+{
+	BaobabHardLinkArray *hla;
+	GFileInfo *info;
+	GError *err = NULL;
+	GFileType ftype;
+	struct allsizes sizes;
+
+	g_return_if_fail (location != NULL);
+
+	/* NOTE: for the root of the scan we follow symlinks */
+	info = g_file_query_info (location,
+				  dir_attributes,
+				  G_FILE_QUERY_INFO_NONE,
+				  NULL,
+				  &err);
+
+	if (info == NULL) {
+		char *parse_name = g_file_get_parse_name (location);
+		g_warning ("couldn't get info for dir %s: %s\n",
+			   parse_name, err->message);
+		g_free (parse_name);
+		g_error_free (err);
+
+		return;
+	}
+
+	ftype = g_file_info_get_file_type (info);
+
+	if (ftype == G_FILE_TYPE_DIRECTORY) {
+		hla = baobab_hardlinks_array_create ();
+
+		sizes = loopdir (location, info, 0, hla, 0);
+		baobab.model_max_depth = sizes.depth;
+
+		baobab_hardlinks_array_free (hla);
+	}
+
+	g_object_unref (info);
+}
+