add a patch to build with >=ntfsprogs-2.0.0 with dragonheart's permission

(Portage version: 2.1.4.2)

3 files changed, 1331 insertions, 2 deletions

diff --git a/app-admin/testdisk/ChangeLog b/app-admin/testdisk/ChangeLog
index 8f55cb0f3d2c..94496e58b82c 100644
--- a/app-admin/testdisk/ChangeLog
+++ b/app-admin/testdisk/ChangeLog
@@ -1,6 +1,12 @@
 # ChangeLog for app-admin/testdisk
-# Copyright 2000-2007 Gentoo Foundation; Distributed under the GPL v2
-# $Header: /var/cvsroot/gentoo-x86/app-admin/testdisk/ChangeLog,v 1.26 2007/08/14 11:50:09 dragonheart Exp $
+# Copyright 2000-2008 Gentoo Foundation; Distributed under the GPL v2
+# $Header: /var/cvsroot/gentoo-x86/app-admin/testdisk/ChangeLog,v 1.27 2008/02/10 14:06:19 maekke Exp $
+
+*testdisk-6.8-r1 (10 Feb 2008)
+
+  10 Feb 2008; Markus Meier <maekke@gentoo.org>
+  +files/testdisk-6.8-ntfsprogs2.patch, +testdisk-6.8-r1.ebuild:
+  add a patch to build with >=ntfsprogs-2.0.0 with dragonheart's permission
 
 *testdisk-6.8 (14 Aug 2007)
 
diff --git a/app-admin/testdisk/files/testdisk-6.8-ntfsprogs2.patch b/app-admin/testdisk/files/testdisk-6.8-ntfsprogs2.patch
new file mode 100644
index 000000000000..070539437b71
--- /dev/null
+++ b/app-admin/testdisk/files/testdisk-6.8-ntfsprogs2.patch
@@ -0,0 +1,1262 @@
+diff -ruw testdisk-6.8.org/src/dir.h testdisk-6.8/src/dir.h
+--- testdisk-6.8.org/src/dir.h	2007-05-11 11:16:17.000000000 +0200
++++ testdisk-6.8/src/dir.h	2007-12-02 22:41:59.000000000 +0100
+@@ -51,7 +51,7 @@
+ };
+ 
+ struct file_info {
+-  struct list_head list;
++  struct td_list_head list;
+   char name[4096];
+   struct stat stat;
+ };
+diff -ruw testdisk-6.8.org/src/filegen.h testdisk-6.8/src/filegen.h
+--- testdisk-6.8.org/src/filegen.h	2007-06-03 23:52:41.000000000 +0200
++++ testdisk-6.8/src/filegen.h	2007-12-02 22:41:59.000000000 +0100
+@@ -88,7 +88,7 @@
+ 
+ struct alloc_data_struct
+ {
+-  struct list_head list;
++  struct td_list_head list;
+   uint64_t start;
+   uint64_t end;
+   file_stat_t *file_stat;
+diff -ruw testdisk-6.8.org/src/intrface.c testdisk-6.8/src/intrface.c
+--- testdisk-6.8.org/src/intrface.c	2007-07-18 19:10:10.000000000 +0200
++++ testdisk-6.8/src/intrface.c	2007-12-02 22:41:59.000000000 +0100
+@@ -1080,15 +1080,15 @@
+ 
+ static list_part_t *interface_load(disk_t *disk_car,list_part_t *list_part, const int debug)
+ {
+-  struct list_head *backup_walker=NULL;
++  struct td_list_head *backup_walker=NULL;
+   backup_disk_t *backup_list=partition_load(disk_car,debug);
+   {
+     log_info("interface_load\n");
+-    list_for_each(backup_walker,&backup_list->list)
++    td_list_for_each(backup_walker,&backup_list->list)
+     {
+       list_part_t *element;
+       backup_disk_t *backup;
+-      backup=list_entry(backup_walker, backup_disk_t, list);
++      backup=td_list_entry(backup_walker, backup_disk_t, list);
+       log_info("%s %s",backup->description,ctime(&backup->my_time));
+       for(element=backup->list_part;element!=NULL;element=element->next)
+ 	log_partition(disk_car,element->part);
+@@ -1100,7 +1100,7 @@
+     int backup_current_num=0;
+     int rewrite=1;
+     unsigned int menu=3;   /* default : quit */
+-    struct list_head *backup_current=backup_list->list.next;
++    struct td_list_head *backup_current=backup_list->list.next;
+     struct MenuItem menuLoadBackup[]=
+     {
+       { 'P', "Previous",""},
+@@ -1134,7 +1134,7 @@
+ 	for(i=0,backup_walker=backup_list->list.next;(backup_walker!=&backup_list->list) && (i<offset);backup_walker=backup_walker->next,i++);
+ 	for(i=offset;(backup_walker!=&backup_list->list) &&((i-offset)<INTER_STRUCTURE);i++,backup_walker=backup_walker->next)
+ 	{
+-	  backup=list_entry(backup_walker, backup_disk_t, list);
++	  backup=td_list_entry(backup_walker, backup_disk_t, list);
+ 	  wmove(stdscr,8+i-offset,0);
+ 	  wclrtoeol(stdscr);	/* before addstr for BSD compatibility */
+ 	  if(backup_walker==backup_current)
+@@ -1222,7 +1222,7 @@
+     {
+       list_part_t *partition;
+       backup_disk_t *backup;
+-      backup=list_entry(backup_current, backup_disk_t, list);
++      backup=td_list_entry(backup_current, backup_disk_t, list);
+       for(partition=backup->list_part;partition!=NULL;partition=partition->next)
+       {
+ 	/* Check partition and load partition name */
+@@ -1232,11 +1232,11 @@
+     }
+   }
+   { /* Cleanup */
+-    struct list_head *backup_walker_next = NULL;
+-    list_for_each_safe(backup_walker,backup_walker_next,&backup_list->list)
++    struct td_list_head *backup_walker_next = NULL;
++    td_list_for_each_safe(backup_walker,backup_walker_next,&backup_list->list)
+     {
+       backup_disk_t *backup;
+-      backup=list_entry(backup_walker, backup_disk_t, list);
++      backup=td_list_entry(backup_walker, backup_disk_t, list);
+       delete_list_part(backup->list_part);
+       free(backup);
+     }
+diff -ruw testdisk-6.8.org/src/intrf.c testdisk-6.8/src/intrf.c
+--- testdisk-6.8.org/src/intrf.c	2007-07-19 23:44:00.000000000 +0200
++++ testdisk-6.8/src/intrf.c	2007-12-02 22:41:59.000000000 +0100
+@@ -1548,11 +1548,11 @@
+   do
+   {
+     DIR* dir;
+-    struct list_head *dir_current;
++    struct td_list_head *dir_current;
+     int offset=0;
+     int pos_num=0;
+     static struct file_info dir_list = {
+-      .list = LIST_HEAD_INIT(dir_list.list),
++      .list = TD_LIST_HEAD_INIT(dir_list.list),
+       .name = {0}
+     };
+     wmove(window,7,0);
+@@ -1576,7 +1576,7 @@
+ 	new_drive->name[2]=PATH_SEP;
+ 	new_drive->name[3]='\0';
+ 	new_drive->stat.st_mode=LINUX_S_IFDIR|LINUX_S_IRWXUGO;
+-	list_add_tail(&new_drive->list,&dir_list.list);
++	td_list_add_tail(&new_drive->list,&dir_list.list);
+       }
+       dir=NULL;
+     }
+@@ -1633,7 +1633,7 @@
+ 	      }
+ #endif
+ 	      strncpy(dir_info->name,dir_entrie->d_name,sizeof(dir_info->name));
+-	      list_add_tail(&dir_info->list,&dir_list.list);
++	      td_list_add_tail(&dir_info->list,&dir_list.list);
+ 	      dir_info=(struct file_info*)MALLOC(sizeof(*dir_info));
+ 	    }
+ 	  }
+@@ -1665,14 +1665,14 @@
+ 	wdoprintf(window,"To select another directory, use the arrow keys.");
+ #endif
+ 	{
+-	  struct list_head *dir_walker = NULL;
++	  struct td_list_head *dir_walker = NULL;
+ 	  int i=0;
+-	  list_for_each(dir_walker,&dir_list.list)
++	  td_list_for_each(dir_walker,&dir_list.list)
+ 	  {
+ 	    if(offset<=i)
+ 	    {
+ 	      struct file_info *dir_info;
+-	      dir_info=list_entry(dir_walker, struct file_info, list);
++	      dir_info=td_list_entry(dir_walker, struct file_info, list);
+ 	      wmove(window,8+i-offset,0);
+ 	      wclrtoeol(window);	/* before addstr for BSD compatibility */
+ 	      if(dir_walker==dir_current)
+@@ -1792,7 +1792,7 @@
+ 	      if(dir_current!=&dir_list.list)
+ 	      {
+ 		struct file_info *dir_info;
+-		dir_info=list_entry(dir_current, struct file_info, list);
++		dir_info=td_list_entry(dir_current, struct file_info, list);
+ 		if(strcmp(dir_info->name,".")==0)
+ 		{
+ 		}
+@@ -1819,13 +1819,13 @@
+ 	} while(quit==0);
+       } while(quit==1);
+       {
+-	struct list_head *dir_walker = NULL;
+-	struct list_head *dir_walker_next = NULL;
+-	list_for_each_safe(dir_walker,dir_walker_next,&dir_list.list)
++	struct td_list_head *dir_walker = NULL;
++	struct td_list_head *dir_walker_next = NULL;
++	td_list_for_each_safe(dir_walker,dir_walker_next,&dir_list.list)
+ 	{
+ 	  struct file_info *dir_info;
+-	  dir_info=list_entry(dir_walker, struct file_info, list);
+-	  list_del(dir_walker);
++	  dir_info=td_list_entry(dir_walker, struct file_info, list);
++	  td_list_del(dir_walker);
+ 	  free(dir_info);
+ 	}
+       }
+diff -ruw testdisk-6.8.org/src/list.c testdisk-6.8/src/list.c
+--- testdisk-6.8.org/src/list.c	2007-07-06 18:48:25.000000000 +0200
++++ testdisk-6.8/src/list.c	2007-12-02 22:41:59.000000000 +0100
+@@ -87,14 +87,14 @@
+       if(file_size>=size)
+       {
+ 	element->end-=(file_size-size);
+-	list_delete(element->next);
+-//	element->next=NULL;	already done by list_delete
++	td_list_delete(element->next);
++//	element->next=NULL;	already done by td_list_delete
+       }
+     }
+   }
+ }
+ 
+-void list_delete(alloc_list_t *list)
++void td_list_delete(alloc_list_t *list)
+ {
+   alloc_list_t *next;
+   if(list!=NULL && list->prev!=NULL)
+diff -ruw testdisk-6.8.org/src/list.h testdisk-6.8/src/list.h
+--- testdisk-6.8.org/src/list.h	2007-06-05 23:01:06.000000000 +0200
++++ testdisk-6.8/src/list.h	2007-12-02 22:41:59.000000000 +0100
+@@ -34,7 +34,7 @@
+ 
+ void list_append_block(alloc_list_t *list, const uint64_t offset, const uint64_t blocksize, const int data);
+ void list_truncate(alloc_list_t *list, uint64_t size);
+-void list_delete(alloc_list_t *list);
++void td_list_delete(alloc_list_t *list);
+ 
+ 
+ /*
+@@ -56,16 +56,16 @@
+  * using the generic single-entry routines.
+  */
+ 
+-struct list_head {
+-	struct list_head *next, *prev;
++struct td_list_head {
++	struct td_list_head *next, *prev;
+ };
+ 
+-#define LIST_HEAD_INIT(name) { &(name), &(name) }
++#define TD_LIST_HEAD_INIT(name) { &(name), &(name) }
+ 
+-#define LIST_HEAD(name) \
+-	struct list_head name = LIST_HEAD_INIT(name)
++#define TD_LIST_HEAD(name) \
++	struct td_list_head name = TD_LIST_HEAD_INIT(name)
+ 
+-#define INIT_LIST_HEAD(ptr) do { \
++#define INIT_TD_LIST_HEAD(ptr) do { \
+ 	(ptr)->next = (ptr); (ptr)->prev = (ptr); \
+ } while (0)
+ 
+@@ -75,9 +75,9 @@
+  * This is only for internal list manipulation where we know
+  * the prev/next entries already!
+  */
+-static inline void __list_add(struct list_head *new,
+-			      struct list_head *prev,
+-			      struct list_head *next)
++static inline void __td_list_add(struct td_list_head *new,
++			      struct td_list_head *prev,
++			      struct td_list_head *next)
+ {
+ 	next->prev = new;
+ 	new->next = next;
+@@ -86,29 +86,29 @@
+ }
+ 
+ /**
+- * list_add - add a new entry
++ * td_list_add - add a new entry
+  * @new: new entry to be added
+  * @head: list head to add it after
+  *
+  * Insert a new entry after the specified head.
+  * This is good for implementing stacks.
+  */
+-static inline void list_add(struct list_head *new, struct list_head *head)
++static inline void td_list_add(struct td_list_head *new, struct td_list_head *head)
+ {
+-	__list_add(new, head, head->next);
++	__td_list_add(new, head, head->next);
+ }
+ 
+ /**
+- * list_add_tail - add a new entry
++ * td_list_add_tail - add a new entry
+  * @new: new entry to be added
+  * @head: list head to add it before
+  *
+  * Insert a new entry before the specified head.
+  * This is useful for implementing queues.
+  */
+-static inline void list_add_tail(struct list_head *new, struct list_head *head)
++static inline void td_list_add_tail(struct td_list_head *new, struct td_list_head *head)
+ {
+-	__list_add(new, head->prev, head);
++	__td_list_add(new, head->prev, head);
+ }
+ 
+ /*
+@@ -118,91 +118,91 @@
+  * This is only for internal list manipulation where we know
+  * the prev/next entries already!
+  */
+-static inline void __list_del(struct list_head * prev, struct list_head * next)
++static inline void __td_list_del(struct td_list_head * prev, struct td_list_head * next)
+ {
+ 	next->prev = prev;
+ 	prev->next = next;
+ }
+ 
+ /**
+- * list_del - deletes entry from list.
++ * td_list_del - deletes entry from list.
+  * @entry: the element to delete from the list.
+- * Note: list_empty on entry does not return true after this, the entry is
++ * Note: td_list_empty on entry does not return true after this, the entry is
+  * in an undefined state.
+  */
+-static inline void list_del(struct list_head *entry)
++static inline void td_list_del(struct td_list_head *entry)
+ {
+-	__list_del(entry->prev, entry->next);
++	__td_list_del(entry->prev, entry->next);
+ 	entry->next = LIST_POISON1;
+ 	entry->prev = LIST_POISON2;
+ }
+ 
+ /**
+- * list_del_init - deletes entry from list and reinitialize it.
++ * td_list_del_init - deletes entry from list and reinitialize it.
+  * @entry: the element to delete from the list.
+  */
+-static inline void list_del_init(struct list_head *entry)
++static inline void td_list_del_init(struct td_list_head *entry)
+ {
+-	__list_del(entry->prev, entry->next);
+-	INIT_LIST_HEAD(entry);
++	__td_list_del(entry->prev, entry->next);
++	INIT_TD_LIST_HEAD(entry);
+ }
+ 
+ /**
+- * list_move - delete from one list and add as another's head
++ * td_list_move - delete from one list and add as another's head
+  * @list: the entry to move
+  * @head: the head that will precede our entry
+  */
+-static inline void list_move(struct list_head *list, struct list_head *head)
++static inline void td_list_move(struct td_list_head *list, struct td_list_head *head)
+ {
+-        __list_del(list->prev, list->next);
+-        list_add(list, head);
++        __td_list_del(list->prev, list->next);
++        td_list_add(list, head);
+ }
+ 
+ /**
+- * list_move_tail - delete from one list and add as another's tail
++ * td_list_move_tail - delete from one list and add as another's tail
+  * @list: the entry to move
+  * @head: the head that will follow our entry
+  */
+-static inline void list_move_tail(struct list_head *list,
+-				  struct list_head *head)
++static inline void td_list_move_tail(struct td_list_head *list,
++				  struct td_list_head *head)
+ {
+-        __list_del(list->prev, list->next);
+-        list_add_tail(list, head);
++        __td_list_del(list->prev, list->next);
++        td_list_add_tail(list, head);
+ }
+ 
+ /**
+- * list_empty - tests whether a list is empty
++ * td_list_empty - tests whether a list is empty
+  * @head: the list to test.
+  */
+-static inline int list_empty(const struct list_head *head)
++static inline int td_list_empty(const struct td_list_head *head)
+ {
+ 	return head->next == head;
+ }
+ 
+ /**
+- * list_empty_careful - tests whether a list is
++ * td_list_empty_careful - tests whether a list is
+  * empty _and_ checks that no other CPU might be
+  * in the process of still modifying either member
+  *
+- * NOTE: using list_empty_careful() without synchronization
++ * NOTE: using td_list_empty_careful() without synchronization
+  * can only be safe if the only activity that can happen
+- * to the list entry is list_del_init(). Eg. it cannot be used
+- * if another CPU could re-list_add() it.
++ * to the list entry is td_list_del_init(). Eg. it cannot be used
++ * if another CPU could re-td_list_add() it.
+  *
+  * @head: the list to test.
+  */
+-static inline int list_empty_careful(const struct list_head *head)
++static inline int td_list_empty_careful(const struct td_list_head *head)
+ {
+-	struct list_head *next = head->next;
++	struct td_list_head *next = head->next;
+ 	return (next == head) && (next == head->prev);
+ }
+ 
+-static inline void __list_splice(struct list_head *list,
+-				 struct list_head *head)
++static inline void __td_list_splice(struct td_list_head *list,
++				 struct td_list_head *head)
+ {
+-	struct list_head *first = list->next;
+-	struct list_head *last = list->prev;
+-	struct list_head *at = head->next;
++	struct td_list_head *first = list->next;
++	struct td_list_head *last = list->prev;
++	struct td_list_head *at = head->next;
+ 
+ 	first->prev = head;
+ 	head->next = first;
+@@ -212,125 +212,125 @@
+ }
+ 
+ /**
+- * list_splice - join two lists
++ * td_list_splice - join two lists
+  * @list: the new list to add.
+  * @head: the place to add it in the first list.
+  */
+-static inline void list_splice(struct list_head *list, struct list_head *head)
++static inline void td_list_splice(struct td_list_head *list, struct td_list_head *head)
+ {
+-	if (!list_empty(list))
+-		__list_splice(list, head);
++	if (!td_list_empty(list))
++		__td_list_splice(list, head);
+ }
+ 
+ /**
+- * list_splice_init - join two lists and reinitialise the emptied list.
++ * td_list_splice_init - join two lists and reinitialise the emptied list.
+  * @list: the new list to add.
+  * @head: the place to add it in the first list.
+  *
+  * The list at @list is reinitialised
+  */
+-static inline void list_splice_init(struct list_head *list,
+-				    struct list_head *head)
++static inline void td_list_splice_init(struct td_list_head *list,
++				    struct td_list_head *head)
+ {
+-	if (!list_empty(list)) {
+-		__list_splice(list, head);
+-		INIT_LIST_HEAD(list);
++	if (!td_list_empty(list)) {
++		__td_list_splice(list, head);
++		INIT_TD_LIST_HEAD(list);
+ 	}
+ }
+ 
+ /**
+- * list_entry - get the struct for this entry
+- * @ptr:	the &struct list_head pointer.
++ * td_list_entry - get the struct for this entry
++ * @ptr:	the &struct td_list_head pointer.
+  * @type:	the type of the struct this is embedded in.
+  * @member:	the name of the list_struct within the struct.
+  */
+-#define list_entry(ptr, type, member) \
++#define td_list_entry(ptr, type, member) \
+ 	((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
+ 
+ /**
+- * __list_for_each	-	iterate over a list
+- * @pos:	the &struct list_head to use as a loop counter.
++ * __td_list_for_each	-	iterate over a list
++ * @pos:	the &struct td_list_head to use as a loop counter.
+  * @head:	the head for your list.
+  *
+  */
+-#define list_for_each(pos, head) \
++#define td_list_for_each(pos, head) \
+ 	for (pos = (head)->next; pos != (head); pos = pos->next)
+ 
+ /**
+- * list_for_each_prev	-	iterate over a list backwards
+- * @pos:	the &struct list_head to use as a loop counter.
++ * td_list_for_each_prev	-	iterate over a list backwards
++ * @pos:	the &struct td_list_head to use as a loop counter.
+  * @head:	the head for your list.
+  */
+-#define list_for_each_prev(pos, head) \
++#define td_list_for_each_prev(pos, head) \
+ 	for (pos = (head)->prev; pos != (head); \
+         	pos = pos->prev)
+ 
+ /**
+- * list_for_each_safe	-	iterate over a list safe against removal of list entry
+- * @pos:	the &struct list_head to use as a loop counter.
+- * @n:		another &struct list_head to use as temporary storage
++ * td_list_for_each_safe	-	iterate over a list safe against removal of list entry
++ * @pos:	the &struct td_list_head to use as a loop counter.
++ * @n:		another &struct td_list_head to use as temporary storage
+  * @head:	the head for your list.
+  */
+-#define list_for_each_safe(pos, n, head) \
++#define td_list_for_each_safe(pos, n, head) \
+ 	for (pos = (head)->next, n = pos->next; pos != (head); \
+ 		pos = n, n = pos->next)
+ 
+ /**
+- * list_for_each_entry	-	iterate over list of given type
++ * td_list_for_each_entry	-	iterate over list of given type
+  * @pos:	the type * to use as a loop counter.
+  * @head:	the head for your list.
+  * @member:	the name of the list_struct within the struct.
+  */
+-#define list_for_each_entry(pos, head, member)				\
+-	for (pos = list_entry((head)->next, typeof(*pos), member);	\
++#define td_list_for_each_entry(pos, head, member)				\
++	for (pos = td_list_entry((head)->next, typeof(*pos), member);	\
+ 	     &pos->member != (head); 	\
+-	     pos = list_entry(pos->member.next, typeof(*pos), member))
++	     pos = td_list_entry(pos->member.next, typeof(*pos), member))
+ 
+ /**
+- * list_for_each_entry_reverse - iterate backwards over list of given type.
++ * td_list_for_each_entry_reverse - iterate backwards over list of given type.
+  * @pos:	the type * to use as a loop counter.
+  * @head:	the head for your list.
+  * @member:	the name of the list_struct within the struct.
+  */
+-#define list_for_each_entry_reverse(pos, head, member)			\
+-	for (pos = list_entry((head)->prev, typeof(*pos), member);	\
++#define td_list_for_each_entry_reverse(pos, head, member)			\
++	for (pos = td_list_entry((head)->prev, typeof(*pos), member);	\
+ 	     &pos->member != (head); 	\
+-	     pos = list_entry(pos->member.prev, typeof(*pos), member))
++	     pos = td_list_entry(pos->member.prev, typeof(*pos), member))
+ 
+ /**
+- * list_prepare_entry - prepare a pos entry for use as a start point in
+- *			list_for_each_entry_continue
++ * td_list_prepare_entry - prepare a pos entry for use as a start point in
++ *			td_list_for_each_entry_continue
+  * @pos:	the type * to use as a start point
+  * @head:	the head of the list
+  * @member:	the name of the list_struct within the struct.
+  */
+-#define list_prepare_entry(pos, head, member) \
+-	((pos) ? : list_entry(head, typeof(*pos), member))
++#define td_list_prepare_entry(pos, head, member) \
++	((pos) ? : td_list_entry(head, typeof(*pos), member))
+ 
+ /**
+- * list_for_each_entry_continue -	iterate over list of given type
++ * td_list_for_each_entry_continue -	iterate over list of given type
+  *			continuing after existing point
+  * @pos:	the type * to use as a loop counter.
+  * @head:	the head for your list.
+  * @member:	the name of the list_struct within the struct.
+  */
+-#define list_for_each_entry_continue(pos, head, member) 		\
+-	for (pos = list_entry(pos->member.next, typeof(*pos), member);	\
++#define td_list_for_each_entry_continue(pos, head, member) 		\
++	for (pos = td_list_entry(pos->member.next, typeof(*pos), member);	\
+ 	     &pos->member != (head);	\
+-	     pos = list_entry(pos->member.next, typeof(*pos), member))
++	     pos = td_list_entry(pos->member.next, typeof(*pos), member))
+ 
+ /**
+- * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
++ * td_list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+  * @pos:	the type * to use as a loop counter.
+  * @n:		another type * to use as temporary storage
+  * @head:	the head for your list.
+  * @member:	the name of the list_struct within the struct.
+  */
+-#define list_for_each_entry_safe(pos, n, head, member)			\
+-	for (pos = list_entry((head)->next, typeof(*pos), member),	\
+-		n = list_entry(pos->member.next, typeof(*pos), member);	\
++#define td_list_for_each_entry_safe(pos, n, head, member)			\
++	for (pos = td_list_entry((head)->next, typeof(*pos), member),	\
++		n = td_list_entry(pos->member.next, typeof(*pos), member);	\
+ 	     &pos->member != (head); 					\
+-	     pos = n, n = list_entry(n->member.next, typeof(*n), member))
++	     pos = n, n = td_list_entry(n->member.next, typeof(*n), member))
+ 
+ 
+ #endif
+diff -ruw testdisk-6.8.org/src/ntfs.c testdisk-6.8/src/ntfs.c
+--- testdisk-6.8.org/src/ntfs.c	2007-07-19 23:44:05.000000000 +0200
++++ testdisk-6.8/src/ntfs.c	2007-12-02 22:41:59.000000000 +0100
+@@ -233,7 +233,7 @@
+     {
+       unsigned int attr_value_length=NTFS_GETU16(attr_record+0x10);
+       unsigned int attr_value_offset=NTFS_GETU16(attr_record+0x14);
+-      const char *attr_list_entry=attr_record+attr_value_offset;
++      const char *attr_td_list_entry=attr_record+attr_value_offset;
+       if(attr_value_offset%8!=0)
+       {
+ #ifdef NTFS_DEBUG
+@@ -241,15 +241,15 @@
+ #endif
+ 	return 2;
+       }
+-      if(attr_list_entry+26>=end)
++      if(attr_td_list_entry+26>=end)
+       {
+ #ifdef NTFS_DEBUG
+-	log_debug("ntfs_get_attr attr_list_entry+26=%p, end=%p\n",attr_list_entry+26,end);
++	log_debug("ntfs_get_attr attr_td_list_entry+26=%p, end=%p\n",attr_td_list_entry+26,end);
+ #endif
+ 	return 2;
+       }
+       /* We found the attribute type. Is the name correct, too? */
+-      if((attr_value_offset+attr_value_length>attr_len) || (attr_list_entry+attr_len >= end))
++      if((attr_value_offset+attr_value_length>attr_len) || (attr_td_list_entry+attr_len >= end))
+       {
+ #ifdef NTFS_DEBUG
+ 	// log_debug("ntfs_get_attr \n");
+@@ -262,7 +262,7 @@
+ 	{
+ 	  case 0x30:	/* AT_FILE_NAME */
+ 	    {
+-	      const char *file_name_attr=attr_list_entry;
++	      const char *file_name_attr=attr_td_list_entry;
+ 	      unsigned int file_name_length;
+ 	      const char *name_it;
+ 	      if(file_name_attr+0x42>=end)
+@@ -303,13 +303,13 @@
+ 	      volume_name_length/=2;	/* Unicode */
+ 	      if(volume_name_length>sizeof(partition->name)-1)
+ 		volume_name_length=sizeof(partition->name)-1;
+-	      for(name_it=attr_list_entry;(volume_name_length>0) && (*name_it!='\0') && (name_it[1]=='\0'); name_it+=2,volume_name_length--)
++	      for(name_it=attr_td_list_entry;(volume_name_length>0) && (*name_it!='\0') && (name_it[1]=='\0'); name_it+=2,volume_name_length--)
+ 		*dest++=*name_it;
+ 	      *dest++='\0'; /* 27 january 2003: Correct a bug found by Andreas du Plessis-Denz */
+ 	    }
+ 	    return 1;
+ 	  case 0x90:	/* AT_INDEX_ROOT */
+-	    return NTFS_GETU32(attr_list_entry+8);	/* index_block_size */
++	    return NTFS_GETU32(attr_td_list_entry+8);	/* index_block_size */
+ 	}
+       }
+     }
+diff -ruw testdisk-6.8.org/src/ntfs_dir.c testdisk-6.8/src/ntfs_dir.c
+--- testdisk-6.8.org/src/ntfs_dir.c	2007-07-10 13:46:07.000000000 +0200
++++ testdisk-6.8/src/ntfs_dir.c	2007-12-02 22:41:59.000000000 +0100
+@@ -93,7 +93,7 @@
+ extern u64 ntfs_inode_lookup_by_name(ntfs_inode *dir_ni,
+                 const ntfschar *uname, const int uname_len);
+ static time_t ntfs2utc (s64 ntfstime);
+-static int ntfs_list_entry(  struct ntfs_dir_struct *ls, const ntfschar *name, 
++static int ntfs_td_list_entry(  struct ntfs_dir_struct *ls, const ntfschar *name, 
+ 		const int name_len, const int name_type, const s64 pos,
+ 		const MFT_REF mref, const unsigned dt_type);
+ static file_data_t *ntfs_dir(disk_t *disk_car, const partition_t *partition, dir_data_t *dir_data, const unsigned long int cluster);
+@@ -138,10 +138,10 @@
+ }
+ 
+ /**
+- * ntfs_list_entry
++ * ntfs_td_list_entry
+  * FIXME: Should we print errors as we go along? (AIA)
+  */
+-static int ntfs_list_entry(  struct ntfs_dir_struct *ls, const ntfschar *name, 
++static int ntfs_td_list_entry(  struct ntfs_dir_struct *ls, const ntfschar *name, 
+ 		const int name_len, const int name_type, const s64 pos,
+ 		const MFT_REF mref, const unsigned dt_type)
+ {
+@@ -150,7 +150,7 @@
+   filename = calloc (1, MAX_PATH);
+   if (!filename)
+   {
+-    log_critical("ntfs_list_entry calloc failed\n");
++    log_critical("ntfs_td_list_entry calloc failed\n");
+     return -1;
+   }
+ 
+@@ -292,7 +292,7 @@
+    */
+   pos = 0;
+   if (inode->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
+-    if(ntfs_readdir(inode, &pos, ls, (ntfs_filldir_t)ntfs_list_entry)<0)
++    if(ntfs_readdir(inode, &pos, ls, (ntfs_filldir_t)ntfs_td_list_entry)<0)
+     {
+       log_error("ntfs_readdir failed\n");
+     }
+diff -ruw testdisk-6.8.org/src/photorec.c testdisk-6.8/src/photorec.c
+--- testdisk-6.8.org/src/photorec.c	2007-07-20 20:44:13.000000000 +0200
++++ testdisk-6.8/src/photorec.c	2007-12-02 22:41:59.000000000 +0100
+@@ -223,14 +223,14 @@
+ 
+ static void list_free_add(const file_recovery_t *file_recovery, alloc_data_t *list_search_space)
+ {
+-  struct list_head *search_walker = NULL;
++  struct td_list_head *search_walker = NULL;
+ #ifdef DEBUG_FREE
+   log_trace("list_free_add %lu\n",(long unsigned)(file_recovery->location.start/512));
+ #endif
+-  list_for_each(search_walker, &list_search_space->list)
++  td_list_for_each(search_walker, &list_search_space->list)
+   {
+     alloc_data_t *current_search_space;
+-    current_search_space=list_entry(search_walker, alloc_data_t, list);
++    current_search_space=td_list_entry(search_walker, alloc_data_t, list);
+     if(current_search_space->start < file_recovery->location.start && file_recovery->location.start < current_search_space->end)
+     {
+       alloc_data_t *new_free_space;
+@@ -239,7 +239,7 @@
+       new_free_space->end=current_search_space->end;
+       new_free_space->file_stat=NULL;
+       current_search_space->end=file_recovery->location.start-1;
+-      list_add(&new_free_space->list, search_walker);
++      td_list_add(&new_free_space->list, search_walker);
+     }
+     if(current_search_space->start==file_recovery->location.start)
+     {
+@@ -252,22 +252,22 @@
+ static alloc_data_t *update_search_space(const file_recovery_t *file_recovery, alloc_data_t *list_search_space, alloc_data_t **new_current_search_space, uint64_t *offset, const unsigned int blocksize)
+ {
+   const alloc_list_t *element;
+-  struct list_head *search_walker = NULL;
++  struct td_list_head *search_walker = NULL;
+ #ifdef DEBUG_UPDATE_SEARCH_SPACE
+   log_trace("update_search_space\n");
+-  list_for_each(search_walker, &list_search_space->list)
++  td_list_for_each(search_walker, &list_search_space->list)
+   {
+     alloc_data_t *cur_free_space;
+-    cur_free_space=list_entry(search_walker, alloc_data_t, list);
++    cur_free_space=td_list_entry(search_walker, alloc_data_t, list);
+     log_trace(" %llu-%llu",(long long unsigned)(cur_free_space->start/512),
+ 	(long long unsigned)(cur_free_space->end/512));
+   }
+   log_trace("\n");
+ #endif
+-  list_for_each(search_walker, &list_search_space->list)
++  td_list_for_each(search_walker, &list_search_space->list)
+   {
+     alloc_data_t *current_search_space;
+-    current_search_space=list_entry(search_walker, alloc_data_t, list);
++    current_search_space=td_list_entry(search_walker, alloc_data_t, list);
+     if(current_search_space->start <= file_recovery->location.start &&
+ 	file_recovery->location.start <= current_search_space->end)
+     {
+@@ -291,7 +291,7 @@
+ 
+ static alloc_data_t *update_search_space_aux(alloc_data_t *list_search_space, uint64_t start, uint64_t end, alloc_data_t **new_current_search_space, uint64_t *offset)
+ {
+-  struct list_head *search_walker = NULL;
++  struct td_list_head *search_walker = NULL;
+ #ifdef DEBUG_UPDATE_SEARCH_SPACE
+     log_trace("update_search_space_aux offset=%llu remove [%llu-%llu]\n",
+ 	(long long unsigned)((*offset)/512),
+@@ -300,10 +300,10 @@
+ #endif
+   if(start >= end)
+     return list_search_space;
+-  list_for_each(search_walker, &list_search_space->list)
++  td_list_for_each(search_walker, &list_search_space->list)
+   {
+     alloc_data_t *current_search_space;
+-    current_search_space=list_entry(search_walker, alloc_data_t, list);
++    current_search_space=td_list_entry(search_walker, alloc_data_t, list);
+ #ifdef DEBUG_UPDATE_SEARCH_SPACE
+     log_trace("update_search_space_aux offset=%llu remove [%llu-%llu] in [%llu-%llu]\n",
+ 	(long long unsigned)((*offset)/512),
+@@ -328,14 +328,14 @@
+       /* current_search_space->start==start current_search_space->end<=end */
+       start=current_search_space->end+1;
+       if(list_search_space==current_search_space)
+-	list_search_space=list_entry(current_search_space->list.next, alloc_data_t, list);
++	list_search_space=td_list_entry(current_search_space->list.next, alloc_data_t, list);
+       if(offset!=NULL && new_current_search_space!=NULL &&
+ 	  current_search_space->start<=*offset && *offset<=current_search_space->end)
+       {
+-	*new_current_search_space=list_entry(current_search_space->list.next, alloc_data_t, list);
++	*new_current_search_space=td_list_entry(current_search_space->list.next, alloc_data_t, list);
+ 	*offset=(*new_current_search_space)->start;
+       }
+-      list_del(search_walker);
++      td_list_del(search_walker);
+       free(current_search_space);
+       return update_search_space_aux(list_search_space, start,end, new_current_search_space, offset);
+     }
+@@ -349,7 +349,7 @@
+ 	if(offset!=NULL && new_current_search_space!=NULL &&
+ 	  start<=*offset && *offset<=current_search_space->end)
+ 	{
+-	  *new_current_search_space=list_entry(current_search_space->list.next, alloc_data_t, list);
++	  *new_current_search_space=td_list_entry(current_search_space->list.next, alloc_data_t, list);
+ 	  *offset=(*new_current_search_space)->start;
+ 	}
+ 	current_search_space->end=start-1;
+@@ -358,14 +358,14 @@
+       /* start<=current_search_space->start current_search_space->end==end */
+       end=current_search_space->start-1;
+       if(list_search_space==current_search_space)
+-	list_search_space=list_entry(current_search_space->list.next, alloc_data_t, list);
++	list_search_space=td_list_entry(current_search_space->list.next, alloc_data_t, list);
+       if(offset!=NULL && new_current_search_space!=NULL &&
+ 	  current_search_space->start<=*offset && *offset<=current_search_space->end)
+       {
+-	*new_current_search_space=list_entry(current_search_space->list.next, alloc_data_t, list);
++	*new_current_search_space=td_list_entry(current_search_space->list.next, alloc_data_t, list);
+ 	*offset=(*new_current_search_space)->start;
+       }
+-      list_del(search_walker);
++      td_list_del(search_walker);
+       free(current_search_space);
+       return update_search_space_aux(list_search_space, start,end, new_current_search_space, offset);
+     }
+@@ -388,7 +388,7 @@
+       new_free_space->end=current_search_space->end;
+       new_free_space->file_stat=NULL;
+       current_search_space->end=start-1;
+-      list_add(&new_free_space->list,search_walker);
++      td_list_add(&new_free_space->list,search_walker);
+       if(offset!=NULL && new_current_search_space!=NULL &&
+ 	  new_free_space->start<=*offset && *offset<=new_free_space->end)
+       {
+@@ -418,13 +418,13 @@
+ 
+ void free_list_search_space(alloc_data_t *list_search_space)
+ {
+-  struct list_head *search_walker = NULL;
+-  struct list_head *search_walker_next = NULL;
+-  list_for_each_safe(search_walker,search_walker_next,&list_search_space->list)
++  struct td_list_head *search_walker = NULL;
++  struct td_list_head *search_walker_next = NULL;
++  td_list_for_each_safe(search_walker,search_walker_next,&list_search_space->list)
+   {
+     alloc_data_t *current_search_space;
+-    current_search_space=list_entry(search_walker, alloc_data_t, list);
+-    list_del(search_walker);
++    current_search_space=td_list_entry(search_walker, alloc_data_t, list);
++    td_list_del(search_walker);
+     free(current_search_space);
+   }
+ }
+@@ -514,7 +514,7 @@
+ static void get_prev_header(alloc_data_t *list_search_space, alloc_data_t **current_search_space, uint64_t *offset)
+ {
+   if((*current_search_space) != list_search_space)
+-    *current_search_space=list_entry((*current_search_space)->list.prev, alloc_data_t, list);
++    *current_search_space=td_list_entry((*current_search_space)->list.prev, alloc_data_t, list);
+   *offset=(*current_search_space)->start;
+ }
+ #endif
+@@ -525,7 +525,7 @@
+   alloc_data_t *file_space=*current_search_space;
+   for(nbr=0;nbr<5;nbr++)
+   {
+-    file_space=list_entry(file_space->list.prev, alloc_data_t, list);
++    file_space=td_list_entry(file_space->list.prev, alloc_data_t, list);
+     if(file_space==list_search_space)
+       return -1;
+     if(file_space->file_stat!=NULL)
+@@ -540,8 +540,8 @@
+ 
+ void forget(alloc_data_t *list_search_space, alloc_data_t *current_search_space)
+ {
+-  struct list_head *search_walker = NULL;
+-  struct list_head *prev= NULL;
++  struct td_list_head *search_walker = NULL;
++  struct td_list_head *prev= NULL;
+   int nbr=0;
+   if(current_search_space==list_search_space)
+     return ;
+@@ -553,8 +553,8 @@
+     if(nbr>10000)
+     {
+       alloc_data_t *tmp;
+-      tmp=list_entry(search_walker, alloc_data_t, list);
+-      list_del(&tmp->list);
++      tmp=td_list_entry(search_walker, alloc_data_t, list);
++      td_list_del(&tmp->list);
+       free(tmp);
+     }
+     else
+@@ -564,14 +564,14 @@
+ 
+ void list_cluster_free(list_cluster_t *list_cluster)
+ {
+-  struct list_head *dir_walker = NULL;
+-  struct list_head *dir_walker_next = NULL;
+-  list_for_each_safe(dir_walker,dir_walker_next,&list_cluster->list)
++  struct td_list_head *dir_walker = NULL;
++  struct td_list_head *dir_walker_next = NULL;
++  td_list_for_each_safe(dir_walker,dir_walker_next,&list_cluster->list)
+   {
+     list_cluster_t *info;
+-    info=list_entry(dir_walker, list_cluster_t, list);
++    info=td_list_entry(dir_walker, list_cluster_t, list);
+     delete_list_file(info->dir_list);
+-    list_del(dir_walker);
++    td_list_del(dir_walker);
+     free(info);
+   }
+ }
+@@ -589,16 +589,16 @@
+ 
+ void update_stats(file_stat_t *file_stats, alloc_data_t *list_search_space)
+ {
+-  struct list_head *search_walker = NULL;
++  struct td_list_head *search_walker = NULL;
+   int i;
+   /* Reset */
+   for(i=0;file_stats[i].file_hint!=NULL;i++)
+     file_stats[i].not_recovered=0;
+   /* Update */
+-  list_for_each(search_walker, &list_search_space->list)
++  td_list_for_each(search_walker, &list_search_space->list)
+   {
+     alloc_data_t *current_search_space;
+-    current_search_space=list_entry(search_walker, alloc_data_t, list);
++    current_search_space=td_list_entry(search_walker, alloc_data_t, list);
+     if(current_search_space->file_stat!=NULL)
+     {
+       current_search_space->file_stat->not_recovered++;
+@@ -705,13 +705,13 @@
+   unsigned int nbr_max=0;
+   for(cluster_size=default_blocksize;cluster_size<=128*512;cluster_size*=2)
+   {
+-    struct list_head *dir_walker = NULL;
++    struct td_list_head *dir_walker = NULL;
+     cluster_offset_t cluster_offset[1000];
+     unsigned int nbr_sol=0;
+-    list_for_each(dir_walker,&list_cluster->list)
++    td_list_for_each(dir_walker,&list_cluster->list)
+     {
+       list_cluster_t *info;
+-      info=list_entry(dir_walker, list_cluster_t, list);
++      info=td_list_entry(dir_walker, list_cluster_t, list);
+       if(info->cluster>=2 && (info->cluster-2)*cluster_size<info->offset)
+       {
+ 	unsigned int sol_cur;
+@@ -753,15 +753,15 @@
+   int blocksize_ok=0;
+   unsigned int blocksize;
+   *offset=0;
+-  if(list_empty(&list_file->list))
++  if(td_list_empty(&list_file->list))
+     return default_blocksize;
+   for(blocksize=128*512;blocksize>=default_blocksize && blocksize_ok==0;blocksize=blocksize>>1)
+   {
+-    struct list_head *search_walker = NULL;
++    struct td_list_head *search_walker = NULL;
+     blocksize_ok=1;
+     {
+       alloc_data_t *tmp;
+-      tmp=list_entry(list_file->list.next, alloc_data_t, list);
++      tmp=td_list_entry(list_file->list.next, alloc_data_t, list);
+       *offset=tmp->start%blocksize;
+     }
+     for(search_walker=list_file->list.next;
+@@ -769,7 +769,7 @@
+       search_walker=search_walker->next)
+     {
+       alloc_data_t *current_file;
+-      current_file=list_entry(search_walker, alloc_data_t, list);
++      current_file=td_list_entry(search_walker, alloc_data_t, list);
+       if(current_file->start%blocksize!=*offset)
+ 	blocksize_ok=0;
+     }
+@@ -780,18 +780,18 @@
+ 
+ alloc_data_t * update_blocksize(unsigned int blocksize, alloc_data_t *list_search_space, const uint64_t offset)
+ {
+-  struct list_head *search_walker = NULL;
+-  struct list_head *search_walker_next = NULL;
+-  list_for_each_safe(search_walker,search_walker_next,&list_search_space->list)
++  struct td_list_head *search_walker = NULL;
++  struct td_list_head *search_walker_next = NULL;
++  td_list_for_each_safe(search_walker,search_walker_next,&list_search_space->list)
+   {
+     alloc_data_t *current_search_space;
+-    current_search_space=list_entry(search_walker, alloc_data_t, list);
++    current_search_space=td_list_entry(search_walker, alloc_data_t, list);
+     current_search_space->start=(current_search_space->start-offset%blocksize+blocksize-1)/blocksize*blocksize+offset%blocksize;
+     if(current_search_space->start>current_search_space->end)
+     {
+-      list_del(search_walker);
++      td_list_del(search_walker);
+       if(list_search_space==current_search_space)
+-	list_search_space=list_entry(search_walker_next, alloc_data_t, list);
++	list_search_space=td_list_entry(search_walker_next, alloc_data_t, list);
+       free(current_search_space);
+     }
+   }
+@@ -1240,14 +1240,14 @@
+       list_free_add(file_recovery, list_search_space);
+       if((*current_search_space)!=list_search_space &&
+ 	  !((*current_search_space)->start <= *offset && *offset <= (*current_search_space)->end))
+-	*current_search_space=list_entry((*current_search_space)->list.next, alloc_data_t, list);
++	*current_search_space=td_list_entry((*current_search_space)->list.next, alloc_data_t, list);
+     }
+     else if(status!=STATUS_EXT2_ON_SAVE_EVERYTHING && status!=STATUS_EXT2_OFF_SAVE_EVERYTHING && status!=STATUS_FIND_OFFSET)
+     {
+       list_search_space=update_search_space(file_recovery,list_search_space,current_search_space,offset,blocksize);
+       file_recovered=1;
+     }
+-    list_delete(file_recovery->location.next);
++    td_list_delete(file_recovery->location.next);
+     file_recovery->location.next=NULL;
+   }
+   if(file_recovery->file_size==0 && file_recovery->offset_error!=0)
+diff -ruw testdisk-6.8.org/src/photorec.h testdisk-6.8/src/photorec.h
+--- testdisk-6.8.org/src/photorec.h	2007-07-17 19:24:04.000000000 +0200
++++ testdisk-6.8/src/photorec.h	2007-12-02 22:41:59.000000000 +0100
+@@ -9,7 +9,7 @@
+ typedef struct list_cluster_struct list_cluster_t;
+ struct list_cluster_struct
+ {
+-  struct list_head list;
++  struct td_list_head list;
+   uint64_t offset;
+   uint32_t cluster;
+   file_data_t *dir_list;
+diff -ruw testdisk-6.8.org/src/phrecn.c testdisk-6.8/src/phrecn.c
+--- testdisk-6.8.org/src/phrecn.c	2007-07-19 23:39:26.000000000 +0200
++++ testdisk-6.8/src/phrecn.c	2007-12-02 22:41:59.000000000 +0100
+@@ -365,8 +365,8 @@
+ 
+ static int photorec_bf(disk_t *disk_car, partition_t *partition, const int debug, const int paranoid, const char *recup_dir, const int interface, file_stat_t *file_stats, unsigned int *file_nbr, unsigned int *blocksize, alloc_data_t *list_search_space, const time_t real_start_time, unsigned int *dir_num, const photorec_status_t status, const unsigned int pass, const unsigned int expert, const unsigned int lowmem)
+ {
+-  struct list_head *search_walker = NULL;
+-  struct list_head *n= NULL;
++  struct td_list_head *search_walker = NULL;
++  struct td_list_head *n= NULL;
+   unsigned char *buffer_start;
+   unsigned int read_size;
+   unsigned int buffer_size;
+@@ -385,7 +385,7 @@
+     uint64_t offset;
+     int need_to_check_file;
+     file_recovery_t file_recovery;
+-    current_search_space=list_entry(search_walker, alloc_data_t, list);
++    current_search_space=td_list_entry(search_walker, alloc_data_t, list);
+     offset=current_search_space->start;
+     buffer_olddata=buffer_start;
+     buffer=buffer_olddata+(*blocksize);
+@@ -394,12 +394,12 @@
+     disk_car->read(disk_car,READ_SIZE, buffer, offset);
+ #ifdef DEBUG_BF
+     {
+-      struct list_head *tmp= NULL;
++      struct td_list_head *tmp= NULL;
+       log_debug("Explore ");
+-      list_for_each(tmp, &list_search_space->list)
++      td_list_for_each(tmp, &list_search_space->list)
+       {
+ 	alloc_data_t *cur_free_space;
+-	cur_free_space=list_entry(tmp, alloc_data_t, list);
++	cur_free_space=td_list_entry(tmp, alloc_data_t, list);
+ 	log_debug(" %lu-%lu",(long unsigned)(cur_free_space->start/disk_car->sector_size),
+ 	    (long unsigned)(cur_free_space->end/disk_car->sector_size));
+ 	if(cur_free_space==current_search_space)
+@@ -538,7 +538,7 @@
+     {
+       if(file_finish(&file_recovery,recup_dir,paranoid,file_nbr, *blocksize, list_search_space, &current_search_space, &offset, dir_num,status,disk_car->sector_size,disk_car)<0)
+       { /* BF */
+-	current_search_space=list_entry(search_walker, alloc_data_t, list);
++	current_search_space=td_list_entry(search_walker, alloc_data_t, list);
+ 	ind_stop=photorec_bf_aux(disk_car, partition, paranoid, recup_dir, interface, file_stats, file_nbr, &file_recovery, *blocksize, list_search_space, current_search_space, real_start_time, dir_num, status, pass2);
+ 	pass2++;
+       }
+@@ -619,11 +619,11 @@
+ 	  extrablock_offset=element->end/blocksize*blocksize;
+       }
+       /* Get the corresponding search_place */
+-      extractblock_search_space=list_entry(list_search_space->list.next, alloc_data_t, list);
++      extractblock_search_space=td_list_entry(list_search_space->list.next, alloc_data_t, list);
+       while(extractblock_search_space != list_search_space &&
+ 	  !(extractblock_search_space->start <= extrablock_offset &&
+ 	    extrablock_offset <= extractblock_search_space->end))
+-	extractblock_search_space=list_entry(extractblock_search_space->list.next, alloc_data_t, list);
++	extractblock_search_space=td_list_entry(extractblock_search_space->list.next, alloc_data_t, list);
+       /* Update extractblock_search_space & extrablock_offset */
+       get_next_sector(list_search_space, &extractblock_search_space, &extrablock_offset, blocksize);
+       /* */
+@@ -730,10 +730,10 @@
+   alloc_data_t *current_search_space;
+   file_recovery_t file_recovery;
+   static alloc_data_t list_file={
+-    .list = LIST_HEAD_INIT(list_file.list)
++    .list = TD_LIST_HEAD_INIT(list_file.list)
+   };
+   static list_cluster_t list_cluster= {
+-    .list = LIST_HEAD_INIT(list_cluster.list)
++    .list = TD_LIST_HEAD_INIT(list_cluster.list)
+   };
+ #define READ_SIZE 256*512
+   read_size=((*blocksize)>8192?(*blocksize):8192);
+@@ -747,18 +747,18 @@
+   memset(buffer_olddata,0,(*blocksize));
+   if(debug>1)
+   {
+-    struct list_head *search_walker = NULL;
++    struct td_list_head *search_walker = NULL;
+     log_debug("Explore ");
+-    list_for_each(search_walker, &list_search_space->list)
++    td_list_for_each(search_walker, &list_search_space->list)
+     {
+       alloc_data_t *cur_free_space;
+-      cur_free_space=list_entry(search_walker, alloc_data_t, list);
++      cur_free_space=td_list_entry(search_walker, alloc_data_t, list);
+       log_debug(" %lu-%lu",(long unsigned)(cur_free_space->start/disk_car->sector_size),
+ 	  (long unsigned)(cur_free_space->end/disk_car->sector_size));
+     }
+     log_debug("\n");
+   }
+-  current_search_space=list_entry(list_search_space->list.next, alloc_data_t, list);
++  current_search_space=td_list_entry(list_search_space->list.next, alloc_data_t, list);
+   if(current_search_space!=list_search_space)
+     offset=current_search_space->start;
+   disk_car->read(disk_car,READ_SIZE, buffer, offset);
+@@ -832,7 +832,7 @@
+ 	      new_file_alloc=(alloc_data_t*)MALLOC(sizeof(*new_file_alloc));
+ 	      new_file_alloc->start=file_recovery.location.start;
+ 	      new_file_alloc->end=0;
+-	      list_add_tail(&new_file_alloc->list,&list_file.list);
++	      td_list_add_tail(&new_file_alloc->list,&list_file.list);
+ 	      (*file_nbr)++;
+ 	    }
+ 	    if(file_recovery.file_stat->file_hint==&file_hint_dir)
+@@ -1080,7 +1080,7 @@
+   aff_buffer(BUFFER_RESET,"Q");
+   log_info("\nAnalyse\n");
+   log_partition(disk_car,partition);
+-  if(blocksize==0 || list_empty(&list_search_space->list))
++  if(blocksize==0 || td_list_empty(&list_search_space->list))
+   {
+     blocksize=disk_car->sector_size;
+     blocksize_is_known=0;
+@@ -1088,10 +1088,10 @@
+   else
+     blocksize_is_known=1;
+ 
+-  if(list_empty(&list_search_space->list))
++  if(td_list_empty(&list_search_space->list))
+   {
+     alloc_data_t *tmp=init_search_space(partition,disk_car);
+-    list_add_tail(&tmp->list, &list_search_space->list);
++    td_list_add_tail(&tmp->list, &list_search_space->list);
+     if(mode_ext2==0 && carve_free_space_only>0)
+     {
+       blocksize=remove_used_space(disk_car, partition, list_search_space);
+@@ -1103,11 +1103,11 @@
+   }
+   else
+   { /* Correct the values */
+-    struct list_head *search_walker = NULL;
+-    list_for_each(search_walker, &list_search_space->list)
++    struct td_list_head *search_walker = NULL;
++    td_list_for_each(search_walker, &list_search_space->list)
+     {
+       alloc_data_t *current_search_space;
+-      current_search_space=list_entry(search_walker, alloc_data_t, list);
++      current_search_space=td_list_entry(search_walker, alloc_data_t, list);
+       current_search_space->start=current_search_space->start*disk_car->sector_size;
+       current_search_space->end=current_search_space->end*disk_car->sector_size+disk_car->sector_size-1;
+     }
+@@ -1266,15 +1266,15 @@
+     }
+   }
+   {
+-    struct list_head *search_walker = NULL;
+-    struct list_head *search_walker_next = NULL;
++    struct td_list_head *search_walker = NULL;
++    struct td_list_head *search_walker_next = NULL;
+     unsigned long int nbr_headers=0;
+     uint64_t sectors_with_unknown_data=0;
+     /* Free memory */
+-    list_for_each_safe(search_walker,search_walker_next,&list_search_space->list)
++    td_list_for_each_safe(search_walker,search_walker_next,&list_search_space->list)
+     {
+       alloc_data_t *current_search_space;
+-      current_search_space=list_entry(search_walker, alloc_data_t, list);
++      current_search_space=td_list_entry(search_walker, alloc_data_t, list);
+       if(current_search_space->file_stat!=NULL)
+       {
+ 	nbr_headers++;
+@@ -1290,7 +1290,7 @@
+ 	      current_search_space->file_stat->file_hint->extension:""):
+ 	     "(null)"));
+       }
+-      list_del(search_walker);
++      td_list_del(search_walker);
+       free(current_search_space);
+     }
+     log_info("%llu sectors contains unknown data, %lu invalid files found %s.\n",
+@@ -1533,12 +1533,12 @@
+   };
+   char *current_cmd=cmd_run;
+   alloc_data_t list_search_space={
+-    .list = LIST_HEAD_INIT(list_search_space.list)
++    .list = TD_LIST_HEAD_INIT(list_search_space.list)
+   };
+   if(cmd_device==NULL)
+   {
+     session_load(&cmd_device, &current_cmd,&list_search_space);
+-    if(cmd_device!=NULL && current_cmd!=NULL && !list_empty(&list_search_space.list) && ask_confirmation("Continue previous session ? (Y/N)")!=0)
++    if(cmd_device!=NULL && current_cmd!=NULL && !td_list_empty(&list_search_space.list) && ask_confirmation("Continue previous session ? (Y/N)")!=0)
+     {
+       /* yes */
+     }
+@@ -2041,7 +2041,7 @@
+       (unsigned long long)((*current_search_space)->end)/512);
+ #endif
+   if((*current_search_space) != list_search_space)
+-    *current_search_space=list_entry((*current_search_space)->list.next, alloc_data_t, list);
++    *current_search_space=td_list_entry((*current_search_space)->list.next, alloc_data_t, list);
+   *offset=(*current_search_space)->start;
+ }
+ 
+diff -ruw testdisk-6.8.org/src/savehdr.c testdisk-6.8/src/savehdr.c
+--- testdisk-6.8.org/src/savehdr.c	2007-07-06 16:35:45.000000000 +0200
++++ testdisk-6.8/src/savehdr.c	2007-12-02 22:41:59.000000000 +0100
+@@ -137,7 +137,7 @@
+ 	log_debug("new disk: %s\n",pos);
+       }
+       if(new_backup!=NULL)
+-	list_add_tail(&new_backup->list,&list_backup->list);
++	td_list_add_tail(&new_backup->list,&list_backup->list);
+       new_backup=(backup_disk_t*)MALLOC(sizeof(*new_backup));
+       new_backup->description[0]='\0';
+       new_backup->list_part=NULL;
+@@ -196,7 +196,7 @@
+     }
+   }
+   if(new_backup!=NULL)
+-    list_add_tail(&new_backup->list,&list_backup->list);
++    td_list_add_tail(&new_backup->list,&list_backup->list);
+   fclose(f_backup);
+   free(buffer);
+   return list_backup;
+diff -ruw testdisk-6.8.org/src/savehdr.h testdisk-6.8/src/savehdr.h
+--- testdisk-6.8.org/src/savehdr.h	2007-05-11 11:16:40.000000000 +0200
++++ testdisk-6.8/src/savehdr.h	2007-12-02 22:41:59.000000000 +0100
+@@ -23,7 +23,7 @@
+ typedef struct backup_disk backup_disk_t;
+ struct backup_disk
+ {
+-  struct list_head list;
++  struct td_list_head list;
+   time_t my_time;
+   char description[128];
+   list_part_t *list_part;
+diff -ruw testdisk-6.8.org/src/sessionp.c testdisk-6.8/src/sessionp.c
+--- testdisk-6.8.org/src/sessionp.c	2007-07-06 16:32:42.000000000 +0200
++++ testdisk-6.8/src/sessionp.c	2007-12-02 22:41:59.000000000 +0100
+@@ -142,7 +142,7 @@
+ 	  new_free_space->start=start;
+ 	  new_free_space->end=end;
+ 	  new_free_space->file_stat=NULL;
+-	  list_add_tail(&new_free_space->list, &list_free_space->list);
++	  td_list_add_tail(&new_free_space->list, &list_free_space->list);
+ #ifdef DEBUG
+ 	  log_trace(">%lu-%lu<\n",start,end);
+ #endif
+@@ -161,7 +161,7 @@
+ 
+ int session_save(alloc_data_t *list_free_space, disk_t *disk_car, const partition_t *partition, const file_enable_t *files_enable, const unsigned int blocksize, const int debug)
+ {
+-  struct list_head *free_walker = NULL;
++  struct td_list_head *free_walker = NULL;
+   FILE *f_session;
+   unsigned int i;
+   if(debug>1)
+@@ -183,10 +183,10 @@
+     }
+   }
+   fprintf(f_session,"search,inter\n");
+-  list_for_each(free_walker, &list_free_space->list)
++  td_list_for_each(free_walker, &list_free_space->list)
+   {
+     alloc_data_t *current_free_space;
+-    current_free_space=list_entry(free_walker, alloc_data_t, list);
++    current_free_space=td_list_entry(free_walker, alloc_data_t, list);
+     fprintf(f_session,"%lu-%lu\n",(long unsigned)(current_free_space->start/disk_car->sector_size),
+ 	(long unsigned)(current_free_space->end/disk_car->sector_size));
+   }
diff --git a/app-admin/testdisk/testdisk-6.8-r1.ebuild b/app-admin/testdisk/testdisk-6.8-r1.ebuild
new file mode 100644
index 000000000000..a63ea4b3b3eb
--- /dev/null
+++ b/app-admin/testdisk/testdisk-6.8-r1.ebuild
@@ -0,0 +1,61 @@
+# Copyright 1999-2008 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/app-admin/testdisk/testdisk-6.8-r1.ebuild,v 1.1 2008/02/10 14:06:19 maekke Exp $
+
+inherit eutils flag-o-matic
+
+DESCRIPTION="Multi-platform tool to check and undelete partition, supports reiserfs, ntfs, fat32, ext2/3 and many others. Also includes PhotoRec to recover pictures from digital camera memory."
+HOMEPAGE="http://www.cgsecurity.org/wiki/TestDisk"
+SRC_URI="http://www.cgsecurity.org/${P}.tar.bz2"
+LICENSE="GPL-2"
+SLOT="0"
+KEYWORDS="~amd64 ~ppc ~x86"
+IUSE="static reiserfs ntfs jpeg"
+# WARNING: reiserfs support does NOT work with reiserfsprogs
+# you MUST use progsreiserfs-0.3.1_rc8 (the last version ever released).
+DEPEND=">=sys-libs/ncurses-5.2
+		jpeg? ( media-libs/jpeg )
+	  	ntfs? ( >=sys-fs/ntfsprogs-2.0.0 )
+	  	reiserfs? ( >=sys-fs/progsreiserfs-0.3.1_rc8 )
+	  	>=sys-fs/e2fsprogs-1.35"
+RDEPEND="!static? ( ${DEPEND} )"
+
+src_unpack() {
+	unpack ${A}
+
+	epatch "${FILESDIR}"/${P}-ntfsprogs2.patch
+}
+
+src_compile() {
+	local myconf="--without-ewf"
+	# --with-foo are broken, any use of --with/--without disable the
+	# functionality.
+	# The following variation must be used.
+	use reiserfs || myconf="${myconf} --without-reiserfs"
+	use ntfs || myconf="${myconf} --without-ntfs"
+	use jpeg || myconf="${myconf} --without-jpeg"
+
+	# this is static method is the same used by upstream for their 'static' make
+	# target, but better, as it doesn't break.
+	use static && append-ldflags -static
+
+	econf ${myconf} || die
+
+	# perform safety checks for NTFS and REISERFS
+	if useq ntfs && egrep -q 'undef HAVE_LIBNTFS\>' "${S}"/config.h ; then
+		die "Failed to find NTFS library."
+	fi
+	if useq reiserfs && egrep -q 'undef HAVE_LIBREISERFS\>' "${S}"/config.h ; then
+		die "Failed to find reiserfs library."
+	fi
+	if useq jpeg && egrep -q 'undef HAVE_LIBJPEG\>' "${S}"/config.h ; then
+		die "Failed to find jpeg library."
+	fi
+
+	emake || die
+}
+
+src_install() {
+	emake DESTDIR="${D}" install || die
+	[ "$PF" != "$P" ] && mv "${D}"/usr/share/doc/${P} "${D}"/usr/share/doc/${PF}
+}