linux-ntfs-cvs — List for CVS checkins and comments.

[Linux-ntfs-cvs] CVS: linux-ntfs AUTHORS,NONE,1.1 CREDITS,NONE,1.1 Makefile,NONE,1.1 Rules.make,NONE,1.1 TODO.include,1.1,1.2

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs
In directory usw-pr-cvs1:/tmp/cvs-serv3215

Modified Files:
	TODO.include 
Added Files:
	AUTHORS CREDITS Makefile Rules.make 
Log Message:
And the last move into CVS. The make files. (Note: compilation is untested
and all changes have been done without testing so if it doesn't compile at
the moment don't be too surprised.)


--- NEW FILE ---

Linux-NTFS is written by Anton Altparmakov <ai...@ca...>.



--- NEW FILE ---
The following people have contributed directly or indirectly to the linux-ntfs
project.

The list is sorted alphabetically, so please keep it this way!

Please let me know (email Anton <ai...@ca...>) if you believe someone is
missing or if you prefer to not be listed.


Yuri Per <yu...@ac...>



--- NEW FILE ---
VERSION = 0
PATCHLEVEL = 0
SUBLEVEL = 1
EXTRAVERSION =

NTFSRELEASE = $(VERSION).$(PATCHLEVEL).$(SUBLEVEL)$(EXTRAVERSION)

TOPDIR  := $(shell pushd . > /dev/null; cd ..; if [ "$$PWD" != "" ]; then echo $$PWD; else pwd; fi; popd > /dev/null)

HPATH   = $(TOPDIR)/include

CC = gcc

CPPFLAGS := -I$(HPATH)

CFLAGS := $(CPPFLAGS) -Wall -Wstrict-prototypes -fomit-frame-pointer \
	 -pipe -fno-strength-reduce -m486 -DCPU=486 -D_FILE_OFFSET_BITS=64 \
	 -D__USE_GNU

# Production build.
#CFLAGS += -O2

# Debug build.
CFLAGS += -ggdb -DDEBUG

LIBS = $(TOPDIR)/lib/ntfslib.a
LIBDIRS = $(TOPDIR)/libntfs
SUBDIRS = $(TOPDIR)/ntfstools

export VERSION PATCHLEVEL SUBLEVEL EXTRAVERSION NTFSRELEASE
export TOPDIR HPATH CC CPPFLAGS CFLAGS LIBS LIBDIRS SUBDIRS

all:	ntfslib utils

build:	clean install

clean:
	rm -f `find $(TOPDIR) \( -name '*.[oas]' -or -name core -or -name \
		".*.flags" -or -name "*~" \) -type f -exec rm "{}" \;`
	rm -f $(TOPDIR)/bin/* $(TOPDIR)/lib/*

utils:
	$(MAKE) -C $(SUBDIRS)

ntfslib:
	$(MAKE) -C $(LIBDIRS)
	ld --whole-archive -shared -o $(TOPDIR)/lib/libntfs.so \
		$(TOPDIR)/lib/libntfs.a

install:
	sudo install -c -g root -o root -m 755 -s $(TOPDIR)/bin/ntfsfix \
								/usr/local/bin
	sudo install -c -g root -o root -m 755 -s $(TOPDIR)/lib/libntfs.a \
								/usr/local/lib
	sudo install -c -g root -o root -m 755 -s $(TOPDIR)/lib/libntfs.so \
								/usr/local/lib

uninstall:
	rm /usr/local/bin/ntfsfix
	rm /usr/local/lib/libntfs.a
	rm /usr/local/lib/libntfs.so

include $(TOPDIR)/Rules.make


--- NEW FILE ---
# This file is a straight copy from linux kernel 2.4.0
#
# This file contains rules which are shared between multiple Makefiles.
#

#
# False targets.
#
.PHONY: dummy

#
# Special variables which should not be exported
#
unexport EXTRA_AFLAGS
unexport EXTRA_CFLAGS
unexport EXTRA_LDFLAGS
unexport EXTRA_ARFLAGS
unexport SUBDIRS
unexport SUB_DIRS
unexport ALL_SUB_DIRS
unexport MOD_SUB_DIRS
unexport O_TARGET
unexport ALL_MOBJS

unexport obj-y
unexport obj-m
unexport obj-n
unexport obj-
unexport export-objs
unexport subdir-y
unexport subdir-m
unexport subdir-n
unexport subdir-

#
# Get things started.
#
first_rule: sub_dirs
	$(MAKE) all_targets

both-m          := $(filter $(mod-subdirs), $(subdir-y))
SUB_DIRS	:= $(subdir-y)
MOD_SUB_DIRS	:= $(sort $(subdir-m) $(both-m))
ALL_SUB_DIRS	:= $(sort $(subdir-y) $(subdir-m) $(subdir-n) $(subdir-))


#
# Common rules
#

%.s: %.c
	$(CC) $(CFLAGS) $(EXTRA_CFLAGS) $(CFLAGS_$@) -S $< -o $@

%.i: %.c
	$(CPP) $(CFLAGS) $(EXTRA_CFLAGS) $(CFLAGS_$@) $< > $@

%.o: %.c
	$(CC) $(CFLAGS) $(EXTRA_CFLAGS) $(CFLAGS_$@) -c -o $@ $<
	@ ( \
	    echo 'ifeq ($(strip $(subst $(comma),:,$(CFLAGS) $(EXTRA_CFLAGS) $(CFLAGS_$@))),$$(strip $$(subst $$(comma),:,$$(CFLAGS) $$(EXTRA_CFLAGS) $$(CFLAGS_$@))))' ; \
	    echo 'FILES_FLAGS_UP_TO_DATE += $@' ; \
	    echo 'endif' \
	) > $(dir $@)/.$(notdir $@).flags

%.o: %.s
	$(AS) $(AFLAGS) $(EXTRA_CFLAGS) -o $@ $<

# Old makefiles define their own rules for compiling .S files,
# but these standard rules are available for any Makefile that
# wants to use them.  Our plan is to incrementally convert all
# the Makefiles to these standard rules.  -- rmk, mec
ifdef USE_STANDARD_AS_RULE

%.s: %.S
	$(CPP) $(AFLAGS) $(EXTRA_AFLAGS) $(AFLAGS_$@) $< > $@

%.o: %.S
	$(CC) $(AFLAGS) $(EXTRA_AFLAGS) $(AFLAGS_$@) -c -o $@ $<

endif

%.lst: %.c
	$(CC) $(CFLAGS) $(EXTRA_CFLAGS) $(CFLAGS_$@) -g -c -o $*.o $<
	$(TOPDIR)/scripts/makelst $* $(TOPDIR) $(OBJDUMP)
#
#
#
all_targets: $(O_TARGET) $(L_TARGET)

#
# Rule to compile a set of .o files into one .o file
#
ifdef O_TARGET
$(O_TARGET): $(obj-y)
	rm -f $@
    ifneq "$(strip $(obj-y))" ""
	$(LD) $(EXTRA_LDFLAGS) -o $@ $(filter $(obj-y), $^)
    else
	$(AR) rcs $@
    endif
	@ ( \
	    echo 'ifeq ($(strip $(subst $(comma),:,$(EXTRA_LDFLAGS) $(obj-y))),$$(strip $$(subst $$(comma),:,$$(EXTRA_LDFLAGS) $$(obj-y))))' ; \
	    echo 'FILES_FLAGS_UP_TO_DATE += $@' ; \
	    echo 'endif' \
	) > $(dir $@)/.$(notdir $@).flags
endif # O_TARGET

#
# Rule to compile a set of .o files into one .a file
#
ifdef L_TARGET
$(L_TARGET): $(obj-y)
	rm -f $@
	$(AR) $(EXTRA_ARFLAGS) rcus $@ $(obj-y)
	@ ( \
	    echo 'ifeq ($(strip $(subst $(comma),:,$(EXTRA_ARFLAGS) $(obj-y))),$$(strip $$(subst $$(comma),:,$$(EXTRA_ARFLAGS) $$(obj-y))))' ; \
	    echo 'FILES_FLAGS_UP_TO_DATE += $@' ; \
	    echo 'endif' \
	) > $(dir $@)/.$(notdir $@).flags
endif


#
# This make dependencies quickly
#
fastdep: dummy
	$(TOPDIR)/scripts/mkdep $(wildcard *.[chS] local.h.master) > .depend
ifdef ALL_SUB_DIRS
	$(MAKE) $(patsubst %,_sfdep_%,$(ALL_SUB_DIRS)) _FASTDEP_ALL_SUB_DIRS="$(ALL_SUB_DIRS)"
endif

ifdef _FASTDEP_ALL_SUB_DIRS
$(patsubst %,_sfdep_%,$(_FASTDEP_ALL_SUB_DIRS)):
	$(MAKE) -C $(patsubst _sfdep_%,%,$@) fastdep
endif

	
#
# A rule to make subdirectories
#
subdir-list = $(sort $(patsubst %,_subdir_%,$(SUB_DIRS)))
sub_dirs: dummy $(subdir-list)

ifdef SUB_DIRS
$(subdir-list) : dummy
	$(MAKE) -C $(patsubst _subdir_%,%,$@)
endif

#
# A rule to make modules
#
ALL_MOBJS = $(filter-out $(obj-y), $(obj-m))
ifneq "$(strip $(ALL_MOBJS))" ""
PDWN=$(shell $(CONFIG_SHELL) $(TOPDIR)/scripts/pathdown.sh)
endif

unexport MOD_DIRS
MOD_DIRS := $(MOD_SUB_DIRS) $(MOD_IN_SUB_DIRS)
ifneq "$(strip $(MOD_DIRS))" ""
.PHONY: $(patsubst %,_modsubdir_%,$(MOD_DIRS))
$(patsubst %,_modsubdir_%,$(MOD_DIRS)) : dummy
	$(MAKE) -C $(patsubst _modsubdir_%,%,$@) modules

.PHONY: $(patsubst %,_modinst_%,$(MOD_DIRS))
$(patsubst %,_modinst_%,$(MOD_DIRS)) : dummy
	$(MAKE) -C $(patsubst _modinst_%,%,$@) modules_install
endif

.PHONY: modules
modules: $(ALL_MOBJS) dummy \
	 $(patsubst %,_modsubdir_%,$(MOD_DIRS))

.PHONY: _modinst__
_modinst__: dummy
ifneq "$(strip $(ALL_MOBJS))" ""
	mkdir -p $(MODLIB)/kernel/$(PDWN)
	cp $(ALL_MOBJS) $(MODLIB)/kernel/$(PDWN)
endif

.PHONY: modules_install
modules_install: _modinst__ \
	 $(patsubst %,_modinst_%,$(MOD_DIRS))

#
# A rule to do nothing
#
dummy:

#
# This is useful for testing
#
script:
	$(SCRIPT)

#
# This sets version suffixes on exported symbols
# Separate the object into "normal" objects and "exporting" objects
# Exporting objects are: all objects that define symbol tables
#
ifdef CONFIG_MODULES

multi-used	:= $(filter $(list-multi), $(obj-y) $(obj-m))
multi-objs	:= $(foreach m, $(multi-used), $($(basename $(m))-objs))
active-objs	:= $(sort $(multi-objs) $(obj-y) $(obj-m))

ifdef CONFIG_MODVERSIONS
ifneq "$(strip $(export-objs))" ""

MODINCL = $(TOPDIR)/include/linux/modules

# The -w option (enable warnings) for genksyms will return here in 2.1
# So where has it gone?
#
# Added the SMP separator to stop module accidents between uniprocessor
# and SMP Intel boxes - AC - from bits by Michael Chastain
#

ifdef CONFIG_SMP
	genksyms_smp_prefix := -p smp_
else
	genksyms_smp_prefix := 
endif

$(MODINCL)/%.ver: %.c
	@if [ ! -r $(MODINCL)/$*.stamp -o $(MODINCL)/$*.stamp -ot $< ]; then \
		echo '$(CC) $(CFLAGS) -E -D__GENKSYMS__ $<'; \
		echo '| $(GENKSYMS) $(genksyms_smp_prefix) -k $(VERSION).$(PATCHLEVEL).$(SUBLEVEL) > $@.tmp'; \
		$(CC) $(CFLAGS) -E -D__GENKSYMS__ $< \
		| $(GENKSYMS) $(genksyms_smp_prefix) -k $(VERSION).$(PATCHLEVEL).$(SUBLEVEL) > $@.tmp; \
		if [ -r $@ ] && cmp -s $@ $@.tmp; then echo $@ is unchanged; rm -f $@.tmp; \
		else echo mv $@.tmp $@; mv -f $@.tmp $@; fi; \
	fi; touch $(MODINCL)/$*.stamp
	
$(addprefix $(MODINCL)/,$(export-objs:.o=.ver)): $(TOPDIR)/include/linux/autoconf.h

# updates .ver files but not modversions.h
fastdep: $(addprefix $(MODINCL)/,$(export-objs:.o=.ver))

# updates .ver files and modversions.h like before (is this needed?)
dep: fastdep update-modverfile

endif # export-objs 

# update modversions.h, but only if it would change
update-modverfile:
	@(echo "#ifndef _LINUX_MODVERSIONS_H";\
	  echo "#define _LINUX_MODVERSIONS_H"; \
	  echo "#include <linux/modsetver.h>"; \
	  cd $(TOPDIR)/include/linux/modules; \
	  for f in *.ver; do \
	    if [ -f $$f ]; then echo "#include <linux/modules/$${f}>"; fi; \
	  done; \
	  echo "#endif"; \
	) > $(TOPDIR)/include/linux/modversions.h.tmp
	@if [ -r $(TOPDIR)/include/linux/modversions.h ] && cmp -s $(TOPDIR)/include/linux/modversions.h $(TOPDIR)/include/linux/modversions.h.tmp; then \
		echo $(TOPDIR)/include/linux/modversions.h was not updated; \
		rm -f $(TOPDIR)/include/linux/modversions.h.tmp; \
	else \
		echo $(TOPDIR)/include/linux/modversions.h was updated; \
		mv -f $(TOPDIR)/include/linux/modversions.h.tmp $(TOPDIR)/include/linux/modversions.h; \
	fi

$(active-objs): $(TOPDIR)/include/linux/modversions.h

else

$(TOPDIR)/include/linux/modversions.h:
	@echo "#include <linux/modsetver.h>" > $@

endif # CONFIG_MODVERSIONS

ifneq "$(strip $(export-objs))" ""
$(export-objs): $(export-objs:.o=.c) $(TOPDIR)/include/linux/modversions.h
	$(CC) $(CFLAGS) $(EXTRA_CFLAGS) $(CFLAGS_$@) -DEXPORT_SYMTAB -c $(@:.o=.c)
	@ ( \
	    echo 'ifeq ($(strip $(subst $(comma),:,$(CFLAGS) $(EXTRA_CFLAGS) $(CFLAGS_$@) -DEXPORT_SYMTAB)),$$(strip $$(subst $$(comma),:,$$(CFLAGS) $$(EXTRA_CFLAGS) $$(CFLAGS_$@) -DEXPORT_SYMTAB)))' ; \
	    echo 'FILES_FLAGS_UP_TO_DATE += $@' ; \
	    echo 'endif' \
	) > $(dir $@)/.$(notdir $@).flags
endif

endif # CONFIG_MODULES


#
# include dependency files if they exist
#
ifneq ($(wildcard .depend),)
include .depend
endif

ifneq ($(wildcard $(TOPDIR)/.hdepend),)
include $(TOPDIR)/.hdepend
endif

#
# Find files whose flags have changed and force recompilation.
# For safety, this works in the converse direction:
#   every file is forced, except those whose flags are positively up-to-date.
#
FILES_FLAGS_UP_TO_DATE :=

# For use in expunging commas from flags, which mung our checking.
comma = ,

FILES_FLAGS_EXIST := $(wildcard .*.flags)
ifneq ($(FILES_FLAGS_EXIST),)
include $(FILES_FLAGS_EXIST)
endif

FILES_FLAGS_CHANGED := $(strip \
    $(filter-out $(FILES_FLAGS_UP_TO_DATE), \
	$(O_TARGET) $(L_TARGET) $(active-objs) \
	))

# A kludge: .S files don't get flag dependencies (yet),
#   because that will involve changing a lot of Makefiles.  Also
#   suppress object files explicitly listed in $(IGNORE_FLAGS_OBJS).
#   This allows handling of assembly files that get translated into
#   multiple object files (see arch/ia64/lib/idiv.S, for example).
FILES_FLAGS_CHANGED := $(strip \
    $(filter-out $(patsubst %.S, %.o, $(wildcard *.S) $(IGNORE_FLAGS_OBJS)), \
    $(FILES_FLAGS_CHANGED)))

ifneq ($(FILES_FLAGS_CHANGED),)
$(FILES_FLAGS_CHANGED): dummy
endif

Index: TODO.include
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/TODO.include,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** TODO.include	2001/01/24 02:10:41	1.1
--- TODO.include	2001/01/30 12:29:03	1.2
***************
*** 1,4 ****
  Finish attrib.h
- Finish migration of the rest of the headers.
- Import include/* into cvs.
  
--- 1,2 ----

[Linux-ntfs-cvs] CVS: linux-ntfs/libntfs attrib.c,NONE,1.1

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/libntfs
In directory usw-pr-cvs1:/tmp/cvs-serv8700/libntfs

Added Files:
	attrib.c 
Log Message:
Added in the current state of attribute handling to libntfs.
Now just missing the make files to make a first public release of ntfsfix!



--- NEW FILE ---
/*
 * attrib.c - Attribute handling code. Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <wchar.h>
#include <stddef.h>
#include <stdio.h>
#include <linux/types.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>

/*
 * This would be defining wchar_t in the kernel, but stdio.h defines it for
 * userspace. FIXME: I have been a bit slack and defining __u16 instead of
 * wchar_t in most places. This will need fixing at some point.
 */
/* #include <linux/nls.h> */

#include "attrib.h"
#include "mft.h"
#include "endians.h"
#include "disk_io.h"
#include "volume.h"

/*
 * Generic macro to convert pointers to values for comparison purposes.
 */
#define p2n(p)		((ptrdiff_t)((ptrdiff_t*)(p)))

ATTRIBUTE_RECORD_HEADER *find_attribute(const MFT_RECORD_HEADER *b,
					const ATTRIBUTE_TYPE t,
					const wchar_t *n)
{
        ATTRIBUTE_RECORD_HEADER *a;

	/* Sanity/size/alignment checks. */
	if (!b		||	!is_mft_recordp(b)	||
	    !(b->flags & MFT_RECORD_IN_USE)		||
	    b->base_file_record				||
	    p2n((char*)b + b->attributes_offset) & 7	||
	    p2n((char*)b + b->bytes_in_use) & 7		||
	    le16_to_cpu(b->attributes_offset) >= le32_to_cpu(b->bytes_in_use)) {
#ifdef DEBUG
		puts("Sanity/size/allignment checks failed in " \
		     "find_attribute()!");
#endif	
		return NULL;
	}
	/* Position of the first attribute. */
	a = (ATTRIBUTE_RECORD_HEADER*)(le16_to_cpu(b->attributes_offset) +
		       						(char*)b);
	/* Alignment check. Note: Can't move this inside while loop, since if
	   this fails a->type will fail too but it will cause an exception! */
	if (p2n(a) & 7) {
#ifdef DEBUG
		puts("Alignment check (2) failed in find_attribute()!");
#endif	
		return NULL;
	}
	/* Iterate over all atributes. */
	while (a->type != $END) {
		if (le32_to_cpu(a->length) + (char*)a >= 
				le32_to_cpu(b->bytes_in_use) + (char*)b) {
#ifdef DEBUG
			puts("Attribute length out of bounds in " \
			     "find_attribute()!");
#endif	
			return NULL;
		}
		if (a->type == t) {
			/* If want an unnamed attribute, check if current one
			   is unnamed and if so we have found it! */
			if (!n) {
				if (!a->name_length)
					return a;
			/* If we want a named attribute, check that the string
			   length is equal and if so, compare the two strings
			   and if they match, we have found it! */
			} else if (a->name_length &&
				    a->name_length == wcslen(n)) {
				/* Sanity check. */
				if (a->name_length * 2 +
						le16_to_cpu(a->name_offset)
					> le32_to_cpu(a->length)) {
#ifdef DEBUG
					puts("Warning: Encountered out of "
					     "bounds attribute name length in "
					     "find_attribute()!");	
#endif
					/* Even though this one is illegal, 
					   maybe it wasn't the right one, so
					   continue with the search (i.e. don't
					   return NULL).
					   FIXME: Shouldn't we doing a hotfix
					   here, i.e. truncate the name to the
					   indicated size or change the
					   indicated size, whichever makes more
					   sense? */
				/* FIXME: Should we really be case sensitive?
				   If not we should be using the $UpCase table,
				   thus we need a custom function for
				   comparisons. */
				} else if (!wcscmp(n, (wchar_t*)((char*)a +
						le16_to_cpu(a->name_offset))))
					return a;
			}
		}
		/* FIXME: If we find an attribute list then the attribute we
		   are looking for might be in there, but we don't handle those 
		   yet, so just skip it for now and emitt a warning. */
		if (a->type == $ATTRIBUTE_LIST) {
			puts("Warning: Encountered attribute list attribute"
			     "which we can't handle yet.");
		}
		/* Get next attribute. */
		a = (ATTRIBUTE_RECORD_HEADER*)((char *)a + 
							le32_to_cpu(a->length));
		/* Alignment check. */
		if (p2n(a) & 7) {
#ifdef DEBUG
			puts("Allignment check (3) failed in " \
			     "find_attribute()!");
#endif	
			return NULL;
		}
	}
#ifdef DEBUG
	if (n)
		printf("Named attribute 0x%x not found in " \
		       "find_attribute()!", t);
	else
		printf("Unnamed attribute 0x%x not found in " \
		       "find_attribute()!", t);
#endif	
        return NULL;
}

int set_ntfs_volume_flags(MFT_RECORD_HEADER *b, const __u16 flags)
{
	RESIDENT_ATTRIBUTE_RECORD_HEADER *r;
	VOLUME_INFORMATION *c;

	/* Sanity checks. */
	if (!b || !is_mft_recordp(b))
                return 0;
	/* Get a pointer to the volume information attribute. */
	if (!(r = (RESIDENT_ATTRIBUTE_RECORD_HEADER*)find_attribute(b,
						$VOLUME_INFORMATION, NULL))) {
		fprintf(stderr, "Error: Attribute $VOLUME_INFORMATION was " \
				"not found in $Volume!\n");
		return 0;
	}
	/* Sanity check. */
	if (r->attribute.non_resident) {
		fprintf(stderr, "Error: Attribute $VOLUME_INFORMATION must " \
				"be resident (and it isn't)!\n");
		return 0;
	}
	/* Get a pointer to the value of the attribute. */
	c = (VOLUME_INFORMATION*)(le16_to_cpu(r->value_offset) + (char*)r);
	/* Sanity checks. */
	if ((char*)c + le32_to_cpu(r->value_length) > 
				le16_to_cpu(b->bytes_in_use) + (char*)b ||
	    le16_to_cpu(r->value_offset) + le32_to_cpu(r->value_length) >
				le32_to_cpu(r->attribute.length)) {
		fprintf(stderr, "Error: Attribute $VOLUME_INFORMATION in " \
				"$Volume is corrupt!\n");
		return 0;
	}
	/* Set the volume flags. */
	c->flags = cpu_to_le16(flags);
	/* Success! */
	return 1;
}

__u64 get_attribute_value_length(const ATTRIBUTE_RECORD_HEADER *a)
{
	if (!a) {
		errno = EINVAL;
		return 0;
	}
	errno = 0;
	if (a->non_resident)
		return le64_to_cpu(((NONRESIDENT_ATTRIBUTE_RECORD_HEADER*)
							(a))->data_size);
	else
		return (__u64)le32_to_cpu(((RESIDENT_ATTRIBUTE_RECORD_HEADER*)
							(a))->value_length);
	errno = EINVAL;
	return 0;
}

__u64 get_attribute_value(const ntfs_volume *vol,
			  const ATTRIBUTE_RECORD_HEADER *a, __u8 *b)
{
	/* Sanity checks. */
	if (!vol || !a || !b) {
		errno = EINVAL;
		return 0;
	}
	/* Complex attribute? */
	if (a->flags) {
		puts("Enountered non-zero attribute flags. Cannot handle this "
		     "yet.");
		errno = ENOTSUP;
		return 0;
	}
	if (!a->non_resident) {		/* Attribute is resident. */
#define RA(a)	((RESIDENT_ATTRIBUTE_RECORD_HEADER*)(a))
		/* Sanity check. */
		if (le32_to_cpu(RA(a)->value_length) +
		    le16_to_cpu(RA(a)->value_offset) > le32_to_cpu(a->length)) {
			return 0;
		}
		memcpy(b, (char*)a + le16_to_cpu(RA(a)->value_offset),
			  		le32_to_cpu(RA(a)->value_length));
		errno = 0;
		return (__u64)le32_to_cpu(RA(a)->value_length);
#undef RA
	} else {			/* Attribute is not resident. */
#define NA(a)	((NONRESIDENT_ATTRIBUTE_RECORD_HEADER*)(a))
		run_list rl;
		__u64 total;
		int r, i;

		/* If no data, return 0. */
		if (!(NA(a)->data_size)) {
			errno = 0;
			return 0;
		}
		/* Decompress the mapping pairs array into a run list. */
		rl = decompress_run_list(NA(a));
		if (!rl) {
			errno = EINVAL;
			return 0;
		}
		/*
		 * FIXED: We were overflowing here in a nasty fashion when we
		 * reach the last cluster in the run list as the buffer will
		 * only be big enough to hold data_size bytes while we are 
		 * reading in allocated_size bytes which is usually larger
		 * than data_size, since the actual data is unlikely to have a
		 * size equal to a multiple of the cluster size!
		 */
		/* Now load all clusters in the run list into b. */
		for (i = 0, total = 0; rl[i].length; i++) {
			if (!rl[i+1].length) {
				unsigned char *intbuf = NULL;
				/*
				 * We have reached the last run so we were
				 * going to overflow when executing the
				 * ntfs_pread() which is BAAAAAAAD!
				 * Temporary fix:
				 * 	Allocate a new buffer with size:
				 * 	rl[i].length << vol->cluster_size_bits,
				 * 	do the read into our buffer, then
				 * 	memcpy the correct amount of data into
				 * 	the caller supplied buffer, free our
				 * 	buffer, and continue.
				 */
				intbuf = malloc(rl[i].length << 
							vol->cluster_size_bits);
				if (!intbuf) {
					int eo = errno;
					perror("Couldn't allocate memory for "
							"internal buffer.\n");
					errno = eo;
					return 0;
				}
				/*
				 * FIXME: If compressed file: Only read if 
				 * lcn != 0. Otherwise, we are dealing with a 
				 * sparse run and we just memset the user buffer
				 * to 0 for the length of the run, which should
				 * be 16 (= compression unit size). 
				 * FIXME: Really only when file is compressed,
				 * or can we have sparse runs in uncompressed
				 * files as well?
				 */
				r = ntfs_pread(vol->fd, intbuf,
					       vol->cluster_size, 
					       rl[i].length,
					       rl[i].lcn << 
							vol->cluster_size_bits);
				if (r != rl[i].length) {
#define ESTR "Error reading attribute value"
					if (r == -1) {
						int eo = errno;
						perror(ESTR);
						errno = eo;
					} else if (r < rl[i].length) {
						fprintf(stderr, ESTR ": Ran "
							"out of input data.\n");
						errno = EIO;
					} else {
			                        fprintf(stderr, ESTR ": "
							   "unknown error\n");
						errno = EIO;
					}
#undef ESTR
					return 0;
				}
				memcpy(b + total, intbuf, 
				       le64_to_cpu(NA(a)->data_size) - total);
				free(intbuf);
				total = le64_to_cpu(NA(a)->data_size);
			} else {
				/*
				 * FIXME: If compressed file: Only read if 
				 * lcn != 0. Otherwise, we are dealing with a 
				 * sparse run and we just memset the user buffer
				 * to 0 for the length of the run, which should
				 * be 16 (= compression unit size).
				 */
				r = ntfs_pread(vol->fd, b + total,
					       vol->cluster_size, 
					       rl[i].length,
					       rl[i].lcn <<
							vol->cluster_size_bits);
				if (r != rl[i].length) {
#define ESTR "Error reading attribute value"
					if (r == -1) {
						int eo = errno;
						perror(ESTR);
						errno = eo;
					} else if (r < rl[i].length) {
						fprintf(stderr, ESTR ": Ran "
							"out of input data.\n");
						errno = EIO;
					} else {
			                        fprintf(stderr, ESTR ": "
							   "unknown error\n");
						errno = EIO;
					}
#undef ESTR
					return 0;
				}
				total += r * vol->cluster_size;
			}
		}
		free(rl);
		return total;
#undef NA
	}
	errno = EINVAL;
	return 0;
}

int set_attribute_value(ntfs_volume *vol, ATTRIBUTE_RECORD_HEADER *a, 
			const __u8 *b, const __u64 l)
{
	/* Sanity check. */
	if (!vol || !a || !b) {
		errno = EINVAL;
		return 0;
	}
	/* FIXME: We can't deal with changes in attribute value length at the
	   moment. */
	if ((l != get_attribute_value_length(a)) || !l) {
		errno = ENOTSUP;
		return 0;
	}
	/* Complex attribute? */
	if (a->flags) {
		puts("Enountered non-zero attribute flags. Cannot handle this "
		     "yet.");
		errno = ENOTSUP;
		return 0;
	}
	if (!a->non_resident) {		/* Attribute is resident. */
#define RA(a)	((RESIDENT_ATTRIBUTE_RECORD_HEADER*)(a))
		/* Sanity check. */
		if (le32_to_cpu(RA(a)->value_length) +
		    le16_to_cpu(RA(a)->value_offset) > le32_to_cpu(a->length)) {
			errno = EINVAL;
			return 0;
		}
		memcpy((char*)a + le16_to_cpu(RA(a)->value_offset), b, l);
		errno = 0;
		return 1;
#undef RA
	} else {			/* Attribute is not resident. */
#define NA(a)	((NONRESIDENT_ATTRIBUTE_RECORD_HEADER*)(a))
		run_list rl;
		__u64 total;
		int w, i;
		
		/* If no data return 1. FIXME: This needs to change when we can
		   cope with changes in length of the attribute. */
		if (!(NA(a)->data_size)) {
			errno = 0;
			return 1;
		}
		/* Decompress the mapping pairs array into a run list. */
		rl = decompress_run_list(NA(a));
		/* Now write all clusters to disk from b. */
		for (i = 0, total = 0; rl[i].length && (l > 0); i++) {
			w = ntfs_pwrite(vol->fd, b + total,
				min(l, rl[i].length << vol->cluster_size_bits),
				rl[i].lcn << vol->cluster_size_bits);
			if (w != min(l, rl[i].length <<
						vol->cluster_size_bits)) {
#define ESTR "Error writing attribute value"
				if (w == -1) {
					int eo = errno;
					perror(ESTR);
					errno = eo;
				} else if (w < min(l, 
						rl[i].length << 
						vol->cluster_size_bits)) {
					fprintf(stderr, ESTR ": Ran out of "
							"input data.\n");
					errno = EIO;
				} else {
		                        fprintf(stderr, ESTR ": unknown "
							"error\n");
					errno = EIO;
				}
#undef ESTR
				return 0;
			}
			total += w;
			l -= w;
			if ((l <= 0) && rl[i+1].length) {
				fprintf(stderr, 
				       "Warning: Amount of data to write "
				       "doesn't match attribute length in\n"
				       "run list! - The old data that was "
				       "present beyond the new data written\n"
				       "has been preserved.\n");
			} else if ((l > 0) && !rl[i+1].length) {
				fprintf(stderr, 
				       "Warning: Still have data to write but "
				       "the attribute length in the run list\n"
				       "was exceeded! - Data written has been "
				       "truncated!\n");
			}
		}
		free(rl);	
		return 1;
#undef NA
	}
	errno = EINVAL;
	return 0;
}

run_list decompress_run_list(const NONRESIDENT_ATTRIBUTE_RECORD_HEADER *attr)
{
	__s64 vcn, lcn; 	/* Current vcn and lcn, respectively. */
	__s64 deltaxcn; 	/* Change in [vl]cn. */
	run_list rl = NULL;	/* The output run_list. */
	run_list rl2;		/* Temporary run_list. */
	__u8* buf;		/* Current position in mapping pairs array. */
	int rlsize;		/* Size of run_list buffer. */
	__u16 rlpos;		/* Current run_list positions in units
				   of run_list_elements. */
	__u8 b;			/* Current byte offset in buf. */

	/* Make sure attr exists and is non-resident. */
	if (!attr || !attr->attribute.non_resident)
		return NULL;
	/*
	 * Other fail safe checks are not required since the caller is
	 * assumed to have done alignment and other consistency checks.
	 * See find_attribute() above for an example.
	 */
	/* FIXME: Compression not supported yet. */
	if (attr->compression_unit) {
		puts("Encountered compressed non-resident attribute."
		     "Cannot handle this yet!");
		return NULL;
	}
	/* Start at vcn = lowest_vcn and lcn 0. */
	vcn = le64_to_cpu(attr->lowest_vcn);
	lcn = 0;
	/* Get start of the mapping pairs array. */
	buf = (__u8*)attr + le16_to_cpu(attr->mapping_pairs_offset);
	/* Current position in run_list array. */
	rlpos = 0;
	/* Current run_list buffer size in bytes. */
	rlsize = 0;
	while (*buf) {
		/* Allocate (more) memory if needed. */
		if (rlpos * (int)sizeof(run_list_element) >= 
				rlsize - (int)sizeof(run_list_element)) {
			rl2 = malloc(rlsize + 16 * sizeof(run_list_element));
			if (!rl2) {
				if (rl)
					free(rl);
				return NULL;
			}
			if (rl) {
				memmove(rl2, rl, rlsize);
				free(rl);
			}
			rl = rl2;
			rlsize += 16 * sizeof(run_list_element);
		}
		/* Enter the current vcn into the current run_list_element. */
		(rl + rlpos)->vcn = vcn;
		/* 
		 * Get the change in vcn, i.e. the run length in clusters.
		 * Doing it this way ensures that we signextend negative values.
		 * A negative run length doesn't make any sense, but hey, I
		 * didn't make up the NTFS specs and Windows NT4 treats the run
		 * length as a signed value so that's how it is...
		 */
		for (b = *buf & 0xf, deltaxcn = (__s8)buf[b--]; b; b--) {
			deltaxcn = (deltaxcn << 8) + buf[b];
		}
		/* Assume a negative length to indicate data corruption and
		   hence clean-up and return NULL. */
		if (deltaxcn < 0) {
			free(rl);
			return NULL;
		}
		/* Enter the current run length into the current 
		 * run_list_element. */
		(rl + rlpos)->length = deltaxcn;
		/* Increment the current vcn by the current run length. */
		vcn += deltaxcn;
		/* Get the lcn change which really can be negative. */
		for (b = (*buf & 0xf) + ((*buf >> 4) & 0xf), 
		     deltaxcn = (__s8)buf[b--]; b > (*buf & 0xf); b--) {
			deltaxcn = (deltaxcn << 8) + buf[b];
		}
		/* Change the current lcn to it's new value. */
		lcn += deltaxcn;
		/* Enter the current lcn into the current run_list_element. */
		(rl + rlpos)->lcn = lcn;
		/* Get to the next run_list_element. */
		rlpos++;
		/* Increment the buffer position to the next mapping pair. */
		buf += (*buf & 0xf) + ((*buf >> 4)  & 0xf) + 1;
	}
	/* If there were no mapping pairs in the run_list, then rl will still
	   be NULL. */
	if (rl)	{
		/* Adjust buffer size to minimum before returning. */
		rl2 = malloc((rlpos + 1) * sizeof(run_list_element));
		if (!rl2) {
			if (rl)
				free(rl);
			return NULL;
		}
		memmove(rl2, rl, (rlpos + 1) * sizeof(run_list_element));
		free(rl);
		rl = rl2;
		/* Setup terminating run_list_element. */
		(rl + rlpos)->vcn = vcn;
		(rl + rlpos)->length = 0;
		/*
		 * This is not necessary, but do it for completeness sake.
		 * FIXME: Do we really want this zero? Zero means it is sparse,
		 * but I guess better zero than an undefined random value...
		 */
		(rl + rlpos)->lcn = 0;
		/* The final vcn - 1 has to be equal to highest_vcn or
		   something has gone badly wrong. */
		if (vcn - 1 != le64_to_cpu(attr->highest_vcn)) {
			free(rl);
			puts("Corrupt Mapping Pairs Array in non-resident "
			     "attribute!");
			return NULL;
		}
	}
#ifdef DEBUG
	if (rl) {
		int i;
		
		puts("\nMapping Pairs array successfully decompressed.");
		puts("Resulting run list (values in hexadecimal):");
		puts("VCN              LCN              Run length");
		for (i = 0; ; i++) {
			printf("%-16Lx %-16Lx %-16Lx\n", (rl + i)->vcn,
			     				 (rl + i)->lcn,
			     				 (rl + i)->length);
			if (!(rl + i)->length)
				break;
		}
	}
#endif
	/* Finally finished! */
	return rl;
}

__s64 vcn_to_lcn(const run_list rl, const __s64 vcn)
{
	int i = 0;
	
	if (!rl || vcn < 0)
		return -EINVAL;
	if (!rl[0].length || vcn < rl[0].vcn)
		return -ENOENT;
	do {
		if (vcn < rl[++i].vcn)
			return rl[i-1].lcn + (vcn - rl[i-1].vcn);
	} while (rl[i].length);
	return -ENOENT;
}

[Linux-ntfs-cvs] CVS: linux-ntfs/include attrib.h,1.4,1.5

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv8700/include

Modified Files:
	attrib.h 
Log Message:
Added in the current state of attribute handling to libntfs.
Now just missing the make files to make a first public release of ntfsfix!



Index: attrib.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/attrib.h,v
retrieving revision 1.4
retrieving revision 1.5
diff -C2 -r1.4 -r1.5
*** attrib.h	2001/01/28 05:49:57	1.4
--- attrib.h	2001/01/30 00:13:11	1.5
***************
*** 254,258 ****
   * present only if the file has been accessed since the upgrade. Recognize
   * the difference by comparing the length of the resident attribute value. If
!  * it is 48, then the following fields are missing. If it is 72 then the fields
   * are present. Maybe just check like this:
   * 	if (resident.ValueLength < sizeof(STANDARD_INFORMATION)) {
--- 254,258 ----
   * present only if the file has been accessed since the upgrade. Recognize
   * the difference by comparing the length of the resident attribute value. If
! * * it is 48, then the following fields are missing. If it is 72 then the fields
   * are present. Maybe just check like this:
   * 	if (resident.ValueLength < sizeof(STANDARD_INFORMATION)) {
***************
*** 781,838 ****
  /* FIXME: Should this be a linked list so it is easier/quicker to edit? */
  
! /*
   * Allocate a run_list array and decompress the run-list of the non-resident
!  * attribute attr into the run_list array.
   * Return a pointer to the run_list array or NULL on error.
   * Notes: caller has to free the run_list array when finished.
   */
! run_list decompress_run_list(NONRESIDENT_ATTRIBUTE_RECORD_HEADER *attr);
  
! /*
!  * Determine the logical cluster number given the virtual cluster number and
!  * the run list describing the mapping between the LCNs and VCNs. 
   * Return -ERRNO on error (ERRNO being the error number) and notably -NOENT 
   * if vcn is outside the boundaries covered by the run list.
   */
! __s64 vcn_to_lcn(run_list rl, __s64 vcn);
  
! /*
!  * Set the volume flags in the Mft record b to flags.
   * Return 1 on success or 0 on error.
   */
! int set_ntfs_volume_flags(MFT_RECORD_HEADER *b, __u16 flags);
  
! /*
!  * Get the location of the desired attribute of type t and name n (n can be
!  * NULL for unnamed attributes; note that n is a Unicode string). Return a
   * pointer to the attribute or NULL if the attribute is not present or an
   * error situation exists.
!  */
! ATTRIBUTE_RECORD_HEADER *find_attribute(MFT_RECORD_HEADER *b, ATTRIBUTE_TYPE t,
! 							      wchar_t *n);
  
  #include "volume.h"
  
! /*
!  * Return the byte size of the attribute value (as it would be after eventual
!  * decompression and filling in of holes if sparse.
   * If we return 0, check errno. If errno is 0 the actual length was 0, 
   * otherwise errno describes the error.
   */
! __u64 get_attribute_value_length(ATTRIBUTE_RECORD_HEADER *a);
  
! /*
!  * Make a copy of the attribute value of the attribute a into the destination
!  * buffer b. Note that the size of b has to be at least equal to the value
!  * returned by get_attribute_value_length(a).
   * Return number of bytes copied. If this is zero check errno. If errno is 0
   * then nothing was read due to a zero-length attribute value, otherwise
   * errno describes the error.
   */
! __u64 get_attribute_value(ntfs_volume *vol, ATTRIBUTE_RECORD_HEADER *a, __u8 *b);
  
! /*
!  * Set the value of the attribute a to the contents of the buffer b which has
!  * a byte-size of l and write it to the NTFS volume vol. 
   * Return 1 on success and 0 on error, errno will be set in the latter case.
   *
--- 781,896 ----
  /* FIXME: Should this be a linked list so it is easier/quicker to edit? */
  
! /**
!  * decompress_run_list - decompress a mapping pairs array into a run list
!  * @attr:	non-resident attribute whose mapping pairs array to decompress
!  * 
   * Allocate a run_list array and decompress the run-list of the non-resident
!  * attribute @attr into the run_list array.
!  * 
   * Return a pointer to the run_list array or NULL on error.
   * Notes: caller has to free the run_list array when finished.
   */
! run_list decompress_run_list(const NONRESIDENT_ATTRIBUTE_RECORD_HEADER *attr);
  
! /**
!  * vcn_to_lcn - determine the lcn corresponding to a particular vcn
!  * @rl:		decompressed mapping pairs array (i.e. run list)
!  * @vcn:	virtucal cluster number to determine the lcn for
!  *
!  * Determine the logical cluster number given the virtual cluster number @vcn
!  * and the run list @rl describing the mapping between the LCNs and VCNs. 
   * Return -ERRNO on error (ERRNO being the error number) and notably -NOENT 
   * if vcn is outside the boundaries covered by the run list.
   */
! __s64 vcn_to_lcn(const run_list rl, const __s64 vcn);
  
! /**
!  * set_ntfs_volume_flags - set the flags of an ntfs volume
!  * @b:		pointer to a buffer containing the mft record of FILE_$Volume
!  * @flags:	new flags
!  * 
!  * Set the volume flags in the mft record buffer @b to @flags.
   * Return 1 on success or 0 on error.
   */
! int set_ntfs_volume_flags(MFT_RECORD_HEADER *b, const __u16 flags);
  
! /**
!  * find_attribute - find an attribute in an mft record
!  * @b:		pointer to a buffer containing the mft record to search
!  * @t:		find attribute of this type
!  * @n:		find attribute of this name
!  *  
!  * Get the location of the desired attribute of type @t and name @n (@n can be
!  * NULL for unnamed attributes; note that @n is a Unicode string). Return a
   * pointer to the attribute or NULL if the attribute is not present or an
   * error situation exists.
!  *
!  * FIXME: There can be several attributes which have the same type and name.
!  * Example: file name attribute. There will be several file name attributes
!  * (e.g. one each for DOS and Win32 namespaces) which will both have the same
!  * attribute type and the same attribute name (i.e. they are both unnamed) but
!  * they will have different attribute values and in particular the file names
!  * will be different.
!  * So we need at least one more search key or a find_next_attribute() function
!  * but that could get ugly as we need to save the context of the search (maybe
!  * in user supplied "context buffer"? Or pass the result of find_attribute()
!  * into find_next_attribute()?). The third search key could be the attribute
!  * value itself or it could be dependent on the attribute type we are looking
!  * for. For example for file name attributes it could be the name of the file.
!  * FIXME: No it could not, as you can have the same file name appearing twice
!  * if there are two hard links to the file with the same name but in different
!  * directories. Ugh! Searching using attribute values is crazy as it would be
!  * too slow or even impossible to generate the value to be used for in the
!  * search. However we can do a find_next_attribute() function easily. In fact
!  * we can also have a find_first_attribute/find_next_attribute combination in
!  * general so we can enumerate all attributes in sequence. The context buffer
!  * could be just the offset in the mft record of the next attribute or of the
!  * last attribute that was returned by the function.
!  */
! ATTRIBUTE_RECORD_HEADER *find_attribute(const MFT_RECORD_HEADER *b,
! 					const ATTRIBUTE_TYPE t,
! 					const wchar_t *n);
  
  #include "volume.h"
  
! /**
!  * get_attribute_value_length - return the length of the value of an attribute
!  * @a:	pointer to a buffer containing the attribute record
!  *
!  * Return the byte size of the attribute value of the attribute @a (as it
!  * would be after eventual decompression and filling in of holes if sparse).
   * If we return 0, check errno. If errno is 0 the actual length was 0, 
   * otherwise errno describes the error.
+  *
+  * FIXME: Describe possible errnos.
   */
! __u64 get_attribute_value_length(const ATTRIBUTE_RECORD_HEADER *a);
  
! /**
!  * get_attribute_value - return the attribute value of an attribute
!  * @vol:	volume on which the attribute is present
!  * @a:		attribute to get the value of
!  * @b:		destination buffer for the attribute value
!  * 
!  * Make a copy of the attribute value of the attribute @a into the destination
!  * buffer @b. Note, that the size of @b has to be at least equal to the value
!  * returned by get_attribute_value_length(@a).
!  *
   * Return number of bytes copied. If this is zero check errno. If errno is 0
   * then nothing was read due to a zero-length attribute value, otherwise
   * errno describes the error.
   */
! __u64 get_attribute_value(const ntfs_volume *vol,
! 			  const ATTRIBUTE_RECORD_HEADER *a, __u8 *b);
  
! /**
!  * set_attribute_value - set the attribute value of an attribute
!  * @vol:	volume on which the attribute is present
!  * @a:		attribute to set the value of
!  * @b:		buffer containing the new attribute value
!  * @l:		length in bytes of the new attribute value @b
!  *
!  * Set the value of the attribute @a to the contents of the buffer @b which has
!  * a byte-size of @l and write it to the NTFS volume @vol. 
   * Return 1 on success and 0 on error, errno will be set in the latter case.
   *
***************
*** 840,848 ****
   * changes in the length of the resident part of the attribute which in turn
   * means it doesn't cope with changes in length or on disk location of the
!  * non-resident part of the attribute either! See ntfsfix.c for details.
   */
! int set_attribute_value(ntfs_volume *vol, ATTRIBUTE_RECORD_HEADER *a, 
! 						    unsigned char *b, __u64 l);
! 
  
  #endif /* defined ATTRIB_H */
--- 898,907 ----
   * changes in the length of the resident part of the attribute which in turn
   * means it doesn't cope with changes in length or on disk location of the
!  * non-resident part of the attribute either! See ../ntfstools/ntfsfix.c for
!  * details.
!  * FIXME: Document possible errnos.
   */
! int set_attribute_value(ntfs_volume *vol, ATTRIBUTE_RECORD_HEADER *a,
! 			const __u8 *b, const __u64 l);
  
  #endif /* defined ATTRIB_H */

[Linux-ntfs-cvs] CVS: linux-ntfs/include attrib.h,1.3,1.4 mft.h,1.2,1.3 ntfs_rec.h,1.1,1.2

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv28090/include

Modified Files:
	attrib.h mft.h ntfs_rec.h 
Log Message:
More header development. AttrDef description.


Index: attrib.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/attrib.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -r1.3 -r1.4
*** attrib.h	2001/01/27 14:22:02	1.3
--- attrib.h	2001/01/28 05:49:57	1.4
***************
*** 27,30 ****
--- 27,49 ----
  
  /*
+  * The data attribute of FILE_$AttrDef contains a sequence of attribute
+  * definitions for the NTFS volume. With this, it is supposed to be safe for an
+  * older NTFS driver to mount a volume containing a newer NTFS version without
+  * damaging it (that's the theory. In practice it's: not damaging it too much).
+  * The flags describe whether the attribute can be resident/non-resident and
+  * possibly other things, too but the actual bits are unknown.
+  */
+ typedef struct {
+ /*hex ofs*/
+ /*  0*/	__u16 name[64];		/* Name of the attribute. */
+ /* 80*/	__u32 type;		/* Type of the attribute. */
+ /* 84*/	__u32 unknown[2];	/* ??? */
+ /* 8c*/	__u32 flags;		/* ??? */
+ /* 90*/	__u64 min_size;		/* Minimum size of attribute. */
+ /* 98*/	__u64 max_size;		/* Maximum size of attribute. */
+ /* sizeof() = 0xa0 or 160 bytes */
+ } __attribute__ ((__packed__)) ATTRIBUTE_DEFINITION;
+ 
+ /*
   * System defined attributes (32-bit).
   */
***************
*** 52,83 ****
  
  /*
-  * System file numbers. All these files are always marked as used in the $Mft
-  * bitmap attribute, presumably in order to avoid accidental allocation for
-  * random other mft records.
-  */
- typedef enum {
-         FILE_$Mft       = 0,	/* Master file table (mft). */
-         FILE_$MftMirr   = 1,	/* Mft mirror (copy of first 4 mft records). */
-         FILE_$LogFile   = 2,	/* Journalling log. */
-         FILE_$Volume    = 3,	/* Volume name, flags and ntfs version. */
-         FILE_$AttrDef   = 4,	/* Attribute definitions. */
-         FILE_$root      = 5,	/* Root directory. */
-         FILE_$BitMap    = 6,	/* Allocation map of all clusters. */
-         FILE_$Boot      = 7,	/* Boot sector (always at cluster 0). */
-         FILE_$BadClus   = 8,	/* Contains all bad clusters. */
-         FILE_$Secure    = 9,	/* Shared security descriptors. */
-         FILE_$UpCase    = 10,	/* Upcase table for all 65536 Unicode chars. */
-         FILE_$Extend    = 11,	/* Directory containing other system files (eg.
- 				   $ObjId, $Quota, $Reparse and $UsnJrnl). This
- 				   is new to NTFS3.0. */
-         FILE_reserved12 = 12,	/* Reserved for future use (records 12-15). */
-         FILE_reserved13 = 13,
-         FILE_reserved14 = 14,
-         FILE_reserved15 = 15,
- 	FILE_first_user = 16,	/* First user file, used as test limit for
- 				   whether to allow opening a file or not. */
- } NTFS_SYSTEM_FILES;
- 
- /*
   * Attribute flags (16-bit). 
   */
--- 71,74 ----
***************
*** 85,89 ****
  	ATTRIBUTE_IS_COMPRESSED	   = cpu_to_le16(0x0001),
  	ATTRIBUTE_COMPRESSION_MASK = cpu_to_le16(0x00ff),  /* Compression method
! 							    * mask. First
  							    * illegal value. */
  	ATTRIBUTE_IS_ENCRYPTED	   = cpu_to_le16(0x4000),
--- 76,80 ----
  	ATTRIBUTE_IS_COMPRESSED	   = cpu_to_le16(0x0001),
  	ATTRIBUTE_COMPRESSION_MASK = cpu_to_le16(0x00ff),  /* Compression method
! 							    * mask. Also, first
  							    * illegal value. */
  	ATTRIBUTE_IS_ENCRYPTED	   = cpu_to_le16(0x4000),
***************
*** 96,100 ****
  typedef struct {
  /*Ofs*/
! /*  0*/	ATTRIBUTE_TYPE type;	/* The (4-byte) type of the attribute. */
  /*  4*/	__u32 length;		/* Byte size of the resident part of the
  				   attribute (aligned to 8-byte boundary). */
--- 87,91 ----
  typedef struct {
  /*Ofs*/
! /*  0*/	ATTRIBUTE_TYPE type;	/* The (32-bit) type of the attribute. */
  /*  4*/	__u32 length;		/* Byte size of the resident part of the
  				   attribute (aligned to 8-byte boundary). */
***************
*** 107,111 ****
  				   record. Note that the name is stored as a
  				   Unicode string. */
! /* 12*/	ATTRIBUTE_FLAGS flags;	/* Bit array of ATTRIBUTE_* flags (16-bit). */
  /* 14*/	__u16 instance;		/* The instance of this attribute record. This
  				   number is unique within this mft record (see 
--- 98,102 ----
  				   record. Note that the name is stored as a
  				   Unicode string. */
! /* 12*/	ATTRIBUTE_FLAGS flags;	/* Flags describing the attribute. */
  /* 14*/	__u16 instance;		/* The instance of this attribute record. This
  				   number is unique within this mft record (see 
***************
*** 121,125 ****
  	RESIDENT_ATTRIBUTE_IS_INDEXED	= 0x01,	/* Attribute is referenced in
  						   an index somewhere (has
! 						   implications for deleting
  						   modifying the attribute). */
  } __attribute__ ((__packed__)) RESIDENT_ATTRIBUTE_FLAGS;
--- 112,116 ----
  	RESIDENT_ATTRIBUTE_IS_INDEXED	= 0x01,	/* Attribute is referenced in
  						   an index somewhere (has
! 						   implications for deleting or
  						   modifying the attribute). */
  } __attribute__ ((__packed__)) RESIDENT_ATTRIBUTE_FLAGS;
***************
*** 147,154 ****
  /* 16*/	__u64 lowest_vcn;	/* Lowest valid virtual cluster number (vcn)
  				   for this portion of the attribute value or
! 				   0 if this is the only portion (usually the
  				   case. - Only when an attribute list is used
  				   does lowest_vcn != 0 ever occur. */
! /* 24*/	__u64 highest_vcn;	/* Highest valid vcn of this portion of the
  				   attribute value. - Usually there is only one
  				   portion, so this usually equals the attribute
--- 138,145 ----
  /* 16*/	__u64 lowest_vcn;	/* Lowest valid virtual cluster number (vcn)
  				   for this portion of the attribute value or
! 				   0 if this is the only extent (usually the
  				   case. - Only when an attribute list is used
  				   does lowest_vcn != 0 ever occur. */
! /* 24*/	__u64 highest_vcn;	/* Highest valid vcn of this extent of the
  				   attribute value. - Usually there is only one
  				   portion, so this usually equals the attribute
***************
*** 238,249 ****
   * NOTE: Always resident.
   * NOTE: Present in all base file records on a volume.
   */
  typedef struct {
  /*Ofs*/
! /*  0*/	__u64 creation_time;		/* When the file was created. */
! /*  8*/	__u64 last_modification_time;	/* Time of last change of data
! 					   attribute. */
! /* 16*/	__u64 last_change_time;		/* Time of last change of this mft
! 					   record. */
  /* 24*/	__u64 last_access_time;		/* Approximate time when the file was
  					   last accessed (obviously this is not
--- 229,245 ----
   * NOTE: Always resident.
   * NOTE: Present in all base file records on a volume.
+  * NOTE: There is conflicting information about the meaning of each of the time
+  * 	 fields but the meaning as defined below has been verified to be
+  * 	 correct by practical experimentation on Windows NT4 SP6a and is hence
+  * 	 assumed to be the one and only correct interpretation.
   */
  typedef struct {
  /*Ofs*/
! /*  0*/	__u64 creation_time;		/* Time file was created. Updated when
! 					   a filename is changed(?). */
! /*  8*/	__u64 last_data_change_time;	/* Time the data attribute was last
! 					   modified. */
! /* 16*/	__u64 last_mft_change_time;	/* Time this mft record was last
! 					   modified. */
  /* 24*/	__u64 last_access_time;		/* Approximate time when the file was
  					   last accessed (obviously this is not
***************
*** 310,327 ****
   * Attribute: Attribute list (0x20).
   *
!  * The value of the attribute list attribute consists of a sequence of
!  * variable length, 64-bit aligned ATTRIBUTE_LIST_ENTRY records. The value
!  * can be either resident or non-resident.
!  * The attribute list attribute contains one entry for each attribute of the
!  * file in which the list is located, except for the list attribute itself.
!  * The list is sorted first by: attribute type, then by attribute name (if 
!  * present) and third by attribute value. In the third case the attribute
!  * value of the referenced attribute is required to be resident. Also, it is
!  * not allowed to have two attributes with all three sorting keys equal.
!  * Further restrictions: 
   * 	- If not resident, the vcn to lcn mapping array has to fit inside the
   * 	  base mft record.
   * 	- The attribute list attribute value has a maximum size of 256kb. This
   * 	  is imposed by the Windows cache manager.
   */
  typedef struct {
--- 306,335 ----
   * Attribute: Attribute list (0x20).
   *
!  * NOTE: Can be either resident or non-resident.
!  * NOTE: Value consists of a sequence of variable length, 8-byte aligned,
!  * 	 ATTRIBUTE_LIST_ENTRY records.
!  * NOTE: The attribute list attribute contains one entry for each attribute of
!  *	 the file in which the list is located, except for the list attribute
!  *	 itself. The list is sorted: first by attribute type, then by attribute
!  *	 name (if present) and third by attribute value. In the third case the
!  *	 attribute value of the referenced attribute is required to be
!  *	 resident. Also, it is not allowed to have two attributes with all
!  *	 three sorting keys equal.
!  * NOTE: Further restrictions: 
   * 	- If not resident, the vcn to lcn mapping array has to fit inside the
   * 	  base mft record.
   * 	- The attribute list attribute value has a maximum size of 256kb. This
   * 	  is imposed by the Windows cache manager.
+  * NOTE: Attribute lists are only used when the attributes of mft record do not
+  * 	 fit inside the mft record despite all attributes (that can be made
+  * 	 non-resident) having been made non-resident. This can happen e.g. when:
+  * 	 	- File has a large number of hard links (lots of file name
+  * 	 	  attributes present).
+  * 	 	- The mapping pairs array of some non-resident attribute
+  * 	 	  becomes so large due to fragmentation that it overflows the
+  * 	 	  mft record.
+  * 	 	- The security descriptor is very complex (not applicable to
+  * 	 	  NTFS 3.0 volumes).
+  * 	 	- There are many named streams.
   */
  typedef struct {
***************
*** 367,374 ****
  
  /*
!  * Possible namespaces for filenames in ntfs.
   */
  typedef enum {
! 	FILENAME_POSIX			= cpu_to_le16(0x0000),
  		/* This is the largest namespace. It is case sensitive and 
  		   allows all Unicode characters except for: '\0' and '/'.
--- 375,382 ----
  
  /*
!  * Possible namespaces for filenames in ntfs (8-bit).
   */
  typedef enum {
! 	FILENAME_POSIX			= 0x00,
  		/* This is the largest namespace. It is case sensitive and 
  		   allows all Unicode characters except for: '\0' and '/'.
***************
*** 377,396 ****
  		   standard utilities and thus a "del filename" will delete
  		   both "filename" and "fileName" without warning. */
! 	FILENAME_WIN32			= cpu_to_le16(0x0001),
  		/* The standard WinNT/2k NTFS long filenames. Case insensitive.
  		   All Unicode chars except: '\0', '"', '*', '/', ':', '<', 
  		   '>', '?', '\' and '|'. Further, names cannot end with a '.'
  		   or a space. */
! 	FILENAME_DOS			= cpu_to_le16(0x0002),
  		/* The standard DOS filenames (8.3 format). Uppercase only.
  		   All 8-bit characters greater space, except: '"', '*', '+',
  		   ',', '/', ':', ';', '<', '=', '>', '?' and '\'. */
! 	FILENAME_WIN32_AND_DOS		= cpu_to_le16(0x0003), 
  		/* 3 means that both the Win32 and the DOS filenames are
  		   identical and hence have been saved in this single filename
  		   record. */
- 	SIZE_INDICATOR_FOR_ATTRIBUTE_PACKED = 0xffff;
- 		/* This is not defined by ntfs but we need it to tell gcc
- 		   to make this enum type 16-bit. */
  } __attribute__ ((__packed__)) FILENAME_TYPE_FLAGS;
  
--- 385,401 ----
  		   standard utilities and thus a "del filename" will delete
  		   both "filename" and "fileName" without warning. */
! 	FILENAME_WIN32			= 0x01,
  		/* The standard WinNT/2k NTFS long filenames. Case insensitive.
  		   All Unicode chars except: '\0', '"', '*', '/', ':', '<', 
  		   '>', '?', '\' and '|'. Further, names cannot end with a '.'
  		   or a space. */
! 	FILENAME_DOS			= 0x02,
  		/* The standard DOS filenames (8.3 format). Uppercase only.
  		   All 8-bit characters greater space, except: '"', '*', '+',
  		   ',', '/', ':', ';', '<', '=', '>', '?' and '\'. */
! 	FILENAME_WIN32_AND_DOS		= 0x03, 
  		/* 3 means that both the Win32 and the DOS filenames are
  		   identical and hence have been saved in this single filename
  		   record. */
  } __attribute__ ((__packed__)) FILENAME_TYPE_FLAGS;
  
***************
*** 399,402 ****
--- 404,415 ----
   *
   * NOTE: Always resident.
+  * NOTE: All fields, except the parent_directory_mft_reference are only updated
+  *	 when the filename is changed. Until then, they just become out of sync
+  *	 with reality and the more up to date values are present in the
+  *	 standard information attribute.
+  * NOTE: There is conflicting information about the meaning of each of the time
+  * 	 fields but the meaning as defined below has been verified to be
+  * 	 correct by practical experimentation on Windows NT4 SP6a and is hence
+  * 	 assumed to be the one and only correct interpretation.
   */
  typedef struct {
***************
*** 404,415 ****
  						   referenced from. */
  	__u64 creation_time;			/* Time file was created. */
! 	__u64 last_modification_time;		/* Time data attribute was
  						   last modified. */
! 	__u64 last_change_time;			/* Time mft record was
! 						   modified. */
! 	__u64 last_access_time;			/* Last time mft record was
! 						   accessed. See notes for this
! 						   in attribute standard
! 						   information above. */
  	__u64 allocated_size;			/* Byte size of allocated space
  					           for the data attribute.
--- 417,426 ----
  						   referenced from. */
  	__u64 creation_time;			/* Time file was created. */
! 	__u64 last_data_change_time;		/* Time the data attribute was
! 						   last modified. */
! 	__u64 last_mft_change_time;		/* Time this mft record was
  						   last modified. */
! 	__u64 last_access_time;			/* Last time this mft record
! 						   was accessed. */
  	__u64 allocated_size;			/* Byte size of allocated space
  					           for the data attribute.
***************
*** 420,424 ****
  						   NOTE: Only present when
  						   lowest_vcn is 0. */
! 	FILE_ATTRIBUTE_FLAGS file_attributes;	/* Flags describing the file.*/
  	union {
  		struct {
--- 431,435 ----
  						   NOTE: Only present when
  						   lowest_vcn is 0. */
! 	FILE_ATTRIBUTE_FLAGS file_attributes;	/* Flags describing the file. */
  	union {
  		struct {
***************
*** 434,440 ****
  	} __attribute__ ((__packed__));
  	__u8 filename_length;			/* Length of filename in
! 						   Unicode characters. */
! 	__u8 filename_type;			/* Bit field of FILENAME_TYPE_*
! 						   flags. */
  	__u16 filename[filename_length];	/* Filename in Unicode. */
  } __attribute__ ((__packed__)) FILENAME_ATTRIBUTE;
--- 445,450 ----
  	} __attribute__ ((__packed__));
  	__u8 filename_length;			/* Length of filename in
! 						   (Unicode) characters. */
! 	FILENAME_TYPE_FLAGS filename_type;	/* Namespace of the filename. */
  	__u16 filename[filename_length];	/* Filename in Unicode. */
  } __attribute__ ((__packed__)) FILENAME_ATTRIBUTE;

Index: mft.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/mft.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -r1.2 -r1.3
*** mft.h	2001/01/27 14:22:02	1.2
--- mft.h	2001/01/28 05:49:57	1.3
***************
*** 30,33 ****
--- 30,73 ----
  
  /*
+  * System file numbers. All these files are always marked as used in the bitmap
+  * attribute of the mft; presumably in order to avoid accidental allocation for
+  * random other mft records.
+  */
+ typedef enum {
+         FILE_$Mft       = 0,	/* Master file table (mft). Data attribute
+ 				   contains the entries and bitmap attribute
+ 				   records which ones are in use (bit==1). */
+         FILE_$MftMirr   = 1,	/* Mft mirror (copy of first four mft records)
+ 				   in data attribute. */
+         FILE_$LogFile   = 2,	/* Journalling log in data attribute. */
+         FILE_$Volume    = 3,	/* Volume name attribute and volume information
+ 				    attribute (flags and ntfs version). */
+         FILE_$AttrDef   = 4,	/* Array of attribute definitions in data
+ 				   attribute. */
+         FILE_$root      = 5,	/* Root directory. */
+         FILE_$BitMap    = 6,	/* Allocation bitmap of all clusters in bitmap
+ 				   attribute. */
+         FILE_$Boot      = 7,	/* Boot sector (always at cluster 0) in data
+ 				   attribute. */
+         FILE_$BadClus   = 8,	/* Contains all bad clusters in the non-resident
+ 				   data attribute. */
+         FILE_$Secure    = 9,	/* Shared security descriptors in data attribute
+ 				   and two indexes into the descriptors.
+ 				   Appeared in Windows NT4 SP4 (I think). */
+         FILE_$UpCase    = 10,	/* Uppercase equivalents of all 65536 Unicode
+ 				   characters in data attribute. */
+         FILE_$Extend    = 11,	/* Directory containing other system files (eg.
+ 				   $ObjId, $Quota, $Reparse and $UsnJrnl). This
+ 				   is new to NTFS3.0. */
+         FILE_reserved12 = 12,	/* Reserved for future use (records 12-15). */
+         FILE_reserved13 = 13,
+         FILE_reserved14 = 14,
+         FILE_reserved15 = 15,
+ 	FILE_first_user = 16,	/* First user file, used as test limit for
+ 				   whether to allow opening a file or not. */
+ } NTFS_SYSTEM_FILES;
+ 
+ 
+ /*
   * These are the so far known MFT_RECORD_* flags which contain information
   * about the mft record in which they are present.
***************
*** 42,47 ****
   * used whenever a structure needs to refer to a record in the mft.
   * 
!  * A reference consists of the 48-bit index into the mft and the 16-bit
!  * sequence number used to detect stale references.
   *
   * The sequence number is a circular counter (skipping 0) describing how many
--- 82,87 ----
   * used whenever a structure needs to refer to a record in the mft.
   * 
!  * A reference consists of a 48-bit index into the mft and a 16-bit sequence
!  * number used to detect stale references.
   *
   * The sequence number is a circular counter (skipping 0) describing how many
***************
*** 56,61 ****
   * for high_part being 0 and if not either BUG(), cause a panic() or handle
   * the situation in some other way. This shouldn't be a problem as a volume has
!  * to become HUGE in order to need more than 32 bits worth of mft records.
!  * Assuming the standard mft records size of 1kb only the records (never mind
   * the non-resident attributes, etc.) would require 4Tb of space on their own
   * for the first 32 bits worth of records. This is only if some strange person
--- 96,101 ----
   * for high_part being 0 and if not either BUG(), cause a panic() or handle
   * the situation in some other way. This shouldn't be a problem as a volume has
!  * to become HUGE in order to need more than 32-bits worth of mft records.
!  * Assuming the standard mft record size of 1kb only the records (never mind
   * the non-resident attributes, etc.) would require 4Tb of space on their own
   * for the first 32 bits worth of records. This is only if some strange person
***************
*** 65,82 ****
   */
  typedef union {
!     struct {
! 	struct {		
! 		__u32 low_part;	/* Mft record number being referenced split */
! 		__u16 high_part;/* into the low 32-bits and the high 16-bits. */
  	} __attribute__ ((__packed__));
! 	__u16 sequence_number;	/* The sequence number, see above. */
!     } __attribute__ ((__packed__));
!     __u64 mft_reference;	/* The whole mft reference as one number. */
  } __attribute__ ((__packed__)) MFT_REFERENCE;
  
! /* The mft record header present at the beginning of every record in the mft. */
  typedef struct {
  /*Ofs*/
! /*  0*/	NTFS_RECORD_HEADER ntfs;
  /*  8*/	__s64 lsn;		/* Log file sequence number for this record. */
  /* 16*/	__u16 sequence_number;	/* Number of times this mft record has been
--- 105,131 ----
   */
  typedef union {
! 	/* We have a union so that we can either use the reference as one
! 	   64-bit number or as the individual parts (i.e. the mft index and the
! 	   sequence number) broken up using a structure. Since there is no
! 	   48-bit data type we need to use another struct dividing the mft
! 	   index into the low 32-bits and the high 16-bits. */
! 	struct {
! 		struct {
! 			__u32 low_part;		/* Low 32-bits of mft index. */
! 			__u16 high_part;	/* High 32-bits of mft index. */
! 		} __attribute__ ((__packed__));
! 		__u16 sequence_number;		/* 16-bit sequence number. */
  	} __attribute__ ((__packed__));
! 
! 	__u64 mft_reference;			/* Mft reference as one value.*/
  } __attribute__ ((__packed__)) MFT_REFERENCE;
  
! /*
!  * The mft record header present at the beginning of every record in the mft.
!  * This is followed by a sequence of variable length attribute records.
!  */
  typedef struct {
  /*Ofs*/
! /*  0*/	NTFS_RECORD_HEADER ntfs;/* Usually the magic is "FILE". */
  /*  8*/	__s64 lsn;		/* Log file sequence number for this record. */
  /* 16*/	__u16 sequence_number;	/* Number of times this mft record has been
***************
*** 110,114 ****
  				   belongs (this is then used to locate the
  				   attribute list attribute present in the base
! 				   record which describes the extension record
  				   and hence might need modification when the
  				   extension record itself is modified). */
--- 159,163 ----
  				   belongs (this is then used to locate the
  				   attribute list attribute present in the base
! 				   record which describes this extension record
  				   and hence might need modification when the
  				   extension record itself is modified). */

Index: ntfs_rec.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/ntfs_rec.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** ntfs_rec.h	2001/01/24 02:13:24	1.1
--- ntfs_rec.h	2001/01/28 05:49:57	1.2
***************
*** 28,32 ****
  /*
   * Magic identifiers present at the beginning of all ntfs record containing
!  * records (like mft records for example.
   */
  typedef enum {
--- 28,32 ----
  /*
   * Magic identifiers present at the beginning of all ntfs record containing
!  * records (like mft records for example).
   */
  typedef enum {
***************
*** 71,76 ****
   * this array is contained. Note that the first entry is the Update Sequence
   * Number (usn), a cyclic counter of how many times the protected record has
!  * been written to disk. (The values 0 and -1 (ie. 0xffff) are not used.) All
!  * last __u16's of each sector have to be equal to the Usn (during reading) or
   * are set to it (during writing). If they are not, an incomplete multi sector
   * transfer has occured when the data was written.
--- 71,76 ----
   * this array is contained. Note that the first entry is the Update Sequence
   * Number (usn), a cyclic counter of how many times the protected record has
!  * been written to disk. The values 0 and -1 (ie. 0xffff) are not used. All
!  * last __u16's of each sector have to be equal to the usn (during reading) or
   * are set to it (during writing). If they are not, an incomplete multi sector
   * transfer has occured when the data was written.

[Linux-ntfs-cvs] CVS: linux-ntfs/doc attribute_definitions,NONE,1.1 tunable_settings,NONE,1.1

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/doc
In directory usw-pr-cvs1:/tmp/cvs-serv28090/doc

Added Files:
	attribute_definitions tunable_settings 
Log Message:
More header development. AttrDef description.


--- NEW FILE ---
/* All values are as in Windows NT4 SP6a. */

__u16 name[64]		= "$STANDARD_INFORMATION"
__u32 type		= 0x10
__u32 unknown[2]	= 0, 0
__u32 flags		= 0x40
__u64 min_size		= 0x30
__u64 max_size		= 0x30, in Win2k: 0x48

__u16 name[64]		= "$ATTRIBUTE_LIST"
__u32 type		= 0x20
__u32 unknown[2]	= 0, 0
__u32 flags		= 0x80
__u64 min_size		= 0
__u64 max_size		= -1

__u16 name[64]		= "$FILE_NAME"
__u32 type		= 0x30
__u32 unknown[2]	= 0, 0
__u32 flags		= 0x42
__u64 min_size		= 0x44
__u64 max_size		= 0x242

/* The $volume_version attribute has never been observed in the field. It
 * probably never was used and was hence replaced by the $object_id in
 * Windows 2000. */
__u16 name[64]		= "$VOLUME_VERSION" in Win2k: "$OBJECT_ID"
__u32 type		= 0x40
__u32 unknown[2]	= 0, 0
__u32 flags		= 0x40
__u64 min_size		= 0x8 in Win2k: 0
__u64 max_size		= 0x8 in Win2k: 0x100

__u16 name[64]		= "$SECURITY_DESCRIPTOR"
__u32 type		= 0x50
__u32 unknown[2]	= 0, 0
__u32 flags		= 0x80
__u64 min_size		= 0
__u64 max_size		= -1

__u16 name[64]		= "$VOLUME_NAME"
__u32 type		= 0x60
__u32 unknown[2]	= 0,0
__u32 flags		= 0x40
__u64 min_size		= 0x2
__u64 max_size		= 0x100

__u16 name[64]		= "$VOLUME_INFORMATION"
__u32 type		= 0x70
__u32 unknown[2]	= 0, 0
__u32 flags		= 0x40
__u64 min_size		= 0xc
__u64 max_size		= 0xc

__u16 name[64]		= "$DATA"
__u32 type		= 0x80
__u32 unknown[2]	= 0, 0
__u32 flags		= 0
__u64 min_size		= 0
__u64 max_size		= -1

__u16 name[64]		= "$INDEX_ROOT"
__u32 type		= 0x90
__u32 unknown[2]	= 0, 0
__u32 flags		= 0x40
__u64 min_size		= 0
__u64 max_size		= -1

__u16 name[64]		= "$INDEX_ALLOCATION"
__u32 type		= 0xa0
__u32 unknown[2]	= 0,0
__u32 flags		= 0x80
__u64 min_size		= 0
__u64 max_size		= -1

__u16 name[64]		= "$BITMAP"
__u32 type		= 0xb0
__u32 unknown[2]	= 0, 0
__u32 flags		= 0x80
__u64 min_size		= 0
__u64 max_size		= -1

/* The $symbolic_link attribute has never been observed in the field. It
 * probably never was used and was hence replaced by the $reparse_point in
 * Windows 2000. */
__u16 name[64]		= "$SYMBOLIC_LINK" in Win2k: "$REPARSE_POINT"
__u32 type		= 0xc0
__u32 unknown[2]	= 0, 0
__u32 flags		= 0x80
__u64 min_size		= 0
__u64 max_size		= -1 in Win2k: 0x4000

__u16 name[64]		= "$EA_INFORMATION"
__u32 type		= 0xd0
__u32 unknown[2]	= 0, 0
__u32 flags		= 0x40
__u64 min_size		= 0x8
__u64 max_size		= 0x8

__u16 name[64]		= "$EA"
__u32 type		= 0xe0
__u32 unknown[2]	= 0, 0
__u32 flags		= 0
__u64 min_size		= 0
__u64 max_size		= 0x10000

/*
 * Sequence terminates here with a record all of whose fields are zero, even
 * though the size of the $AttrDef data attribute is much larger (36000 bytes,
 * i.e. in theory 225 attribute definitions of 160 bytes each but in practice
 * only until we reach an all zero record).
 * 
 * The following only applies to Windows 2000 and replaces the above comment.
 */

__u16 name[64]		= "$LOGGED_UTILITY_STREAM"
__u32 type		= 0x100
__u32 unknown[2]	= 0, 0
__u32 flags		= 0x80
__u64 min_size		= 0
__u64 max_size		= 0x10000

/*
 * This is terminated by a single record all of whose fields are zero. This
 * also finishes the $AttrDef data attribute. I.e. the attribute size is the
 * correct size of the sequence of attribute definitions (2560 bytes, i.e.
 * 16 attribute definitions of 160 bytes each).
 */


--- NEW FILE ---
The following settings can be tuned in Windows NT in the registry under the key
\Registry\Machine\System\CurrentControlSet\Control\FileSystem.

NtfsDisable8dot3NameCreation
NtfsAllowExtendedCharacterIn8dot3Name
NtfsDisableLastAccessUpdate
NtfsMftZoneReservation

[Linux-ntfs-cvs] CVS: linux-ntfs/ntfstools ntfsdump_logfile.c,NONE,1.1 ntfsfix.c,1.1,1.2

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/ntfstools
In directory usw-pr-cvs1:/tmp/cvs-serv9476/ntfstools

Modified Files:
	ntfsfix.c 
Added Files:
	ntfsdump_logfile.c 
Log Message:
Added a logfile dumper as a new utility.
Almost finished the first ntfsfix release. (Still missingin CVS are attrib.c
for ntfslib and the makefiles to build everything.)
Fixes for nested packed structure/union typedefs as gcc doesn't automatically
nest the __attribute__ ((__packed__)), even though according to the gcc info
page it does. (Thanks to Yuri Per <yu...@ac...> for pointing this out.)


--- NEW FILE ---
const char *EXEC_NAME = "NtfsDump_LogFile";
const char *EXEC_VERSION = "0.0.1";
/*
 * NtfsDump_LogFile - Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This utility will interpret the contents of the journal ($LogFile) of an
 * NTFS partition and display the results on stdout. Errors will be output to
 * stderr.
 *
 * 	Anton Altaparmakov <ai...@ca...>
 *
 * 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 (in the main directory of the Linux-NTFS source
 * in the file COPYING); if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 * WARNING: This program might not work on architectures which do not allow 
 * unaligned access. For those, the program would need to start using 
 * get/put_unaligned macros (#include <asm/unaligned.h>), but not doing it yet,
 * since NTFS really mostly applies to ia32 only, which does allow unaligned
 * accesses. We might not actually have a problem though, since the structs are 
 * defined as being packed so that might be enough for gcc to insert the 
 * correct code.
 *
 * If anyone using a non-little endian and/or an aligned access only CPU tries
 * this program please let me know whether it works or not!
 *
 * 	Anton Altaparmakov <ai...@ca...>
 */

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <linux/types.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

#include "attrib.h"
#include "endians.h"
#include "mft.h"
#include "disk_io.h"
#include "volume.h"
#include "logfile.h"

int main(int argc, char **argv)
{
	unsigned char *b1 = NULL;
	NONRESIDENT_ATTRIBUTE_RECORD_HEADER *a;
	__u64 l;
	unsigned char *lfd;
	ntfs_volume *vol = NULL;
	RESTART_PAGE_HEADER *rph;
	RESTART_AREA *rr;
	RESTART_CLIENT *cr;
	int pass = 1;
	int i, lps;

	printf("\n");
	if (argc != 2) {
		printf("%s v%s - Interpret and display information\nabout the "
		       "journal ($LogFile) of an NTFS volume.\n\n"
		       /* Generic copyright / disclaimer. */
		       "Copyright (c) 2000, 2001 Anton Altaparmakov.\n"
		       "%s is free software, released under the GNU "
		       "General Public License and you\nare welcome to "
		       "redistribute it under certain conditions.\n"
		       "%s comes with ABSOLUTELY NO WARRANTY; for details"
		       "read the file GNU\nGeneral Public License to be found "
		       "in the file COPYING in the main Linux-NTFS\n"
		       "distribution directory.\n\n"
		       /* Generic part ends here. */
		       "Syntax: ntfsdump_logfile partition_or_file_name\n"
		       "        e.g. ntfsdump_logfile /dev/hda6\n\n",
		       EXEC_NAME, EXEC_VERSION, EXEC_NAME, EXEC_NAME);
		fprintf(stderr, "Error: incorrect syntax\n");
		exit(1);
	}
	vol = ntfs_open(argv[1]);
	if (!vol) {
		perror("ntfs_open() failed");
		exit(1);
	}
	b1 = (__u8 *)malloc(vol->mft_record_size);
	if (!b1) {
		perror("Error allocating internal buffers");
		goto error_exit;
	}
	/* Read $MFT and $MFTmirr. */
	if (get_mft_records(vol, b1, 2, 1) != 1) {
		fprintf(stderr, "Error reading mft record for $LogFile.\n");
		goto error_exit;
	}
	/* Check the $LogFile mft record. */
	if (is_baad_record(b1)) {
		puts(FAILED);
		fprintf(stderr, "Error: Incomplete multi sector "
			       	"transfer detected in $LogFile.\nCannot "
			       	"handle this yet. )-:\n");
		goto error_exit;
	}
	if (!is_mft_recordp(b1)) {
		puts(FAILED);
		fprintf(stderr, "Error: Invalid mft record for $LogFile.\n"
				"Cannot handle this yet. )-:\n");
		goto error_exit;
	}
	/* Check NTFS version is ok for us. */
	printf("\nNTFS volume version is %i.%i.\n", vol->major_ver,
						  vol->minor_ver);
	switch (vol->major_ver) {
		case 1:
			if (vol->minor_ver == 1 || vol->minor_ver == 2)
				break;
			else
				goto version_error;
		case 2:	case 3:
			if (vol->minor_ver == 0)
				break;
			/* Fall through on error. */
		default:
version_error:			
                	fprintf(stderr, "Error: Unknown NTFS version.\n");
			goto error_exit;
	}
	/* Find the $DATA attribute of the $LogFile. */
	a = (NONRESIDENT_ATTRIBUTE_RECORD_HEADER*)
		find_attribute((MFT_RECORD_HEADER*)b1, $DATA, NULL);
	if (!a) {
		puts(FAILED);
		fprintf(stderr, "Error: Attribute $DATA was not found in" \
		                "$LogFile!\n");
		goto log_file_error;
	}
	/* Get length of $LogFile contents. */
	l = get_attribute_value_length((ATTRIBUTE_RECORD_HEADER*)a);
	if (!l) {
		puts(OK);
		puts("$LogFile has zero length, no need to write to disk.");
		goto log_file_error;
	}
	/* Allocate a buffer to hold all of the $LogFile contents. */
	lfd = (unsigned char*)malloc(l);
	if (!lfd) {
		puts(FAILED);
		puts("Not enough memory to load $LogFile.");
		goto log_file_error;
	}
	/* Read in the $LogFile into the buffer. */
	if (l != get_attribute_value(vol, (ATTRIBUTE_RECORD_HEADER*)a, lfd)) {
		puts(FAILED);
		puts("Amount of data read does not correspond to expected "
		     "length!");
		free(lfd);
		goto log_file_error;
	}
	/* Check restart area. */
	if (!is_rstr_recordp(lfd)) {
		puts(FAILED);
		puts("$LogFile contents are corrupt (magic RSTR missing)!");
		free(lfd);
		goto log_file_error;
	}
	/* Do the interpretation and display now. */
	rph = (RESTART_PAGE_HEADER*)lfd;
	lps = le32_to_cpu(rph->LogPageSize);
pass_loc:
	if (!post_read_mst_fixup((NTFS_RECORD_HEADER*)rph, lps) ||
	    is_baad_recordp(rph)) {
		puts(FAILED);
		puts("$LogFile incomplete multi sector transfer detected! "
		     "Cannot handle this yet!");
		free(lfd);
		goto log_file_error;
	}
	if (le16_to_cpu(rph->major_version != 1) || 
	    le16_to_cpu(rph->minor_version != 1)) {
		puts(FAILED);
		fprintf(stderr, "$LogFile version %i.%i! Error: Unknown "
				"$LogFilee version!\n",
					le16_to_cpu(rph->major_ver),
					le16_to_cpu(rph->minor_ver));
		free(lfd);
		goto log_file_error;
	}
	rr = (RESTART_AREA*)((char*)rph + le16_to_cpu(rph->restart_offset));
	cr = (RESTART_CLIENT*)((char*)rr + sizeof(RESTART_AREA));
	/* Dump of the interpreted $LogFile restart area. */
	if (pass == 1)
		printf("\n$LogFile version %i.%i.\n",
					le16_to_cpu(rph->major_ver),
					le16_to_cpu(rph->minor_ver));
	printf("%s restart area:\n", pass == 1? "1st": "2nd");
	printf("magic = RSTR\n");
	printf("Lsn = 0x%Lx\n", sle64_to_cpu(rph->chkdsk_lsn));
	printf("SystempageSize = %u\n", le32_to_cpu(rph->system_page_size));
	printf("LogPageSize = %u\n", le32_to_cpu(rph->log_page_size));
	printf("RestartOffset = 0x%x\n", le16_to_cpu(rph->restart_offset));
	printf("\n(1st) restart record:\n");
	printf("CurrentLsn = %Lx\n", sle64_to_cpu(rr->current_lsn));
	printf("LogClients = %u\n", le16_to_cpu(rr->log_clients));
	printf("ClientFreeList = %u\n", le16_to_cpu(rr->client_free_list));
	printf("ClientInUseList = %u\n", le16_to_cpu(rr->client_in_use_list));
	printf("Flags = 0x%x\n", le16_to_cpu(rr->flags));
	printf("SeqNumberBits = %u\n", le32_to_cpu(rr->seq_number_bits));
	printf("RestartAreaLength = 0x%x\n", 
					le16_to_cpu(rr->restart_area_length));
	printf("ClientArrayOffset = 0x%x\n",
					le16_to_cpu(rr->client_array_offset));
	printf("FileSize = %Lu\n", le64_to_cpu(rr->file_size));
	if (le64_to_cpu(rr->file_size) != l)
		puts("$LogFile restart area indicates a log file size"
		     "different from the actual size!");
	printf("LastLsnDataLength = 0x%x\n",
					le32_to_cpu(rr->last_lsn_data_length));
	printf("RecordLength = 0x%x\n", le16_to_cpu(rr->record_length));
	printf("LogPageDataOffset = 0x%x\n", 
					le16_to_cpu(rr->log_page_data_offset));
	printf("\n1st Client record:\n");
	printf("OldestLsn = 0x%Lx\n", sle64_to_cpu(cr->oldest_lsn));
	printf("ClientRestartLsn = 0x%Lx\n", 
					sle64_to_cpu(cr->client_restart_lsn));
	printf("PrevClient = 0x%x\n", le16_to_cpu(cr->prev_client));
	printf("NextClient = 0x%x\n", le16_to_cpu(cr->next_client));
	printf("SeqNumber = 0x%x\n", le16_to_cpu(cr->seq_number));
	printf("ClientName = %u\n", le16_to_cpu(cr->client_name));
	printf("\nTerminator = 0x%x\n", *(__u32*)((char*)cr + 
						sizeof(RESTART_CLIENT)));
	if (*(__u32*)((char*)cr + sizeof(RESTART_CLIENT)) != 0xffffffff)
		puts("$LogFile restart area is not terminated!");
	printf("Unicode string \"NTFS\"%spresent\n", *(__u64*)((char*)cr + 
				sizeof(RESTART_CLIENT) + 0x10) == 
				cpu_to_le64(0x005300460054004e) ? " ": " not ");
	rph = (RESTART_PAGE_HEADER*)((char*)rph + lps);
	if (pass == 1) {
		++pass;
		goto pass_loc;
	}
	if (!is_rcrd_recordp(rph))
		puts("$LogFile's first record area magic RCRD is missing!");
}
	puts("That's all for now. Dumping of the actual log contents is not "
	     "implemented yet.");
	/* Release the allocated buffer. */
	free(lfd);
log_file_error:
	printf("\n");
	/* Set return code to 0. */
	i = 0;
final_exit:
	if (b1)
		free(b1);
	if (vol)
		ntfs_close(vol);
	return i;
error_exit:
	i = 1;
	goto final_exit;
}


Index: ntfsfix.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/ntfstools/ntfsfix.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** ntfsfix.c	2001/01/24 21:02:37	1.1
--- ntfsfix.c	2001/01/27 14:22:02	1.2
***************
*** 321,336 ****
  	puts(OK);
  	printf("\n");
! 	
! 	/* Zero the value of the $LogFile data attribute (ie. the contents of
! 	 * the file) thus erasing the journal.
  	 * FIXME(?): We might need to zero the LSN field of every single $Mft
  	 * record as well. (But, first try without doing that and see what
  	 * happens, since chkdsk might pickup the pieces and do it for us...)
! 	 * FIXME: This results in winNT/2k saying the partition is corrupt and
! 	 * tells us to run chkdsk but when it is the boot drive it doesn't
! 	 * boot up so can't run chkdsk!!! 
! 	 * 
! 	 * Try to clear the $LogFile by modifying the restart areas... */
! 	printf("Going to fixup the journal ($LogFile)... ");
  	/* Find the $DATA attribute. */
  	a = (NONRESIDENT_ATTRIBUTE_RECORD_HEADER*)
--- 321,332 ----
  	puts(OK);
  	printf("\n");
! 	/*
! 	 * Fill the value of the $LogFile data attribute (ie. the contents of
! 	 * the file) with 0xff's, thus marking the journal as empty.
  	 * FIXME(?): We might need to zero the LSN field of every single $Mft
  	 * record as well. (But, first try without doing that and see what
  	 * happens, since chkdsk might pickup the pieces and do it for us...)
! 	 */
! 	printf("Going to empty the journal ($LogFile)... ");
  	/* Find the $DATA attribute. */
  	a = (NONRESIDENT_ATTRIBUTE_RECORD_HEADER*)
***************
*** 342,345 ****
--- 338,347 ----
  		goto log_file_error;
  	}
+ 	/* The $DATA attribute of the $LogFile has to be non-resident. */
+ 	if (!a->non_resident) {
+ 		puts(FAILED);
+ 		fprintf(stderr, "$LogFile $DATA attribute is resident!?!\n");
+ 		goto log_file_error;
+ 	}
  	/* Get length of $LogFile contents. */
  	l = get_attribute_value_length((ATTRIBUTE_RECORD_HEADER*)a);
***************
*** 356,360 ****
  		goto log_file_error;
  	}
! 	/* Read in the $LogFile into the buffer. */
  	if (l != get_attribute_value(vol, (ATTRIBUTE_RECORD_HEADER*)a, lfd)) {
  		puts(FAILED);
--- 358,365 ----
  		goto log_file_error;
  	}
! 	/* Read in the $LogFile into the buffer. We do this more as a check
! 	   for correct length than anything else. We thus make sure we are
! 	   decompressing the mapping pairs array correctly and hence writing
! 	   below if safe as well. */
  	if (l != get_attribute_value(vol, (ATTRIBUTE_RECORD_HEADER*)a, lfd)) {
  		puts(FAILED);
***************
*** 363,492 ****
  		free(lfd);
  		goto log_file_error;
- 	}
- 	/* Check and then modify restart area. */
- 	if (!is_rstr_recordp(lfd)) {
- 		puts(FAILED);
- 		puts("$LogFile contents are corrupt (magic RSTR missing)!");
- 		free(lfd);
- 		goto log_file_error;
- 	}
- {	RESTART_PAGE_HEADER *rph;
- 	RESTART_AREA *rr;
- 	RESTART_CLIENT *cr;
- 	int pass = 1;
- 	int lps;
- 	
- 	rph = (RESTART_PAGE_HEADER*)lfd;
- 	lps = le32_to_cpu(rph->LogPageSize);
- pass_loc:
- 	if (!post_read_mst_fixup((NTFS_RECORD_HEADER*)rph, lps) ||
- 	    is_baad_recordp(rph)) {
- 		puts(FAILED);
- 		puts("$LogFile incomplete multi sector transfer detected! "
- 		     "Cannot handle this yet!");
- 		free(lfd);
- 		goto log_file_error;
- 	}
- 	if (le16_to_cpu(rph->major_version != 1) || 
- 	    le16_to_cpu(rph->minor_version != 1)) {
- 		puts(FAILED);
- 		printf("$LogFile version %i.%i! Cannot handle this yet!\n",
- 					le16_to_cpu(rph->major_ver),
- 					le16_to_cpu(rph->minor_ver));
- 		free(lfd);
- 		goto log_file_error;
  	}
! 	rr = (RESTART_AREA*)((char*)rph + le16_to_cpu(rph->restart_offset));
! 	cr = (RESTART_CLIENT*)((char*)rr + sizeof(RESTART_AREA));
! #ifdef DEBUG
! 	/* Do a dump of the $LogFile restart area. */
! 	if (pass == 1)
! 		printf("\n$LogFile version %i.%i.\n",
! 					le16_to_cpu(rph->major_ver),
! 					le16_to_cpu(rph->minor_ver));
! 	printf("%s restart area:\n", pass == 1? "1st": "2nd");
! 	printf("magic = RSTR\n");
! 	printf("Lsn = 0x%Lx\n", sle64_to_cpu(rph->chkdsk_lsn));
! 	printf("SystempageSize = %u\n", le32_to_cpu(rph->system_page_size));
! 	printf("LogPageSize = %u\n", le32_to_cpu(rph->log_page_size));
! 	printf("RestartOffset = 0x%x\n", le16_to_cpu(rph->restart_offset));
! 	printf("\n(1st) restart record:\n");
! 	printf("CurrentLsn = %Lx\n", sle64_to_cpu(rr->current_lsn));
! 	printf("LogClients = %u\n", le16_to_cpu(rr->log_clients));
! 	printf("ClientFreeList = %u\n", le16_to_cpu(rr->client_free_list));
! 	printf("ClientInUseList = %u\n", le16_to_cpu(rr->client_in_use_list));
! 	printf("Flags = 0x%x\n", le16_to_cpu(rr->flags));
! 	printf("SeqNumberBits = %u\n", le32_to_cpu(rr->seq_number_bits));
! 	printf("RestartAreaLength = 0x%x\n", 
! 					le16_to_cpu(rr->restart_area_length));
! 	printf("ClientArrayOffset = 0x%x\n",
! 					le16_to_cpu(rr->client_array_offset));
! 	printf("FileSize = %Lu\n", le64_to_cpu(rr->file_size));
! 	printf("LastLsnDataLength = 0x%x\n",
! 					le32_to_cpu(rr->last_lsn_data_length));
! 	printf("RecordLength = 0x%x\n", le16_to_cpu(rr->record_length));
! 	printf("LogPageDataOffset = 0x%x\n", 
! 					le16_to_cpu(rr->log_page_data_offset));
! 	printf("\n1st Client record:\n");
! 	printf("OldestLsn = 0x%Lx\n", sle64_to_cpu(cr->oldest_lsn));
! 	printf("ClientRestartLsn = 0x%Lx\n", 
! 					sle64_to_cpu(cr->client_restart_lsn));
! 	printf("PrevClient = 0x%x\n", le16_to_cpu(cr->prev_client));
! 	printf("NextClient = 0x%x\n", le16_to_cpu(cr->next_client));
! 	printf("SeqNumber = 0x%x\n", le16_to_cpu(cr->seq_number));
! 	printf("ClientName = %u\n", le16_to_cpu(cr->client_name));
! 	printf("\nTerminator = 0x%x\n", *(__u32*)((char*)cr + 
! 						sizeof(RESTART_CLIENT)));
! 	printf("Unicode string \"NTFS\"%spresent\n", *(__u64*)((char*)cr + 
! 				sizeof(RESTART_CLIENT) + 0x10) == 
! 				cpu_to_le64(0x005300460054004e) ? " ": " not ");
! #endif
! 	rr->log_clients = cpu_to_le16(1);
! 	rr->client_free_list = cpu_to_le16(0xffff);
! 	rr->client_in_use_list = cpu_to_le16(0);
! 	rr->flags = cpu_to_le16(0);
! 	if (le64_to_cpu(rr->file_size) != l) {
! 		puts(FAILED);
! 		puts("$LogFile restart area indicates a log file size"
! 		     "different from the actual size!");
! 		free(lfd);
! 		goto log_file_error;
! 	}
! 	rr->last_lsn_data_length = cpu_to_le32(0);
! 	rr->current_lsn = cr->client_restart_lsn;
! 	cr->prev_client = cpu_to_le16(0);
! 	cr->next_client = cpu_to_le16(0);
! 	if (le16_to_cpu(cr->client_name) != 0) {
! 		puts(FAILED);
! 		puts("$LogFile restart area Client Name != 0.");
! 		free(lfd);
! 		goto log_file_error;
! 	}
! 	if (*(__u32*)((char*)cr + sizeof(RESTART_CLIENT)) != 
! 								  0xffffffff) {
! 		puts(FAILED);
! 		puts("$LogFile restart area not terminated!");
! 		free(lfd);
! 		goto log_file_error;
! 	}
! 	if (!pre_write_mst_fixup((NTFS_RECORD_HEADER*)rph, lps)) {
! 		puts(FAILED);
! 		puts("$LogFile restart area multi sector protection not "
! 		     "completed!");
! 		free(lfd);
! 		goto log_file_error;
! 	}
! 	rph = (RESTART_PAGE_HEADER*)((char*)rph + lps);
! 	if (pass == 1) {
! 		++pass;
! 		goto pass_loc;
! 	}
! 	if (!is_rcrd_recordp(rph)) {
! 		puts(FAILED);
! 		puts("$LogFile's first record area magic RCRD is missing!");
! 		free(lfd);
! 		goto log_file_error;
! 	}
! }
  	/* Set the $DATA attribute. */
  	/* FIXME: set_attribute_value needs to either:
--- 368,374 ----
  		free(lfd);
  		goto log_file_error;
  	}
! 	/* Fill the buffer with 0xff's. */
! 	memset(lfd, -1, l);
  	/* Set the $DATA attribute. */
  	/* FIXME: set_attribute_value needs to either:
***************
*** 499,504 ****
  	 * For now, just assume that attribute length remains constant, since
  	 * this is the case for the $LogFile zeroing out. */
- 
- /* DON'T WRITE IT BACK YET!!!
  	if (!set_attribute_value(vol, (ATTRIBUTE_RECORD_HEADER*)a, lfd, l)) {
  		puts(FAILED);
--- 381,384 ----
***************
*** 507,531 ****
  		goto log_file_error;
  	}
!  */
! 
! 	/* Release the allocated buffer. */
  	free(lfd);
  	puts(OK);
- 	puts("$LogFile was left untouched as we don't know what to do with "
- 	     "it yet!");
  
  log_file_error:
- 	
  	printf("\n");
  
  	/* FIXME: If on NTFS 3.0+, check for presence of the usn journal and
  	   disable it (if present) as Win2k might be unhappy otherwise and Bad
! 	   Thing(TM) could happen depending on what applications are actually
  	   using it for. */
  	
  	/* FIXME: Should we be marking the quota out of date, too? */
  
  	/* That's all for now! */
- 
  	printf("NTFS partition %s was processed successfully.\n", 
  							      vol->vol_name);
--- 387,409 ----
  		goto log_file_error;
  	}
! 	/* No need to sync the $LogFile mft record to disk as we haven't
! 	   touched it at all. */
! 	/* Release the allocated buffer and finish $LogFile processing. */
  	free(lfd);
  	puts(OK);
  
  log_file_error:
  	printf("\n");
  
+ 	if (vol->major_ver >= 3) {
  	/* FIXME: If on NTFS 3.0+, check for presence of the usn journal and
  	   disable it (if present) as Win2k might be unhappy otherwise and Bad
! 	   Things(TM) could happen depending on what applications are actually
  	   using it for. */
+ 	}
  	
  	/* FIXME: Should we be marking the quota out of date, too? */
  
  	/* That's all for now! */
  	printf("NTFS partition %s was processed successfully.\n", 
  							      vol->vol_name);

[Linux-ntfs-cvs] CVS: linux-ntfs/include attrib.h,1.2,1.3 logfile.h,1.2,1.3 mft.h,1.1,1.2

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv9476/include

Modified Files:
	attrib.h logfile.h mft.h 
Log Message:
Added a logfile dumper as a new utility.
Almost finished the first ntfsfix release. (Still missingin CVS are attrib.c
for ntfslib and the makefiles to build everything.)
Fixes for nested packed structure/union typedefs as gcc doesn't automatically
nest the __attribute__ ((__packed__)), even though according to the gcc info
page it does. (Thanks to Yuri Per <yu...@ac...> for pointing this out.)


Index: attrib.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/attrib.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -r1.2 -r1.3
*** attrib.h	2001/01/26 02:36:10	1.2
--- attrib.h	2001/01/27 14:22:02	1.3
***************
*** 427,436 ****
  						   pack the extended attributes
  						   (EAs), if such are present.*/
! 		};
  		__u32 reparse_point_tag;	/* Type of reparse point,
  						   present only in reparse
  						   points and only if there are
  						   no EAs. */
! 	};
  	__u8 filename_length;			/* Length of filename in
  						   Unicode characters. */
--- 427,436 ----
  						   pack the extended attributes
  						   (EAs), if such are present.*/
! 		} __attribute__ ((__packed__));
  		__u32 reparse_point_tag;	/* Type of reparse point,
  						   present only in reparse
  						   points and only if there are
  						   no EAs. */
! 	} __attribute__ ((__packed__));
  	__u8 filename_length;			/* Length of filename in
  						   Unicode characters. */
***************
*** 479,485 ****
  			GUID domain_id;		/* Reserved.
  						   NOTE: Optional. */
! 		};
  		__u8 extended_info[48];
! 	};
  } __attribute__ ((__packed__)) OBJECT_ID_ATTRIBUTE;
  
--- 479,485 ----
  			GUID domain_id;		/* Reserved.
  						   NOTE: Optional. */
! 		} __attribute__ ((__packed__));
  		__u8 extended_info[48];
! 	} __attribute__ ((__packed__));
  } __attribute__ ((__packed__)) OBJECT_ID_ATTRIBUTE;
  

Index: logfile.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/logfile.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -r1.2 -r1.3
*** logfile.h	2001/01/24 21:02:37	1.2
--- logfile.h	2001/01/27 14:22:02	1.3
***************
*** 164,168 ****
  		__u64 last_lsn;
  		__u32 file_offset;
! 	} copy;
  	__u32 flags;
  	__u16 page_count;
--- 164,168 ----
  		__u64 last_lsn;
  		__u32 file_offset;
! 	} __attribute__ ((__packed__)) copy;
  	__u32 flags;
  	__u16 page_count;
***************
*** 172,177 ****
  			__u64 next_record_offset;
  			__u64 last_end_lsn;
! 		} packed;
! 	} header;
  } __attribute__ ((__packed__)) RECORD_PAGE_HEADER;
  
--- 172,177 ----
  			__u64 next_record_offset;
  			__u64 last_end_lsn;
! 		} __attribute__ ((__packed__)) packed;
! 	} __attribute__ ((__packed__)) header;
  } __attribute__ ((__packed__)) RECORD_PAGE_HEADER;
  
***************
*** 197,201 ****
  		__u16 seq_number;
  		__u16 client_index;
! 	} client_id;
  	__u32 record_type;
  	__u32 transaction_id;
--- 197,201 ----
  		__u16 seq_number;
  		__u16 client_index;
! 	} __attribute__ ((__packed__)) client_id;
  	__u32 record_type;
  	__u32 transaction_id;
***************
*** 221,225 ****
  		__u32 lcn;
  		__u32 alignment_or_reserved;
! 	} lcn_list[0];
  } __attribute__ ((__packed__)) LOG_RECORD;
  
--- 221,225 ----
  		__u32 lcn;
  		__u32 alignment_or_reserved;
! 	} __attribute__((__packed__)) lcn_list[0];
  } __attribute__ ((__packed__)) LOG_RECORD;
  

Index: mft.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/mft.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** mft.h	2001/01/24 02:13:24	1.1
--- mft.h	2001/01/27 14:22:02	1.2
***************
*** 69,75 ****
  		__u32 low_part;	/* Mft record number being referenced split */
  		__u16 high_part;/* into the low 32-bits and the high 16-bits. */
! 	};
  	__u16 sequence_number;	/* The sequence number, see above. */
!     };
      __u64 mft_reference;	/* The whole mft reference as one number. */
  } __attribute__ ((__packed__)) MFT_REFERENCE;
--- 69,75 ----
  		__u32 low_part;	/* Mft record number being referenced split */
  		__u16 high_part;/* into the low 32-bits and the high 16-bits. */
! 	} __attribute__ ((__packed__));
  	__u16 sequence_number;	/* The sequence number, see above. */
!     } __attribute__ ((__packed__));
      __u64 mft_reference;	/* The whole mft reference as one number. */
  } __attribute__ ((__packed__)) MFT_REFERENCE;

[Linux-ntfs-cvs] CVS: linux-ntfs TODO.ntfsfix,1.1,1.2

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs
In directory usw-pr-cvs1:/tmp/cvs-serv9476

Modified Files:
	TODO.ntfsfix 
Log Message:
Added a logfile dumper as a new utility.
Almost finished the first ntfsfix release. (Still missingin CVS are attrib.c
for ntfslib and the makefiles to build everything.)
Fixes for nested packed structure/union typedefs as gcc doesn't automatically
nest the __attribute__ ((__packed__)), even though according to the gcc info
page it does. (Thanks to Yuri Per <yu...@ac...> for pointing this out.)


Index: TODO.ntfsfix
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/TODO.ntfsfix,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** TODO.ntfsfix	2001/01/24 02:10:41	1.1
--- TODO.ntfsfix	2001/01/27 14:22:02	1.2
***************
*** 15,24 ****
  *    format for the records in the file. - Argh!
  *
! * - On ntfs 3.0+ volumes need to disable the usn journal if it is active.
  *
! * - On ntfs 3.0+ volumes need to mark the quota out of date?
  *
  *
  *
  *
  *
--- 15,33 ----
  *    format for the records in the file. - Argh!
  *
! * 5. YES! - Big thanks to Yuri Per <yu...@ac...> for providing the
! *    solution: Set the contents of the $LogFile to 0xff's which results in
! *    Windows regarding the log as being empty and just starts it again!
! *    One problem down! (-:
  *
! * - On ntfs 3.0+ volumes need to disable the usn journal if it is active:
  *
+ * 1. Delete file $UsnJrnl from /$Extend directory.
  *
+ * 2. Walk the mft and for each record set the usn in the standard information
+ *    attribute to zero. (This can take a while on large volumes.)
  *
+ * - On ntfs 3.0+ volumes need to mark the quota out of date? - Probably, but
+ *   it shouldn't cause any corruption not doing so for the moment so this is
+ *   not a showstopper bug for the first release.
  *
  *

[Linux-ntfs-cvs] CVS: linux-ntfs/include attrib.h,1.1,1.2

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv8494/include

Modified Files:
	attrib.h 
Log Message:
More work on attrib.h.


Index: attrib.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/attrib.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** attrib.h	2001/01/24 02:13:24	1.1
--- attrib.h	2001/01/26 02:36:10	1.2
***************
*** 92,117 ****
  
  /*
-  * The collation rules for sorting views/indexes/etc (32-bit).
-  */
- typedef enum {
- 	COLLATION_BINARY	 = cpu_to_le32(0), /* Collate by binary compare
- 						      where the first byte is
- 						      most significant. */
- 	COLLATION_FILENAME	 = cpu_to_le32(1), /* Collate file names as
- 						      Unicode strings. */
- 	COLLATION_UNICODE_STRING = cpu_to_le32(2), /* Collate Unicode strings
- 						      by comparing their binary
- 						      Unicode values, except
- 						      that when a character can
- 						      be uppercased, the upper
- 						      case value collates before
- 						      the lower case one. */
- 	COLLATION_NTOFS_ULONG		= cpu_to_le32(16),	/* ??? */
- 	COLLATION_NTOFS_SID		= cpu_to_le32(17),	/* ??? */
- 	COLLATION_NTOFS_SECURITY_HASH	= cpu_to_le32(18),	/* ??? */
- 	COLLATION_NTOFS_ULONGS		= cpu_to_le32(19),	/* ??? */
- } COLLATION_RULES;
- 
- /*
   * Attribute record header.
   */
--- 92,95 ----
***************
*** 256,260 ****
  
  /*
!  * Attribute: Standard information.
   *
   * NOTE: Always resident.
--- 234,238 ----
  
  /*
!  * Attribute: Standard information (0x10).
   *
   * NOTE: Always resident.
***************
*** 330,334 ****
  
  /*
!  * Attribute: Attribute list.
   *
   * The value of the attribute list attribute consists of a sequence of
--- 308,312 ----
  
  /*
!  * Attribute: Attribute list (0x20).
   *
   * The value of the attribute list attribute consists of a sequence of
***************
*** 418,424 ****
  
  /*
!  * Attribute: Filename.
   *
!  * NOTE: Always resident. (?)
   */
  typedef struct {
--- 396,402 ----
  
  /*
!  * Attribute: Filename (0x30).
   *
!  * NOTE: Always resident.
   */
  typedef struct {
***************
*** 481,485 ****
  
  /*
!  * Attribute: Object id.
   *
   * NOTE: Always resident.
--- 459,463 ----
  
  /*
!  * Attribute: Object id (0x40).
   *
   * NOTE: Always resident.
***************
*** 507,511 ****
  
  /*
!  * Attribute: Security descriptor.
   *
   * NOTE: Always resident.
--- 485,489 ----
  
  /*
!  * Attribute: Security descriptor (0x50).
   *
   * NOTE: Always resident.
***************
*** 517,521 ****
  
  /*
!  * Attribute: Volume name.
   * 
   * NOTE: Always resident.
--- 495,499 ----
  
  /*
!  * Attribute: Volume name (0x60).
   * 
   * NOTE: Always resident.
***************
*** 540,547 ****
  
  /*
!  * Attribute: Volume information.
   *
   * NOTE: Always resident.
   * NOTE: Present only in FILE_$Volume.
   */
  typedef struct {
--- 518,527 ----
  
  /*
!  * Attribute: Volume information (0x70).
   *
   * NOTE: Always resident.
   * NOTE: Present only in FILE_$Volume.
+  * NOTE: Windows 2000 uses NTFS 3.0 while Windows NT4 service pack 6a uses
+  * 	 NTFS 1.2. I haven't personally seen other values yet.
   */
  typedef struct {
***************
*** 553,559 ****
  
  /*
!  * Attribute: Data attribute.
   *
!  * Data contents of a file (unnamed stream) or of a named stream.
   */
  typedef struct {
--- 533,539 ----
  
  /*
!  * Attribute: Data attribute (0x80).
   *
!  * Data contents of a file (i.e. the unnamed stream) or of a named stream.
   */
  typedef struct {
***************
*** 562,594 ****
  
  /*
!  * Index header flags.
   */
  typedef enum {
! 	NO_INDEX_NODE	= cpu_to_le32(0), /* Small directory, i.e. the whole
! 					     directory fits inside the index
! 					     root attribute and hence there is
! 					     no index allocation attribute. */
! 	INDEX_NODE	= cpu_to_le32(1), /* Large directory, i.e. it doesn't
! 					     fit in the index root attribute
! 					     and hence an index allocation
  					     attribute is present. */
  } INDEX_HEADER_FLAGS;
  
  typedef enum {
! 	INDEX_ENTRY_NODE = cpu_to_le32(1), /* This entry references an index
! 					      allocation attribute value. */
  	INDEX_ENTRY_END  = cpu_to_le32(2), /* This signifies the last entry in
! 					      an index buffer. */
! } INDEX_ROOT_INDEX_ENTRY_FLAGS;
  
  /*
!  * Attribute: Bitmap.
   */
  typedef struct {
  	__u8 bitmap[0];			/* Array of bits. */
  } __attribute__ ((__packed__)) BITMAP_ATTRIBUTE;
  
  /*
!  * Attribute: Reparse point.
   *
   * FIXME: Describe more about reparse points here including the flags in the
--- 542,687 ----
  
  /*
!  * Index header flags (32-bit).
   */
  typedef enum {
! 	NO_INDEX_NODE	= cpu_to_le32(0), /* Small index, i.e. the whole index
! 					     fits inside the index root
! 					     attribute and hence there is no
! 					     index allocation attribute. */
! 	HAS_INDEX_NODE	= cpu_to_le32(1), /* Large index, i.e. it doesn't fit
! 					     in the index root attribute and
! 					     hence an index allocation
  					     attribute is present. */
  } INDEX_HEADER_FLAGS;
  
+ /*
+  * This is the header for indexes, describing the INDEX_ENTRY records, which
+  * follow the INDEX_HEADER. Together the index header and the index entries
+  * make up a complete index.
+  */
+ typedef struct {
+ 	__u32 entries_offset;		/* Byte offset to first INDEX_ENTRY. */
+ 	__u32 index_block_length;	/* Data size of index block in bytes.
+ 					   I.e. the number of bytes used from
+ 					   the allocated_size. */
+ 	__u32 allocated_size;		/* Byte size of the index block. */
+ 	INDEX_HEADER_FLAGS flags;	/* Bit field of INDEX_HEADER_FLAGS. */
+ } __attribute__ ((__packed__)) INDEX_HEADER;
+ 
+ /*
+  * The collation rules for sorting views/indexes/etc (32-bit).
+  */
  typedef enum {
! 	COLLATION_BINARY	 = cpu_to_le32(0), /* Collate by binary compare
! 						      where the first byte is
! 						      most significant. */
! 	COLLATION_FILENAME	 = cpu_to_le32(1), /* Collate file names as
! 						      Unicode strings. */
! 	COLLATION_UNICODE_STRING = cpu_to_le32(2), /* Collate Unicode strings
! 						      by comparing their binary
! 						      Unicode values, except
! 						      that when a character can
! 						      be uppercased, the upper
! 						      case value collates before
! 						      the lower case one. */
! 	COLLATION_NTOFS_ULONG		= cpu_to_le32(16),	/* ??? */
! 	COLLATION_NTOFS_SID		= cpu_to_le32(17),	/* ??? */
! 	COLLATION_NTOFS_SECURITY_HASH	= cpu_to_le32(18),	/* ??? */
! 	COLLATION_NTOFS_ULONGS		= cpu_to_le32(19),	/* ??? */
! } COLLATION_RULE;
! 
! /*
!  * Attribute: Index root (0x90).
!  *
!  * This is followed by a sequence of index entries (INDEX_ENTRY structures)
!  * as described by the index header.
!  */
! typedef struct {
! 	ATTRIBUTE_TYPE type;		/* Type of the indexed attribute. */
! 	COLLATION_RULE collation_rule;	/* Collation rule used to sort the
! 					   index entries. */
! 	__u32 bytes_per_index_block;	/* Byte size of each index block (in
! 					   the index allocation attribute). */
! 	__u32 clusters_per_index_block;	/* Cluster size of each index block (in
! 					   the index allocation attribute). */
! 	INDEX_HEADER index;		/* Index header describing the
! 					   following index entries. */
! } __attribute__ ((__packed__)) INDEX_ROOT;
! 
! /*
!  * Attribute: Index allocation (0xa0).
!  *
!  * This is an array of index blocks. Each index block starts with an
!  * INDEX_BLOCK_HEADER structure containing an index header, followed by a
!  * sequence of index entries (INDEX_ENTRY structures), as described by the
!  * index header.
!  */
! typedef struct {
! 	NTFS_RECORD_HEADER ntfs;	/* Magic is "INDX". */
! 	__u64 index_block_vcn;		/* Virtual cluster number of this
! 					   index block. */
! 	INDEX_HEADER index;		/* Index header describing the
! 					   following index entries. */
! } __attribute__ ((__packed__)) INDEX_BLOCK_HEADER;
! 
! /*
!  * Index entry flags (32-bit).
!  */
! typedef enum {
! 	INDEX_ENTRY_NODE = cpu_to_le32(1), /* This entry contains a reference
! 					      to an index block in form of a
! 					      virtual cluster number (see
! 					      below). */
  	INDEX_ENTRY_END  = cpu_to_le32(2), /* This signifies the last entry in
! 					      an index block. */
! } INDEX_ENTRY_FLAGS;
  
  /*
!  * This is an index entry. A sequence of such entries follows each INDEX_HEADER
!  * structure. Together they make up a complete index. The index follows either
!  * an index root attribute or an index allocation attribute.
!  *
!  * NOTE: Before NTFS 3.0 only filename attributes were indexed.
   */
  typedef struct {
+ 	MFT_REFERENCE indexed_file;	/* The mft reference of the file
+ 					   described by this index entry. */
+ 	__u16 length;			/* Byte size of this index entry. */
+ 	__u16 attribute_length;		/* Byte size of indexed attribute. */
+ 	INDEX_ENTRY_FLAGS flags;	/* Bit field of INDEX_ENTRY_* flags. */
+ 	// FILENAME_ATTRIBUTE name;	/* The indexed attribute. On NTFS
+ 	// 				   versions before 3.0 this is always
+ 	// 				   a FILENAME_ATTRIBUTE. */
+ 	// __u64 vcn;			/* If INDEX_ENTRY_NODE bit in flags is
+ 	//				   set, the last eight bytes of this
+ 	//				   index entry contain the virtual
+ 	//				   cluster number of the index block
+ 	//				   that holds the entries immediately
+ 	//				   preceding the current entry (the
+ 	//				   vcn is found in the index block
+ 	//				   header in the index allocation
+ 	//				   attribute). */
+ } __attribute__ ((__packed__)) INDEX_ENTRY;
+ 
+ /*
+  * Attribute: Bitmap (0xb0).
+  *
+  * Contains an array of bits (aka a bitfield).
+  */
+ typedef struct {
  	__u8 bitmap[0];			/* Array of bits. */
  } __attribute__ ((__packed__)) BITMAP_ATTRIBUTE;
  
+ /*
+  * Reparse point tag:
+  * 
+  * Most significant three bits mean:
+  * 	tag owned by Microsoft
+  * 	high latency on accessing file data
+  * 	filename is an alias for another object
+  */
+ 
  /*
!  * Attribute: Reparse point (0xc0).
   *
   * FIXME: Describe more about reparse points here including the flags in the
***************
*** 603,615 ****
  
  /*
!  * Attribute: Extended attribute (EA) information.
   */
  typedef struct {
! 	__u16 packed_ea_length;		/* Byte size of the buffer needed to
! 					   pack the extended attributes. */
! 	__u16 need_ea_count;		/* The number of extended attributes
! 					   which have the NEED_EA bit set. */
! 	__u32 unpacked_ea_length;	/* Byte size of the buffer required to
! 					   query the extended attributes. */
  } __attribute__ ((__packed__)) EA_INFORMATION;
  
--- 696,711 ----
  
  /*
!  * Attribute: Extended attribute (EA) information (0xd0).
   */
  typedef struct {
! 	__u16 ea_length;	/* Byte size of the packed extended
! 				   attributes. */
! 	__u16 need_ea_count;	/* The number of extended attributes which have
! 				   the NEED_EA bit set. */
! 	__u32 ea_query_length;	/* Byte size of the buffer required to query
! 				   the extended attributes when calling
! 				   ZwQueryEaFile() in Windows NT/2k. I.e. the
! 				   byte size of the unpacked extended
! 				   attributes. */
  } __attribute__ ((__packed__)) EA_INFORMATION;
  
***************
*** 619,626 ****
  
  /*
!  * Attribute: Extended attribute (EA).
   * 
   * Like the attribute list and the index buffer list, the EA attribute value is 
   * a sequence of EA_ATTRIBUTE variable length records.
   */
  typedef struct {
--- 715,724 ----
  
  /*
!  * Attribute: Extended attribute (EA) (0xe0).
   * 
   * Like the attribute list and the index buffer list, the EA attribute value is 
   * a sequence of EA_ATTRIBUTE variable length records.
+  *
+  * FIXME: It appears weird that the EA name is not unicode. Is it true?
   */
  typedef struct {
***************
*** 628,665 ****
  	__u8 flags;			/* Bit array of EA_FLAGS. */
  	__u8 ea_name_length;		/* Length of the name of the extended
! 					   attribute in characters.
! 					   FIXME: Unicode? */
  	__u16 ea_value_length;		/* Byte size of the EA's value. */
! 	__u8 ea_name[ea_name_length];	/* Name of the EA.
! 					   FIXME: In Unicode? */
  	__u8 ea_data[ea_value_length];	/* The value of the EA. Immediately
  					   follows the name. */
  } __attribute__ ((__packed__)) EA_ATTRIBUTE;
  
- /*
-  * Attribute: .
-  */
- typedef struct {
- } __attribute__ ((__packed__)) INDEX_HEADER;
- 
- /*
-  * Attribute: .
-  */
- typedef struct {
- } __attribute__ ((__packed__)) INDEX_ROOT;
- 
  /*
!  * Attribute: .
   */
  typedef struct {
! } __attribute__ ((__packed__)) INDEX_ALLOCATION;
  
  /*
!  * Attribute: .
   */
  typedef struct {
! } __attribute__ ((__packed__)) INDEX_ENTRY;
  
! /* min macro used in attrib.c. */
  #ifndef min
  #define min(a,b)	((a) <= (b) ? (a) : (b))
--- 726,757 ----
  	__u8 flags;			/* Bit array of EA_FLAGS. */
  	__u8 ea_name_length;		/* Length of the name of the extended
! 					   attribute in bytes. */
  	__u16 ea_value_length;		/* Byte size of the EA's value. */
! 	__u8 ea_name[ea_name_length];	/* Name of the EA. */
  	__u8 ea_data[ea_value_length];	/* The value of the EA. Immediately
  					   follows the name. */
  } __attribute__ ((__packed__)) EA_ATTRIBUTE;
  
  /*
!  * Attribute: Property set (0xf0).
!  *
!  * Intended to support Native Structure Storage (NSS) - a feature removed from
!  * NTFS 3.0 during beta testing.
   */
  typedef struct {
! 	/* ??? */
! } __attribute__ ((__packed__)) PROPERTY_SET;
  
  /*
!  * Attribute: Logged utility stream (0x100).
!  *
!  * Operations on this attribute are logged to the journal ($LogFile) like
!  * normal metadata changes. Used by the Encrypting File System (EFS).
   */
  typedef struct {
! 	/* Can be anything the creator chooses. */
! } __attribute__ ((__packed__)) LOGGED_UTILITY_STREAM;
  
! /* min macro used in attrib.c */
  #ifndef min
  #define min(a,b)	((a) <= (b) ? (a) : (b))
***************
*** 676,702 ****
   * - The last VCN is recognised by the fact that length == 0.
   * - LCN == 0 at any point means that the count VCNs starting at VCN are not 
!  *   physically allocated (ie. this is a hole). */
  /* FIXME: Should this be a linked list so it is easier/quicker to edit? */
  
! /* Allocate a run_list array and decompress the run-list of the non-resident
   * attribute attr into the run_list array.
   * Return a pointer to the run_list array or NULL on error.
!  * Notes: caller has to free the run_list array when finished. */
  run_list decompress_run_list(NONRESIDENT_ATTRIBUTE_RECORD_HEADER *attr);
  
! /* Determine the logical cluster number given the virtual cluster number and
   * the run list describing the mapping between the LCNs and VCNs. 
   * Return -ERRNO on error (ERRNO being the error number) and notably -NOENT 
!  * if vcn is outside the boundaries covered by the run list. */
  __s64 vcn_to_lcn(run_list rl, __s64 vcn);
  
! /* Set the volume flags in the Mft record b to flags.
!  * Return 1 on success or 0 on error. */
  int set_ntfs_volume_flags(MFT_RECORD_HEADER *b, __u16 flags);
  
! /* Get the location of the desired attribute of type t and name n (n can be
   * NULL for unnamed attributes; note that n is a Unicode string). Return a
   * pointer to the attribute or NULL if the attribute is not present or an
!  * error situation exists. */
  ATTRIBUTE_RECORD_HEADER *find_attribute(MFT_RECORD_HEADER *b, ATTRIBUTE_TYPE t,
  							      wchar_t *n);
--- 768,802 ----
   * - The last VCN is recognised by the fact that length == 0.
   * - LCN == 0 at any point means that the count VCNs starting at VCN are not 
!  *   physically allocated (i.e. this is a hole / data is sparse). */
  /* FIXME: Should this be a linked list so it is easier/quicker to edit? */
  
! /*
!  * Allocate a run_list array and decompress the run-list of the non-resident
   * attribute attr into the run_list array.
   * Return a pointer to the run_list array or NULL on error.
!  * Notes: caller has to free the run_list array when finished.
!  */
  run_list decompress_run_list(NONRESIDENT_ATTRIBUTE_RECORD_HEADER *attr);
  
! /*
!  * Determine the logical cluster number given the virtual cluster number and
   * the run list describing the mapping between the LCNs and VCNs. 
   * Return -ERRNO on error (ERRNO being the error number) and notably -NOENT 
!  * if vcn is outside the boundaries covered by the run list.
!  */
  __s64 vcn_to_lcn(run_list rl, __s64 vcn);
  
! /*
!  * Set the volume flags in the Mft record b to flags.
!  * Return 1 on success or 0 on error.
!  */
  int set_ntfs_volume_flags(MFT_RECORD_HEADER *b, __u16 flags);
  
! /*
!  * Get the location of the desired attribute of type t and name n (n can be
   * NULL for unnamed attributes; note that n is a Unicode string). Return a
   * pointer to the attribute or NULL if the attribute is not present or an
!  * error situation exists.
!  */
  ATTRIBUTE_RECORD_HEADER *find_attribute(MFT_RECORD_HEADER *b, ATTRIBUTE_TYPE t,
  							      wchar_t *n);
***************
*** 704,717 ****
  #include "volume.h"
  
  __u64 get_attribute_value_length(ATTRIBUTE_RECORD_HEADER *a);
  
! /* Make a copy of the attribute value of the attribute a into the destination
   * buffer b. Note that the size of b has to be at least equal to the value
   * returned by get_attribute_value_length(a).
   * Return number of bytes copied. If this is zero check errno. If errno is 0
   * then nothing was read due to a zero-length attribute value, otherwise
!  * errno describes the error. */
  __u64 get_attribute_value(ntfs_volume *vol, ATTRIBUTE_RECORD_HEADER *a, __u8 *b);
  
  int set_attribute_value(ntfs_volume *vol, ATTRIBUTE_RECORD_HEADER *a, 
  						    unsigned char *b, __u64 l);
--- 804,835 ----
  #include "volume.h"
  
+ /*
+  * Return the byte size of the attribute value (as it would be after eventual
+  * decompression and filling in of holes if sparse.
+  * If we return 0, check errno. If errno is 0 the actual length was 0, 
+  * otherwise errno describes the error.
+  */
  __u64 get_attribute_value_length(ATTRIBUTE_RECORD_HEADER *a);
  
! /*
!  * Make a copy of the attribute value of the attribute a into the destination
   * buffer b. Note that the size of b has to be at least equal to the value
   * returned by get_attribute_value_length(a).
   * Return number of bytes copied. If this is zero check errno. If errno is 0
   * then nothing was read due to a zero-length attribute value, otherwise
!  * errno describes the error.
!  */
  __u64 get_attribute_value(ntfs_volume *vol, ATTRIBUTE_RECORD_HEADER *a, __u8 *b);
  
+ /*
+  * Set the value of the attribute a to the contents of the buffer b which has
+  * a byte-size of l and write it to the NTFS volume vol. 
+  * Return 1 on success and 0 on error, errno will be set in the latter case.
+  *
+  * FIXME: This is only a temporary implementation which doesn't cope with
+  * changes in the length of the resident part of the attribute which in turn
+  * means it doesn't cope with changes in length or on disk location of the
+  * non-resident part of the attribute either! See ntfsfix.c for details.
+  */
  int set_attribute_value(ntfs_volume *vol, ATTRIBUTE_RECORD_HEADER *a, 
  						    unsigned char *b, __u64 l);

[Linux-ntfs-cvs] CVS: linux-ntfs/include disk_io.h,1.3,1.4

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv29232/include

Modified Files:
	disk_io.h 
Log Message:
Inconsisteny fixes.


Index: disk_io.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/disk_io.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -r1.3 -r1.4
*** disk_io.h	2001/01/25 22:25:43	1.3
--- disk_io.h	2001/01/26 00:34:35	1.4
***************
*** 39,43 ****
   * On success return bytes written (0 means nothing written).
   * On error return -1 with errno set appropriately to the return code of 
!  * either lseek, malloc, write or fdatasync.
   */
  __u64 ntfs_pwrite(int fd, const void *b, __u64 count, const __u64 pos);
--- 39,43 ----
   * On success return bytes written (0 means nothing written).
   * On error return -1 with errno set appropriately to the return code of 
!  * either lseek, malloc, write or fdatasync. Or errno is EINVAL if b is null.
   */
  __u64 ntfs_pwrite(int fd, const void *b, __u64 count, const __u64 pos);
***************
*** 55,59 ****
   * On success return bytes written (0 means nothing written).
   * On error return -1 with errno set appropriately to the return code of 
!  * either lseek, malloc, write or fdatasync.
   */
  __u64 mst_pwrite(int fd, const void *b, __u64 count, const __u64 pos);
--- 55,59 ----
   * On success return bytes written (0 means nothing written).
   * On error return -1 with errno set appropriately to the return code of 
!  * either lseek, malloc, write or fdatasync. Or errno is EINVAL if b is null.
   */
  __u64 mst_pwrite(int fd, const void *b, __u64 count, const __u64 pos);
***************
*** 80,84 ****
   * 	 read some blocks successfully (this is subject to change!!!).
   */
! ssize_t ntfs_pread(int fd, void *b, size_t bksize, size_t count, off_t pos);
  
  /**
--- 80,85 ----
   * 	 read some blocks successfully (this is subject to change!!!).
   */
! __u64 ntfs_pread(const int fd, void *b, const __u32 bksize, __u64 count,
! 	         const __u64 pos);
  
  /**
***************
*** 111,115 ****
   * 	 read some blocks successfully (this is subject to change!!!).
   */
! ssize_t mst_pread(int fd, void *b, size_t bksize, size_t count, off_t pos);
  
  /**
--- 112,117 ----
   * 	 read some blocks successfully (this is subject to change!!!).
   */
! __u64 mst_pread(const int fd, void *b, const __u32 bksize, __u64 count,
! 		const __u64 pos);
  
  /**
***************
*** 128,132 ****
   * is performed for this!
   */
! int get_clusters(ntfs_volume *vol, __u8 *buf, __s64 lcn, int count);
  
  /**
--- 130,135 ----
   * is performed for this!
   */
! int get_clusters(const ntfs_volume *vol, __u8 *buf, const __s64 lcn,
! 		 const int count);
  
  /**
***************
*** 142,146 ****
   * caller really only needs to check for sucess / failure.
   */
! int put_clusters(ntfs_volume *vol, const __u8 *buf, __s64 lcn, int count);
  
  /**
--- 145,149 ----
   * caller really only needs to check for sucess / failure.
   */
! int put_clusters(ntfs_volume *vol, const __u8 *buf, const __s64 lcn, int count);
  
  /**
***************
*** 158,162 ****
   * NOTE: @buf has to be at least of size @count * vol->MftRecordSize.
   */
! int get_mft_records(ntfs_volume *vol, __u8 *buf, __s64 mftrec, int count);
  
  /**
--- 161,166 ----
   * NOTE: @buf has to be at least of size @count * vol->MftRecordSize.
   */
! int get_mft_records(const ntfs_volume *vol, __u8 *buf, const __s64 mftrec,
! 		    const int count);
  
  /**
***************
*** 171,175 ****
   * / failure.
   */
! int put_mft_record(ntfs_volume *vol, const __u8 *buf, __s64 mftrec);
  
  
--- 175,179 ----
   * / failure.
   */
! int put_mft_record(ntfs_volume *vol, const __u8 *buf, const __s64 mftrec);
  
  

[Linux-ntfs-cvs] CVS: linux-ntfs/libntfs disk_io.c,NONE,1.1

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/libntfs
In directory usw-pr-cvs1:/tmp/cvs-serv28972

Added Files:
	disk_io.c 
Log Message:
Added disk io functions file.


--- NEW FILE ---
/*
 * disk_io.c - Disk io functions. Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <unistd.h>
#include <stdlib.h>
#include <linux/types.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>

#include "ntfs_rec.h"
#include "attrib.h"
#include "bitmap.h"
#include "volume.h"

__u64 ntfs_pwrite(int fd, const void *b, __u64 count, const __u64 pos)
{
	__u64 written, total;
	char retry;
	
	if (!b) {
		errno = EINVAL;
		return -1;
	}
	if (!count)
		return 0;
	/* Locate to position. */
	if (lseek(fd, pos, SEEK_SET) == (off_t)-1)
		return -1;
	/* Write the data. */
	total = retry = 0;
	do {
		written = write(fd, ((char *)b) + total, count);
		if (written == -1)
			return written;
		else if (!written)
			++retry;
		/* We just recycle count as a local variable here. */
		count -= written;
		total += written;
	} while (count && (retry < 3));
	/* Sync write to disk. */
	if (fdatasync(fd) == -1)
		return -1;
	/* Finally return the number of bytes written. */
	return total;
}

__u64 mst_pwrite(int fd, const void *b, __u64 count, const __u64 pos)
{
	__u64 written, total;
	char retry;
	void *buf;
	
	if (!b) {
		errno = EINVAL;
		return -1;
	}
	if (!count)
		return 0;
	/* Locate to position. */
	if (lseek(fd, pos, SEEK_SET) == (off_t)-1)
		return -1;
	/* Get memory for copy of data. */
	if (!(buf = malloc(count)))
		return -1;
	/* Make a copy of the data. */
	memcpy(buf, b, count);
	/* Prepare copied data for writing. */
	if (pre_write_mst_fixup((NTFS_RECORD_HEADER*)buf, count)) {
		__u16 *usn_pos;
		__u16 usn;
		/*
		 * Ok, need to update usn in original buffer (b) as well,
		 * otherwise two writes of the same data would result in the
		 * same usn being written on top of the same usn, which means
		 * no protection after first write and in fact it actually
		 * would cause corruption and not just lack of protection!!!
		 */
		usn_pos = (__u16*)((__u8*)b + 
				le16_to_cpu(((NTFS_RECORD_HEADER*)b)->usa_ofs));
		usn = le16_to_cpup(usn_pos) + 1;
		if (usn == 0xffff || !usn)
			usn = 1;
		*usn_pos = cpu_to_le16(usn);
	}
	/* Write the prepared data (copy). */
	total = retry = 0;
	do {
		written = write(fd, ((char *)buf) + total, count);
		if (written == -1) {
			free(buf);
			return written;
		}
		else if (!written)
			++retry;
		/* We just recycle count as a local variable here. */
		count -= written;
		total += written;
	} while (count && (retry < 3));
	/* Don't need the copy of the data anymore. */
	free(buf);
	/* Sync write to disk. */
	if (fdatasync(fd) == -1)
		return -1;
	/* Finally return the number of bytes written. */
	return total;
}

__u64 ntfs_pread(const int fd, void *b, const __u32 bksize, __u64 count,
	         const __u64 pos)
{
	__u64 br, btr, total;
	char bksize_bits;
	
	/* Nothing to read so, return 0. */
	if (!count || !bksize)
		return 0;
	/* Calculate bksize_bits. */
	for (bksize_bits = 0, br = bksize; br > 1; br >>= 1)
		++bksize_bits;
	/* Check buffer. Only multiples of NTFS_SECTOR_SIZE and powers of
	   two are alowed for bksize. */
	if (!b || (bksize_bits < NTFS_SECTOR_SIZE_BITS) ||
		       			(bksize != 1 << bksize_bits)) {
#ifdef DEBUG
		if (!b)
			puts("ntfs_pread: b is NULL");
		if (bksize_bits < NTFS_SECTOR_SIZE_BITS)
			puts("ntfs_pread: bksize_bits < NTFS_SECTOR_SIZE_BITS");
		if (bksize != 1 << bksize_bits)
			puts("ntfs_pread: bksize != 1 << bksize_bits");
		puts("Returning EINVAL");
#endif
		errno = EINVAL;
		return -1;
	}
	/* Locate to position. */
	if (lseek(fd, pos, SEEK_SET) == (off_t)-1) {
#ifdef DEBUG
		int eo = errno;
		printf("ntfs_pread: lseek to 0x%Lx returned -1\n", pos);
		errno = eo;
#endif
		return -1;
	}
	/* Read the data. */
	total = 0;
	btr = count << bksize_bits;
	/* Loop until we have read all data even if it happens only a byte at
	   a time. */
	do {
		br = read(fd, ((char *)b) + total, btr);
		if (br == -1)
			return br;
		if (!br) {
			/* Calculate the number of complete blocks read
			   (and recycle count as a local variable). */
			count -= btr >> bksize_bits;
			break;
		}
		btr -= br;
		total += br;
	} while (btr);
	/* Finally, return the number of blocks read. */
	return count;
}

__u64 mst_pread(const int fd, void *b, const __u32 bksize, __u64 count,
		       const __u64 pos)
{
	__u64 br, i;
	char bksize_bits;
	
	/* Do the read. */
	count = ntfs_pread(fd, b, bksize, count, pos);
	/* Calculate bksize_bits. */
	for (bksize_bits = 0, br = bksize; br > 1; br >>= 1)
		++bksize_bits;
	/* Apply fixups to successfully read data. Note, that we disregard
	   any errors returned from the MST fixup function. This is because we
	   want to fixup everything possible and we rely on the fact that the
	   "BAAD" magic will be detected later on anyway (before the data is
	   made use of). */
	for (i = 0; i < count; ++i)
		post_read_mst_fixup((NTFS_RECORD_HEADER*)(b + 
						(i << bksize_bits)), bksize);
	/* Finally, return the number of blocks read. */
	return count;
}

int get_clusters(const ntfs_volume *vol, __u8 *buf, const __s64 lcn,
		 const int count)
{
	__u64 br;
	
	if (!vol || !buf || count < 0 || lcn < 0)
		return -EINVAL;
	if (!vol->fd)
		return -EBADF;
	if (vol->number_of_clusters < lcn + count)
		return -ESPIPE;
	br = ntfs_pread(vol->fd, buf, vol->cluster_size, count, 
						lcn << vol->cluster_size_bits);
	if (br != count) {
		int eo = errno;
#define ESTR "Error reading cluster(s)"
                if (br == -1) {
                        perror(ESTR);
			return -eo;
		} else if (!br)
                        fprintf(stderr, "Error: partition is smaller than "
                                        "it should be!?! Weird!\n");
		else
                        fprintf(stderr, ESTR ": unknown error\n");
#undef ESTR
		return -EIO;
	}
	return br;
}

int put_clusters(ntfs_volume *vol, const __u8 *buf, const __s64 lcn, int count)
{
	__u64 bw;
	
	if (!vol || !buf || count < 0 || lcn < 0)
		return -EINVAL;
	if (!vol->fd)
		return -EBADF;
	if (vol->number_of_clusters < lcn + count)
		return -ESPIPE;
	bw = ntfs_pwrite(vol->fd, buf, count << vol->cluster_size_bits, 
						lcn << vol->cluster_size_bits);
	if (bw != count << vol->cluster_size_bits) {
		int eo = errno;
#define ESTR "Error writting cluster(s)"
                if (bw == -1) {
                        perror(ESTR);
			return -eo;
		} else if (!bw)
                        fprintf(stderr, ESTR ": Ran out of input data!\n");
		else
                        fprintf(stderr, ESTR ": unknown error\n");
#undef ESTR
		return -EIO;
	}
	return bw >> vol->cluster_size_bits;
}

int get_mft_records(const ntfs_volume *vol, __u8 *buf, const __s64 mftrec,
		    const int count)
{
	__u64 br;
	__s64 lcn, ofs;
	
	if (!vol || !buf || mftrec < 0)
		return -EINVAL;
	if (!vol->fd)
		return -EBADF;
	if (vol->number_of_mft_records < mftrec + count)
		return -ESPIPE;
	if (!get_bit(vol->mft_bitmap, mftrec))
		return -ENOENT;
	/* Size of mft record != size of cluster thus need to work with
	   offsets into clusters. */
	if (vol->mft_records_per_cluster) {
		lcn = vcn_to_lcn(vol->mft_runlist,
					mftrec / vol->mft_records_per_cluster);
		/* FIXME: Change "/" above and "%" below to ">>" and "&"
		   respectively! */
		ofs = mftrec % vol->mft_records_per_cluster;
		ofs <<= vol->mft_record_size_bits;
	} else {
		lcn = vcn_to_lcn(vol->mft_runlist,
					mftrec * vol->clusters_per_mft_record);
		/* FIXME: Change "*" above to "<<"! */
		ofs = 0;
	}
	if (lcn < 0) {
		int eo = errno;
		perror("Error determining on disk location of $Mft record");
		return -eo;
	}
	br = mst_pread(vol->fd, buf, vol->mft_record_size, count, 
					(lcn << vol->cluster_size_bits) + ofs);
	if (br != count) {
		int eo = errno;
#define ESTR "Error reading $Mft record"
                if (br == -1) {
                        perror(ESTR);
			return -eo;
		} else if (!br)
                        fprintf(stderr, "Error: partition is smaller than "
                                        "it should be!?! Weird!\n");
		else
                        fprintf(stderr, ESTR ": unknown error\n");
#undef ESTR
		return -EIO;
	}
	return br;
}

int put_mft_record(ntfs_volume *vol, const __u8 *buf, const __s64 mftrec)
{
	__u64 bw;
	__s64 lcn, ofs;
	
	if (!vol || !buf || mftrec < 0)
		return -EINVAL;
	if (!vol->fd)
		return -EBADF;
	if (vol->number_of_mft_records <= mftrec)
		return -ESPIPE;
	if (!get_bit(vol->mft_bitmap, mftrec))
		return -ENOENT;
	/* Size of mft record != size of cluster thus need to work with offsets
	   into clusters. */
	if (vol->mft_records_per_cluster) {
		lcn = vcn_to_lcn(vol->mft_runlist,
					mftrec / vol->mft_records_per_cluster);
		/* FIXME: Change "/" above and "%" below to ">>" and "&"
		   respectively! */
		ofs = mftrec % vol->mft_records_per_cluster;
		ofs <<= vol->mft_record_size_bits;
	} else {
		lcn = vcn_to_lcn(vol->mft_runlist,
					mftrec * vol->clusters_per_mft_record);
		/* FIXME: Change "*" above to "<<"! */
		ofs = 0;
	}
	if (lcn < 0) {
		int eo = errno;
		perror("Error determining on disk location of $Mft record");
		return -eo;
	}
	bw = mst_pwrite(vol->fd, buf, vol->mft_record_size, 
					(lcn << vol->cluster_size_bits) + ofs);
	if (bw != vol->mft_record_size) {
		int eo = errno;
#define ESTR "Error writing $Mft record"
                if (bw == -1) {
                        perror(ESTR);
			return -eo;
		} else if (!bw)
                        fprintf(stderr, ESTR ": Ran out of input data!\n");
		else
                        fprintf(stderr, ESTR ": unknown error\n");
#undef ESTR
		return -EIO;
	}
	return 1;
}

[Linux-ntfs-cvs] CVS: linux-ntfs/libntfs bitmap.c,NONE,1.1 bootsect.c,NONE,1.1 mft.c,NONE,1.1 ntfs_rec.c,NONE,1.1 volume.c,1.1,1.2

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/libntfs
In directory usw-pr-cvs1:/tmp/cvs-serv26977/libntfs

Modified Files:
	volume.c 
Added Files:
	bitmap.c bootsect.c mft.c ntfs_rec.c 
Log Message:
More files added to ntfs lib. Fixed some consistency problems.


--- NEW FILE ---
/*
 * bitmap.c - Bitmap handling code. Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "bitmap.h"

/*
 * NOTES:
 *
 * - Operations are 8-bit only to ensure the functions work both on little
 *   and big endian machines! So don't make them 32-bit ops!
 * - bitmap starts at bit = 0 and ends at bit = bitmap size - 1.
 * - _Caller_ has to make sure that the bit to operate on is less than the
 *   size of the bitmap.
 */

inline void set_bit(__u8 *bitmap, const __u64 bit, const __u8 new_value)
{
	if (!bitmap || new_value > 1)
		return;
	if (!new_value)
		bitmap[bit >> 3] &= ~(1 << (bit & 7));
	else
		bitmap[bit >> 3] |= (1 << (bit & 7));
}

inline char get_bit(const __u8 *bitmap, const __u64 bit)
{
	if (!bitmap)
		return -1;
	return (bitmap[bit >> 3] >> (bit & 7)) & 1;
}

inline char get_and_set_bit(__u8 *bitmap, const __u64 bit,
			    const __u8 new_value)
{
	__u8 b, old_value;
	
	if (!bitmap || new_value > 1)
		return -1;
	b = bitmap[bit >> 3];
	old_value = (b >> (bit & 7)) & 1;
	if (new_value != old_value) {
		if (!new_value)
			bitmap[bit >> 3] = b & ~(1 << (bit & 7)); 
		else
			bitmap[bit >> 3] = b | (1 << (bit & 7));
	}
	return old_value;
}


--- NEW FILE ---
/*
 * bootsect.c - Boot sector handling code. Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <stdio.h>
#include <stdlib.h>
#include <linux/types.h>

#include "bootsect.h"
#include "endians.h"

int is_boot_sector_ntfs(const NTFS_BOOT_SECTOR *b, const int silent)
{
	__u32 i;

	if (!silent)
		printf("\nBeginning bootsector check...\n");
	
	/* Calculate the checksum. */
	if ((void*)b < (void*)&b->checksum) {
		__u32 *u = (__u32 *)b;
		__u32 *bi = (__u32 *)(&b->checksum);

		if (!silent)
			printf("Calculating bootsector checksum... ");
		
		for (i = 0; u < bi; ++u)
			i += le32_to_cpup(u);
		
		if (le32_to_cpu(b->checksum) && le32_to_cpu(b->checksum) != i)
			goto not_ntfs;
		if (!silent)
			puts("OK");
	}

	/* Check OEMidentifier is "NTFS    " */
	if (!silent)
		printf("Checking OEMid... ");
	if (b->oem_id != cpu_to_le64(0x202020205346544e)) /* "NTFS    " */
		goto not_ntfs;
	if (!silent)
		puts("OK");

	/* Check bytes per sector value is between 256 and 4096. */
	if (!silent)
		printf("Checking bytes per sector... ");
	if (le16_to_cpu(b->bpb.bytes_per_sector) <  0x100 ||
	    le16_to_cpu(b->bpb.bytes_per_sector) > 0x1000)
		goto not_ntfs;
	if (!silent)
		puts("OK");

	/* Check sectors per cluster value is valid. */
	if (!silent)
		printf("Checking sectors per cluster... ");
	switch (b->bpb.sectors_per_cluster) {
	case 1: case 2: case 4: case 8: case 16:
	case 32: case 64: case 128:
		break;
	default:
		goto not_ntfs;
	}
	if (!silent)
		puts("OK");

	/* Check reserved/unused fields are really zero. */
	if (!silent)
		printf("Checking reserved fields are zero... ");
	if (le16_to_cpu(b->bpb.reserved_sectors) ||
	    le16_to_cpu(b->bpb.root_entries) ||
	    le16_to_cpu(b->bpb.sectors) ||
	    le16_to_cpu(b->bpb.sectors_per_fat) ||
	    le32_to_cpu(b->bpb.large_sectors) ||
	    b->bpb.fats)
		goto not_ntfs;
	if (!silent)
		puts("OK");

	/* Check clusters per file mft record value is valid. */
	if (!silent)
		printf("Checking clusters per mft record... ");
	if ((__u8)b->clusters_per_mft_record < 0xe1 || 
	    (__u8)b->clusters_per_mft_record > 0xf7) {
		switch (b->clusters_per_mft_record) {
		case 1: case 2: case 4: case 8: case 0x10: case 0x20: case 0x40:
			break;
		default:
			goto not_ntfs;
		}
	}
	if (!silent)
		puts("OK");

	/* Check clusters per index block value is valid. */
	if (!silent)
		printf("Checking clusters per index block... ");
	if ((__u8)b->clusters_per_index_block < 0xe1 || 
	    (__u8)b->clusters_per_index_block > 0xf7) {
		switch (b->clusters_per_index_block) {
		case 1: case 2: case 4: case 8: case 0x10: case 0x20: case 0x40:
			break;
		default:
			goto not_ntfs;
		}
	}
	if (!silent)
		puts("OK");

	if (b->end_of_sector_marker != cpu_to_le16(0xaa55))
		fprintf(stderr, "Warning: Bootsector has invalid end of " \
				"sector marker.\n");

	if (!silent)
		puts("Bootsector check completed successfully.");

	return 1;
not_ntfs:
	if (!silent) {
		puts("FAILED");
		puts("Bootsector check failed. Aborting...");
	}
	return 0;
}


--- NEW FILE ---
/*
 * mft.c - Mft record handling code. Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <linux/types.h>

#include "mft.h"
#include "endians.h"

inline __u32 get_mft_record_data_size(const MFT_RECORD_HEADER *b)
{
	if (!b || !is_mft_recordp(b))
		return 0;

	/* Get the number of used bytes and return it. */
	return le32_to_cpu(b->bytes_in_use);
}


--- NEW FILE ---
/*
 * ntfs_rec.c - NTFS record handling code. Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <linux/types.h>

#include "ntfs_rec.h"
#include "endians.h"

int post_read_mst_fixup(NTFS_RECORD_HEADER *b, const __u32 size)
{
	__u16 usa_ofs, usa_count, usn;
	__u16 *usa_pos, *data_pos;

	/* Setup the variables. */
	usa_ofs = le16_to_cpu(b->usa_ofs);
	usa_count = le16_to_cpu(b->usa_count);
	/* Size and alignement checks. */
	if ( size & (NTFS_SECTOR_SIZE - 1)	||
	     usa_ofs & 1				||
	     usa_ofs + (usa_count * 2) > size	||
	     (size >> NTFS_SECTOR_SIZE_BITS) != usa_count)
		return 1;
	/* Decrement usa_count to get number of fixups. */
	--usa_count;
	/* Position of usn in update sequence array. */  
	usa_pos = (__u16*)b + usa_ofs/sizeof(__u16);
	/* 
	 * The update sequence number which has to be equal to each of the
	 * __u16 values before they are fixed up. Note no need to care for
	 * endianness since we are comparing and moving data for on disk
	 * structures which means the data is consistent. - If it is 
	 * consistenty the wrong endianness it doesn't make any difference.
	 */
	usn = *usa_pos;
	/*
	 * Position in protected data of first __u16 that needs fixing up.
	 */
	data_pos = (__u16*)b + NTFS_SECTOR_SIZE/sizeof(__u16) - 1;
        /* Fixup all sectors. */
	while (usa_count--) {
                if (*data_pos != usn) {
			/*
			 * Incomplete multi sector transfer detected! )-:
			 * Set the magic to "BAAD" and return failure.
			 * Note that magic_BAAD is already converted to le32.
			 */
			b->magic = magic_BAAD;
	                return 0;
		}
		/*
		 * Increment position in usa and restore original data from
		 * the usa into the data buffer.
		 */
		*data_pos = *(++usa_pos);
                /* Increment position in data as well. */
		data_pos += NTFS_SECTOR_SIZE/sizeof(__u16);
        }
	return 1;
}

int pre_write_mst_fixup(NTFS_RECORD_HEADER *b, const __u32 size)
{
	__u16 usa_ofs, usa_count, usn;
	__u16 *usa_pos, *data_pos;

	/* Sanity check + only fixup if it makes sense. */
	if (!b || is_baad_record(b->magic) || is_hole_record(b->magic))
		return 0;
	/* Setup the variables. */
	usa_ofs = le16_to_cpu(b->usa_ofs);
	usa_count = le16_to_cpu(b->usa_count);
	/* Size and alignement checks. */
	if ( size & (NTFS_SECTOR_SIZE - 1)	||
	     usa_ofs & 1				||
	     usa_ofs + (usa_count * 2) > size	||
	     (size >> NTFS_SECTOR_SIZE_BITS) != usa_count)
		return 0;
	/* Decrement usa_count to get number of fixups. */
	--usa_count;
	/* Position of usn in update sequence array. */  
	usa_pos = (__u16*)((__u8*)b + usa_ofs);
	/*
	 * Cyclically increment the update sequence number 
	 * (skipping 0 and -1, i.e. 0xffff).
	 */
	usn = le16_to_cpup(usa_pos) + 1;
	if (usn == 0xffff || !usn)
		usn = 1;
	usn = cpu_to_le16(usn);
	*usa_pos = usn;
	/* Position in data of first __u16 that needs fixing up. */
	data_pos = (__u16*)b + NTFS_SECTOR_SIZE/sizeof(__u16) - 1;
        /* Fixup all sectors. */
        while (usa_count--) {
		/*
		 * Increment the position in the usa and save the 
		 * original data from the data buffer into the usa.
		 */
		*(++usa_pos) = *data_pos;
		/* Apply fixup to data. */
		*data_pos = usn;
		/* Increment position in data as well. */
		data_pos += NTFS_SECTOR_SIZE/sizeof(__u16);
        }
	return 1;
}


Index: volume.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/volume.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** volume.c	2001/01/25 14:00:43	1.1
--- volume.c	2001/01/25 22:25:43	1.2
***************
*** 40,44 ****
          const char *FAILED = "FAILED";
  	ntfs_volume *vol = NULL;
!         BOOT_SECTOR *bs = NULL;
  	MFT_RECORD_HEADER *mb = NULL;
  	ATTRIBUTE_RECORD_HEADER *a;
--- 40,44 ----
          const char *FAILED = "FAILED";
  	ntfs_volume *vol = NULL;
!         NTFS_BOOT_SECTOR *bs = NULL;
  	MFT_RECORD_HEADER *mb = NULL;
  	ATTRIBUTE_RECORD_HEADER *a;
***************
*** 69,73 ****
  	}
  	/* Allocate the boot sector structure. */
!         if (!(bs = (BOOT_SECTOR *)malloc(sizeof(BOOT_SECTOR)))) {
                  puts(FAILED);
                  perror("Error allocating memory for bootsector");
--- 69,73 ----
  	}
  	/* Allocate the boot sector structure. */
!         if (!(bs = (NTFS_BOOT_SECTOR *)malloc(sizeof(NTFS_BOOT_SECTOR)))) {
                  puts(FAILED);
                  perror("Error allocating memory for bootsector");
***************
*** 84,88 ****
          }
          /* Now read the bootsector. */
!         br = ntfs_pread(vol->fd, bs, sizeof(BOOT_SECTOR), 1, 0);
          if (br != 1) {
  		int eo = errno;
--- 84,88 ----
          }
          /* Now read the bootsector. */
!         br = ntfs_pread(vol->fd, bs, sizeof(NTFS_BOOT_SECTOR), 1, 0);
          if (br != 1) {
  		int eo = errno;

[Linux-ntfs-cvs] CVS: linux-ntfs/include bitmap.h,1.1,1.2 bootsect.h,1.1,1.2 disk_io.h,1.2,1.3

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv26977/include

Modified Files:
	bitmap.h bootsect.h disk_io.h 
Log Message:
More files added to ntfs lib. Fixed some consistency problems.


Index: bitmap.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/bitmap.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** bitmap.h	2001/01/24 15:01:18	1.1
--- bitmap.h	2001/01/25 22:25:43	1.2
***************
*** 39,47 ****
   * @bitmap:	field of bits
   * @bit:	bit to set
!  * @newvalue:	value to set bit to (0 or 1)
   *
!  * Set the bit @bit in the @bitmap to @newvalue. Ignore all errors.
   */
! extern inline void set_bit(__u8 *bitmap, __u64 bit, __u8 newvalue);
  
  /**
--- 39,48 ----
   * @bitmap:	field of bits
   * @bit:	bit to set
!  * @new_value:	value to set bit to (0 or 1)
   *
!  * Set the bit @bit in the @bitmap to @new_value. Ignore all errors.
   */
! extern inline void set_bit(__u8 *bitmap, const __u64 bit,
! 			   const __u8 new_value);
  
  /**
***************
*** 50,68 ****
   * @bit:	bit to get
   * 
!  * Get and return the value of the bit @bit in @bitmap (0 or 1). Return -1 on
!  * error.
   */
! extern inline char get_bit(__u8 *bitmap, __u64 bit);
  
  /**
!  * get_and_set_bit - get value of a bit in a field of bits and set it afterwards
   * @bitmap:	field of bits
   * @bit:	bit to get/set
!  * @newvalue:	value to set bit to (0 or 1)
   * 
!  * Return the value of the bit @bit and set it to @newvalue (0 or 1). Return -1
!  * on error.
   */
! extern inline char get_and_set_bit(__u8 *bitmap, __u64 bit, __u8 newvalue);
  
  #endif /* defined BITMAP_H */
--- 51,70 ----
   * @bit:	bit to get
   * 
!  * Get and return the value of the bit @bit in @bitmap (0 or 1).
!  * Return -1 on error.
   */
! extern inline char get_bit(const __u8 *bitmap, const __u64 bit);
  
  /**
!  * get_and_set_bit - get value of a bit in a field of bits and set it
   * @bitmap:	field of bits
   * @bit:	bit to get/set
!  * @new_value:	value to set bit to (0 or 1)
   * 
!  * Return the value of the bit @bit and set it to @new_value (0 or 1).
!  * Return -1 on error.
   */
! extern inline char get_and_set_bit(__u8 *bitmap, const __u64 bit,
! 				   const __u8 new_value);
  
  #endif /* defined BITMAP_H */

Index: bootsect.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/bootsect.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** bootsect.h	2001/01/24 20:37:36	1.1
--- bootsect.h	2001/01/25 22:25:43	1.2
***************
*** 25,38 ****
  
  
! /* The NTFS OEMid */
  #define magicNTFS	cpu_to_le64(0x202020205346544e) /* "NTFS    " */
  
  /*
   * Location of bootsector on partition:
!  * 	The standard PACKED_BOOT_SECTOR is on sector 0 of the partition.
   * 	On NT4 and above there is one backup copy of the boot sector to
   * 	be found on the last sector of the partition (not normally accessible
!  * 	from within Windows as the bootsector contained number of sectors value
!  * 	is one less than the actual value!).
   * 	On versions of NT 3.51 and earlier, the backup copy was located at 
   * 	number of sectors/2, i.e. in the middle of the volume.
--- 25,38 ----
  
  
! /* The NTFS oem_id */
  #define magicNTFS	cpu_to_le64(0x202020205346544e) /* "NTFS    " */
  
  /*
   * Location of bootsector on partition:
!  * 	The standard NTFS_BOOT_SECTOR is on sector 0 of the partition.
   * 	On NT4 and above there is one backup copy of the boot sector to
   * 	be found on the last sector of the partition (not normally accessible
!  * 	from within Windows as the bootsector contained number of sectors
!  *	value is one less than the actual value!).
   * 	On versions of NT 3.51 and earlier, the backup copy was located at 
   * 	number of sectors/2, i.e. in the middle of the volume.
***************
*** 88,97 ****
   * 
   * This function checks the boot sector in @b for describing a valid ntfs
!  * volume. Return 1 if @b is a NTFS boot sector or 0 otherwise. If silent is 0
!  * progress output will be output to stdout. If silent is 1 no output to stdout
!  * will occur. Errors/warnings to stderr will occur disregarding the value of
!  * silent.
   */
! int is_boot_sector_ntfs(PACKED_BOOT_SECTOR *b, int silent);
  
  #endif /* defined BOOTSECT_H */
--- 88,97 ----
   * 
   * This function checks the boot sector in @b for describing a valid ntfs
!  * volume. Return 1 if @b is a valid NTFS boot sector or 0 otherwise. If
!  * silent is 0, progress output will be output to stdout. If silent is 1 no
!  * output to stdout will occur. Errors/warnings to stderr will occur
!  * disregarding the value of silent.
   */
! int is_boot_sector_ntfs(const NTFS_BOOT_SECTOR *b, const int silent);
  
  #endif /* defined BOOTSECT_H */

Index: disk_io.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/disk_io.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -r1.2 -r1.3
*** disk_io.h	2001/01/24 20:37:36	1.2
--- disk_io.h	2001/01/25 22:25:43	1.3
***************
*** 41,45 ****
   * either lseek, malloc, write or fdatasync.
   */
! ssize_t ntfs_pwrite(int fd, const void *b, size_t count, off_t pos);
  
  /**
--- 41,45 ----
   * either lseek, malloc, write or fdatasync.
   */
! __u64 ntfs_pwrite(int fd, const void *b, __u64 count, const __u64 pos);
  
  /**
***************
*** 57,61 ****
   * either lseek, malloc, write or fdatasync.
   */
! ssize_t mst_pwrite(int fd, const void *b, size_t count, off_t pos);
  
  /**
--- 57,61 ----
   * either lseek, malloc, write or fdatasync.
   */
! __u64 mst_pwrite(int fd, const void *b, __u64 count, const __u64 pos);
  
  /**

[Linux-ntfs-cvs] CVS: linux-ntfs/libntfs volume.c,NONE,1.1

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/libntfs
In directory usw-pr-cvs1:/tmp/cvs-serv25241/libntfs

Added Files:
	volume.c 
Log Message:
Added volume.c code and fixed some typos and inconsistencies.


--- NEW FILE ---
/*
 * volume.c - NTFS volume handling code. Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <linux/types.h>

#include "endians.h"
#include "attrib.h"
#include "volume.h"
#include "bootsect.h"
#include "disk_io.h"
#include "mft.h"

ntfs_volume *ntfs_open(const char *name)
{
        const char *OK = "OK";
        const char *FAILED = "FAILED";
	ntfs_volume *vol = NULL;
        BOOT_SECTOR *bs = NULL;
	MFT_RECORD_HEADER *mb = NULL;
	ATTRIBUTE_RECORD_HEADER *a;
	VOLUME_INFORMATION *vinf;
	__u32 u;
	__u64 l;
	ssize_t br;
	__u8 SectorsPerCluster, bits;
	__s8 c;
       	
	if (!name) {
		errno = EINVAL;
		return NULL;
	}
	/* Allocate the volume structure. */
	if (!(vol = (ntfs_volume *)malloc(sizeof(ntfs_volume)))) {
		perror("Error allocating memory for ntfs volume structure");
		errno = ENOMEM;
		goto error_exit;
	}
        /* Zero the volume structure. */
        memset(vol, 0, sizeof(ntfs_volume));
	/* Make a copy of the partition name. */
	if (!(vol->dev_name = strdup(name))) {
		perror("Error allocating memory for partition name");
		errno = ENOMEM;
		goto error_exit;
	}
	/* Allocate the boot sector structure. */
        if (!(bs = (BOOT_SECTOR *)malloc(sizeof(BOOT_SECTOR)))) {
                puts(FAILED);
                perror("Error allocating memory for bootsector");
		errno = ENOMEM;
		goto error_exit;
        }
        printf("Reading bootsector... ");
        if ((vol->fd = open(name, O_RDWR)) == -1) {
		int eo = errno;
                puts(FAILED);
                perror("Error opening partition file");
		errno = eo;
		goto error_exit;
        }
        /* Now read the bootsector. */
        br = ntfs_pread(vol->fd, bs, sizeof(BOOT_SECTOR), 1, 0);
        if (br != 1) {
		int eo = errno;
                puts(FAILED);
#define ESTR "Error reading bootsector"
                if (br == -1) {
                        perror(ESTR);
			errno = eo;
		} else if (!br) {
                        fprintf(stderr, "Error: partition is smaller than " \
                                        "bootsector size. Weird!\n");
			errno = EINVAL;
		} else {
                        fprintf(stderr, ESTR ": unknown error\n");
			errno = EINVAL;
		}
#undef ESTR
                goto error_exit;
        }
        puts(OK);
        if (!is_boot_sector_ntfs(bs, 0)) {
                fprintf(stderr, "Error: %s is not a valid NTFS partition!\n",
                                name);
		errno = EINVAL;
                goto error_exit;
        }
        /* The bounds checks on mft_lcn and mft_mirr_lcn (i.e. them being
           below or equal the number_of_clusters) really belong in the
           is_boot_sector_ntfs but in this way we can just do this once. */
        sectors_per_cluster = bs->bpb.sectors_per_cluster;
#ifdef DEBUG
	printf("NumberOfSectors = %Li\n", sle64_to_cpu(bs->number_of_sectors));
        printf("SectorsPerCluster = 0x%x\n", sectors_per_cluster);
#endif
        for (bits = 0; sectors_per_cluster > 1; sectors_per_cluster >>= 1)
                bits++;
        sectors_per_cluster = bs->bpb.sectors_per_cluster;

        vol->number_of_clusters = sle64_to_cpu(bs->number_of_sectors) >> bits;

        vol->mft_lcn = sle64_to_cpu(bs->mft_lcn);
        vol->mftmirr_lcn = sle64_to_cpu(bs->mftmirr_lcn);

        if ((vol->mft_lcn > vol->number_of_clusters) ||
            (vol->mftmirr_lcn > vol->number_of_clusters)) {
                fprintf(stderr, "Error: %s is not a valid NTFS partition! " \
                                "($Mft LCN or\n$MftMirr LCN is greater than " \
                                "the number of clusters!\n", name);
		errno = EINVAL;
                goto error_exit;
        }
        vol->cluster_size = sectors_per_cluster *
                                     le16_to_cpu(bs->bpb.bytes_per_sector);
	u = vol->cluster_size;
        for (bits = 0; u > 1; u >>= 1)
                bits++;
        vol->cluster_size_bits = bits;
	
        /* Need to get the clusters per mft record and handle it if it is
           negative. Then calculate the mft_record_size and replace the
           cluster_size with the mft_record_size where applicable below!
           A value of 0x80 is illegal, thus signed char is actually ok! */
        c = bs->clusters_per_mft_record;
#ifdef DEBUG
        printf("ClusterSize = 0x%x\n", vol->cluster_size);
	printf("ClusterSizeBits = %u\n", vol->cluster_size_bits);
        printf("ClustersPerMftRecord = 0x%x\n", c);
#endif
	/* When clusters_per_mft_record is negative, it means that it is to
	   be taken to be the negative base 2 logarithm of the mft_record_size
	   in bytes. Then:
	  	 mft_record_size = 2^(-clusters_per_mft_record) bytes. */
        if (c < 0)
                vol->mft_record_size = 1 << -c;
        else
                vol->mft_record_size = vol->cluster_size * c;
	u = vol->mft_record_size;
        for (bits = 0; u > 1; u >>= 1)
                bits++;
        vol->mft_record_size_bits = bits;
	if (vol->cluster_size > vol->mft_record_size) {
		vol->mft_records_per_cluster = vol->cluster_size / 
							vol->mft_record_size;
		vol->clusters_per_mft_record = 0;
	} else {
		vol->mft_records_per_cluster = 0;
		vol->clusters_per_mft_record = vol->mft_record_size / 
							vol->cluster_size;
	}
#ifdef DEBUG
        printf("MftRecordSize = 0x%x\n", vol->mft_record_size);
	printf("MftRecordSizeBits = %u\n", vol->mft_record_size_bits);
	printf("There are %i mft records in each cluster.\n", 
						vol->mft_records_per_cluster);
	printf("There are %i clusters in each mft record.\n", 
						vol->clusters_per_mft_record);
#endif
	/* Start with $Mft. */
	printf("Loading $Mft... ");
	if (!(mb = (MFT_RECORD_HEADER *)malloc(vol->mft_record_size))) {
                puts(FAILED);
                perror("Error allocating memory for $Mft");
		errno = ENOMEM;
		goto error_exit;
        }
	/* Can't use get_mft_records yet!!! */
	br = mst_pread(vol->fd, (char *)mb, vol->mft_record_size, 1, 
					vol->mft_lcn << vol->cluster_size_bits);
	if (br != 1) {
		puts(FAILED);
#define ESTR "Error reading $Mft"
		if (br == -1)
			perror(ESTR);
		else if (br < 4)
			fprintf(stderr, "Error: $Mft LCN is outside of "
					"the partition?!?\n");
		else
	                fprintf(stderr, ESTR ": unknown error\n");
#undef ESTR
		errno = EIO;
		goto error_exit;
	}
	if (is_baad_record(mb)) {
		puts(FAILED);
                fprintf(stderr, "Error: Incomplete multi sector "
		                "transfer detected in $Mft.\nCannot "
		                "handle this yet. )-:\n");
		errno = EIO;
		goto error_exit;
	}
        if (!is_mft_recordp(mb)) {
                puts(FAILED);
                fprintf(stderr, "Error: Invalid mft record for $Mft.\n"
                                "Cannot handle this yet. )-:\n");
		errno = EIO;
		goto error_exit;
        }
	/* Find the bitmap attribute. */
	a = find_attribute(mb, $BITMAP, NULL);
	if (!a) {
		puts(FAILED);
		fprintf(stderr, "$bitmap attribute not found in $Mft?!?\n");
		errno = EIO;
		goto error_exit;
	}
	/* Get attribute value size and allocate a big enough buffer.*/
	l = get_attribute_value_length(a);
	if (!l) {
		puts(OK);
		puts("Error: $bitmap in $Mft has zero length! T'is weird!");
		errno = EIO;
		goto error_exit;
	}
	vol->mft_bitmap = (__u8*)malloc(l);
	if (!vol->mft_bitmap) {
		puts(FAILED);
		puts("Not enough memory to load bitmap attribute from $Mft.");
		errno = ENOMEM;
		goto error_exit;
	}
	/* Read in the bitmap attribute value into the buffer. */
	if (l != get_attribute_value(vol, a, vol->mft_bitmap)) {
		puts(FAILED);
		puts("Amount of data read does not correspond to expected "
		     "length!");
		errno = EIO;
		goto error_exit;
	}
	/* Find the $DATA attribute in $Mft. */
	a = find_attribute(mb, $DATA, NULL);
	if (!a) {
		puts(FAILED);
		fprintf(stderr, "$DATA attribute not found in $Mft?!?\n");
		errno = EIO;
		goto error_exit;
	}
	/* Determine the number of mft records in $Mft. */
	vol->number_of_mft_records = 
		((NONRESIDENT_ATTRIBUTE_RECORD_HEADER*)a)->data_size >> 
						vol->mft_record_size_bits;
	/* The $DATA attribute of the $Mft has to be non-resident. */
	if (!a->non_resident) {
		puts(FAILED);
		fprintf(stderr, "$Mft $DATA attribute is resident!?!\n");
		errno = EINVAL;
		goto error_exit;
	}
	/* Get the run list. */
	vol->mft_runlist = decompress_run_list(
				      (NONRESIDENT_ATTRIBUTE_RECORD_HEADER*)a);
	if (!vol->mft_runlist) {
		puts(FAILED);
		fprintf(stderr, "Error decompressing run list from $Mft $DATA"
			        " attribute.\n");
		errno = EINVAL;
		goto error_exit;
	}
	puts(OK);
	/* Now load the bitmap from $Bitmap. */
	printf("Loading $Bitmap... ");
	br = get_mft_records(vol, (char*)mb, 6, 1);
	if (br != 1) {
		puts(FAILED);
		errno = EIO;
		goto error_exit;
	}
	if (is_baad_record(mb)) {
		puts(FAILED);
                fprintf(stderr, "Error: Incomplete multi sector "
		                "transfer detected in $Bitmap.\nCannot "
		                "handle this yet. )-:\n");
		errno = EIO;
		goto error_exit;
	}
        if (!is_mft_recordp(mb)) {
                puts(FAILED);
                fprintf(stderr, "Error: Invalid $Mft record for $Bitmap.\n"
                                "Cannot handle this yet. )-:\n");
		printf("Record is of type: %c%c%c%c\n", ((char*)mb)[0], 
							((char*)mb)[1], 
							((char*)mb)[2], 
							((char*)mb)[3]);
		errno = EIO;
		goto error_exit;
        }
	/* Find the bitmap (it is in the $DATA attribute). */
	a = find_attribute(mb, $DATA, NULL);
	if (!a) {
		puts(FAILED);
		fprintf(stderr, "bitmap attribute not found in $Bitmap?!?\n");
		errno = EIO;
		goto error_exit;
	}
	/* Get attribute value size and allocate a big enough buffer.*/
	l = get_attribute_value_length(a);
	if (!l) {
		puts(OK);
		puts("Error: bitmap in $Bitmap has zero length! T'is weird!");
		errno = EIO;
		goto error_exit;
	}
	vol->lcn_bitmap = (__u8*)malloc(l);
	if (!vol->lcn_bitmap) {
		puts(FAILED);
		puts("Not enough memory to load $Bitmap.");
		errno = ENOMEM;
		goto error_exit;
	}
	/* Read in the bitmap attribute value into the buffer. */
	if (l != get_attribute_value(vol, a, vol->lcn_bitmap)) {
		puts(FAILED);
		puts("Amount of data read does not correspond to expected "
		     "length!");
		errno = EIO;
		goto error_exit;
	}
	puts(OK);
	/* Now load the upcase table from $UpCase. */
	printf("Loading $UpCase... ");
	br = get_mft_records(vol, (char*)mb, 10, 1);
	if (br != 1) {
		puts(FAILED);
		errno = EIO;
		goto error_exit;
	}
	if (is_baad_record(mb)) {
		puts(FAILED);
                fprintf(stderr, "Error: Incomplete multi sector "
		                "transfer detected in $UpCase.\nCannot "
		                "handle this yet. )-:\n");
		errno = EIO;
		goto error_exit;
	}
        if (!is_mft_recordp(mb)) {
                puts(FAILED);
                fprintf(stderr, "Error: Invalid $Mft record for $UpCase.\n"
                                "Cannot handle this yet. )-:\n");
		errno = EIO;
		goto error_exit;
        }
	/* Find the bitmap (it is in the $DATA attribute). */
	a = find_attribute(mb, $DATA, NULL);
	if (!a) {
		puts(FAILED);
		fprintf(stderr, "$DATA attribute not found in $UpCase?!?\n");
		errno = EIO;
		goto error_exit;
	}
	/* Get attribute value size and allocate a big enough buffer.*/
	l = get_attribute_value_length(a);
	if (!l) {
		puts(OK);
		puts("Error: $DATA in $UpCase has zero length! T'is weird!");
		errno = EIO;
		goto error_exit;
	}
	/* The upcase table has by definition to have a length equal to 
	   65536 2-byte Unicode characters. */
	if (l != 65536 * 2) {
		puts(OK);
		puts("Error: Upcase table (in $UpCase) has incorrect length!");
		errno = EINVAL;
		goto error_exit;
	}
	vol->upcase = (__u16*)malloc(l);
	if (!vol->upcase) {
		puts(FAILED);
		puts("Not enough memory to load $UpCase.");
		errno = ENOMEM;
		goto error_exit;
	}
	/* Read in the $DATA attribute value into the buffer. */
	if (l != get_attribute_value(vol, a, (__u8*)vol->upcase)) {
		puts(FAILED);
		puts("Amount of data read does not correspond to expected "
		     "length!");
		errno = EIO;
		goto error_exit;
	}
	puts(OK);
	/* Now load $Volume and set the version information and flags in the
	   vol structure accordingly. */
	printf("Loading $Volume... ");
	br = get_mft_records(vol, (char*)mb, 3, 1);
	if (br != 1) {
		puts(FAILED);
		errno = EIO;
		goto error_exit;
	}
	if (is_baad_record(mb)) {
		puts(FAILED);
                fprintf(stderr, "Error: Incomplete multi sector "
		                "transfer detected in $Volume.\nCannot "
		                "handle this yet. )-:\n");
		errno = EIO;
		goto error_exit;
	}
        if (!is_mft_recordp(mb)) {
                puts(FAILED);
                fprintf(stderr, "Error: Invalid $Mft record for $Volume.\n"
                                "Cannot handle this yet. )-:\n");
		errno = EIO;
		goto error_exit;
        }
	/* Find the $VOLUME_INFORMATION attribute. */
	a = find_attribute(mb, $VOLUME_INFORMATION, NULL);
	if (!a) {
		puts(FAILED);
		fprintf(stderr, "$VOLUME_INFORMATION attribute not found in "
				"$Volume?!?\n");
		errno = EIO;
		goto error_exit;
	}
        /* Has to be resident. */
        if (a->non_resident) {
                fprintf(stderr, "Error: Attribute $VOLUME_INFORMATION must " \
                                "be resident (and it isn't)!\n");
                errno = EIO;
		goto error_exit;
        }
	/* Get a pointer to the value of the attribute. */
#define RA(x) ((RESIDENT_ATTRIBUTE_RECORD_HEADER*)(x))
	vinf = (VOLUME_INFORMATION*)(le16_to_cpu(RA(a)->value_offset) + 
								    (char*)a);
	/* Sanity checks. */
	if ((char*)vinf + le32_to_cpu(RA(a)->value_length) > 
				le16_to_cpu(mb->bytes_in_use) + (char*)mb ||
				le16_to_cpu(RA(a)->value_offset) + 
				le32_to_cpu(RA(a)->value_length) >
						le32_to_cpu(a->length)) {
		fprintf(stderr, "Error: Attribute $VOLUME_INFORMATION in " \
				"$Volume is corrupt!\n");
		errno = EIO;
		goto error_exit;
	}
#undef RA
	/* Setup vol from the volume information attribute value. */
        vol->major_ver = vinf->major_ver;
	vol->minor_ver = vinf->minor_ver;
	/* Do not use le16_to_cpu() macro here as our VOLUME_FLAGS are
	   defined using cpu_to_le16() macro and hence are consistent. */
	vol->flags = vinf->flags;
	/* Phew! Done. */

	/* FIXME: Need to initialise vol->dev_name as well. */

	puts(OK);
	free(mb);
	
	/* FIXME: Need to deal with $AttrDef (4). */

	return vol;

error_exit:
	{
		int eo = errno;
		
		if (bs)
			free(bs);
		if (mb)
			free(mb);
		if (vol) {
			if (vol->fd)
				close(vol->fd);
			if (vol->dev_name)
				free(vol->dev_name);
			if (vol->vol_name)
				free(vol->vol_name);
			if (vol->lcn_bitmap)
				free(vol->lcn_bitmap);
			if (vol->mft_bitmap)
				free(vol->mft_bitmap);
			if (vol->mft_runlist)
				free(vol->mft_runlist);
			if (vol->upcase)
				free(vol->upcase);
			free(vol);
		}
		errno = eo;
	}
	return NULL;
}

int ntfs_close(ntfs_volume *vol, const int force)
{
	if (!vol) {
		errno = EINVAL;
		return 0;
	}
	/* FIXME: Do the cleanup. */
	if (vol->fd)
		close(vol->fd);
	if (vol->dev_name)
		free(vol->dev_name);
	if (vol->vol_name)
		free(vol->vol_name);
	if (vol->lcn_bitmap)
		free(vol->lcn_bitmap);
	if (vol->mft_bitmap)
		free(vol->mft_bitmap);
	if (vol->mft_runlist)
		free(vol->mft_runlist);
	if (vol->upcase)
		free(vol->upcase);
	free(vol);
	return 1;
}

[Linux-ntfs-cvs] CVS: linux-ntfs/include volume.h,1.1,1.2

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv25241/include

Modified Files:
	volume.h 
Log Message:
Added volume.c code and fixed some typos and inconsistencies.


Index: volume.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/volume.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** volume.h	2001/01/24 02:13:24	1.1
--- volume.h	2001/01/25 14:00:43	1.2
***************
*** 54,58 ****
  typedef struct {
  	int fd;			/* File descriptor associated with volume. */
! 	char *dev_name;		/* Name of the device the volume is on. */
  	char *vol_name;		/* Name of the volume from the volume name
  				   attribute. */
--- 54,58 ----
  typedef struct {
  	int fd;			/* File descriptor associated with volume. */
! 	char *dev_name;		/* Name of the device/file the volume is in. */
  	char *vol_name;		/* Name of the volume from the volume name
  				   attribute. */
***************
*** 84,88 ****
  	__s64 number_of_mft_records;	/* Number of records in the mft, equals
  					   the number of bits in mft_bitmap. */
! 	__u16 *up_case[65536];		/* Upper case equivalents of all 65536 
  					   2-byte Unicode characters. Obtained
  					   from FILE_$UpCase. */
--- 84,88 ----
  	__s64 number_of_mft_records;	/* Number of records in the mft, equals
  					   the number of bits in mft_bitmap. */
! 	__u16 *upcase[65536];		/* Upper case equivalents of all 65536 
  					   2-byte Unicode characters. Obtained
  					   from FILE_$UpCase. */
***************
*** 98,108 ****
  /**
   * ntfs_open - open ntfs volume
!  * @dev_name: name of device to open
   *
!  * This function opens an ntfs volume. @dev_name should contain the name
!  * of the device to open as the ntfs volume.
   * 
!  * The function opens the device @dev_name and verifies that it contains a
!  * valid bootsector. Then, it allocates a ntfs_volume structure and initializes
   * some of the values inside the structure from the information stored in the
   * bootsector. It proceeds to load the necessary system files and completes
--- 98,108 ----
  /**
   * ntfs_open - open ntfs volume
!  * @name: name of device/file to open
   *
!  * This function opens an ntfs volume. @name should contain the name of the
!  * device/file to open as the ntfs volume.
   * 
!  * The function opens the device or file @name and verifies that it contains a
!  * valid bootsector. Then, it allocates an ntfs_volume structure and initializes
   * some of the values inside the structure from the information stored in the
   * bootsector. It proceeds to load the necessary system files and completes
***************
*** 112,116 ****
   * On error, the return value is NULL and errno is set appropriately.
   *
!  * Note, that a copy is made of @dev_name, and hence it can be discarded as
   * soon as the function returns.
   *
--- 112,116 ----
   * On error, the return value is NULL and errno is set appropriately.
   *
!  * Note, that a copy is made of @name, and hence it can be discarded as
   * soon as the function returns.
   *
***************
*** 118,122 ****
   * means.
   */
! ntfs_volume *ntfs_open(char *dev_name);
  
  /**
--- 118,122 ----
   * means.
   */
! ntfs_volume *ntfs_open(const char *name);
  
  /**
***************
*** 146,150 ****
   * means.
   */
! int ntfs_close(ntfs_volume *vol, int force);
  
  #endif /* defined VOLUME_H */
--- 146,150 ----
   * means.
   */
! int ntfs_close(ntfs_volume *vol, const int force);
  
  #endif /* defined VOLUME_H */

[Linux-ntfs-cvs] CVS: linux-ntfs/ntfstools ntfsfix.c,NONE,1.1

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/ntfstools
In directory usw-pr-cvs1:/tmp/cvs-serv10246/ntfstools

Added Files:
	ntfsfix.c 
Log Message:
Added ntfsfix program.


--- NEW FILE ---
const char *EXEC_NAME = "NtfsFix";
const char *EXEC_VERSION = "0.0.2";
/*
 * NtfsFix - Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This utility will attempt to fix a partition that has been damaged by the
 * current Linux-NTFS driver. It should be run after dismounting a NTFS
 * partition that has been mounted read-write under Linux and before rebooting
 * into Windows NT/2000. NtfsFix can be run even after Windows has had mounted
 * the partition, but it might be too late and irreversible damage to the data
 * might have been done already.
 *
 * 	Anton Altaparmakov <ai...@ca...>
 *
 * 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 (in the main directory of the Linux-NTFS source
 * in the file COPYING); if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 * WARNING: This program might not work on architectures which do not allow 
 * unaligned access. For those, the program would need to start using 
 * get/put_unaligned macros (#include <asm/unaligned.h>), but not doing it yet,
 * since NTFS really mostly applies to ia32 only, which does allow unaligned
 * accesses. We might not actually have a problem though, since the structs are 
 * defined as being packed so that might be enough for gcc to insert the 
 * correct code.
 *
 * If anyone using a non-little endian and/or an aligned access only CPU tries
 * this program please let me know whether it works or not!
 *
 * 	Anton Altaparmakov <ai...@ca...>
 */

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <linux/types.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

#include "attrib.h"
#include "endians.h"
#include "mft.h"
#include "disk_io.h"
#include "volume.h"
#include "logfile.h"

int main(int argc, char **argv)
{
	const char *OK = "OK";
	const char *FAILED = "FAILED";
	unsigned char *b1 = NULL;
	unsigned char *b2 = NULL;
	int i, ebits;
	ssize_t br;
	NONRESIDENT_ATTRIBUTE_RECORD_HEADER *a;
	__u64 l;
	unsigned char *lfd;
	ntfs_volume *vol = NULL;
	__u16 flags;

	printf("\n");
	if (argc != 2) {
		printf("NtfsFix v%s - Attempt to fix an NTFS parition that "
		       "has been damaged by the\nLinux NTFS driver. Note that "
		       "you should run it every time after you have used\nthe "
		       "Linux NTFS driver to write to an NTFS partition to "
		       "prevent massive data\ncorruption from happening when "
		       "Windows mounts the partition.\nIMPORTANT: Run this "
		       "only *after* unmounting the partition in Linux but "
		       "*before*\nrebooting into Windows NT/2000 or you *will*"
		       " suffer! - You have been warned!\n\n"
		       /* Generic copyright / disclaimer. */
		       "Copyright (c) 2000, 2001 Anton Altaparmakov.\n"
		       "%s is free software, released under the GNU "
		       "General Public License and you\nare welcome to "
		       "redistribute it under certain conditions.\n"
		       "%s comes with ABSOLUTELY NO WARRANTY; for details"
		       "read the file GNU\nGeneral Public License to be found "
		       "in the file COPYING in the main Linux-NTFS\n"
		       "distribution directory.\n\n"
		       /* Generic part ends here. */
		       "Syntax: ntfsfix partition_name\n"
		       "        e.g. ntfsfix /dev/hda6\n\n", EXEC_VERSION,
		       EXEC_NAME, EXEC_NAME);
		fprintf(stderr, "Error: incorrect syntax\n");
		exit(1);
	}
	vol = ntfs_open(argv[1]);
	if (!vol) {
		perror("ntfs_open() failed");
		exit(1);
	}
	
/* Lazyness caused define for offset from one Mft record to the next. (-; */
#define mrs (vol->MftRecordSize)

	printf("\nBeginning processing of the $Mft and $MftMirr...\n");
	b1 = (__u8 *)malloc(mrs * 8);
	if (!b1) {
		perror("Error allocating internal buffers");
		goto error_exit;
	}
	b2 = b1 + (mrs * 4);
#ifdef DEBUG
	printf("$Mft LCN = 0x%Lx\n", vol->mft_lcn);
	printf("$MftMirr LCN = 0x%Lx\n", vol->mftmirr_lcn);
#endif
	/* Read $MFT and $MFTmirr. */
	printf("Going to read $Mft... ");
	br = get_mft_records(vol, b1, 0, 4);
	if (br != 4) {
		puts(FAILED);
		goto error_exit;
	}
	puts(OK);
	/* Use mst_pread as we don't want to rely on information in $Mft for
	 * locating $MftMirr as that would defeat the point of $MftMirr. */
	printf("Going to read $MftMirr... ");
	br = mst_pread(vol->fd, b2, mrs, 4, vol->mftmirr_lcn <<
		       				vol->cluster_size_bits);
	if (br != 4) {
		puts(FAILED);
#define ESTR "Error reading $MftMirr"
		if (br == -1)
			perror(ESTR);
		else if (br < 4)
			fprintf(stderr, "Error: $MftMirr LCN is outside of "
					"the partition!\nIs it maybe part of "
					"a RAID array?\n");
		else
	                fprintf(stderr, ESTR ": unknown error\n");
#undef ESTR
		goto error_exit;
	}
	puts(OK);
	/* Check first four Mft records. */
	printf("Checking first four entries in $Mft. ");
	for (i = 0; i < 4; ++i) {
		const char *ESTR[4] = { "$Mft", "$MftMirr", "$LogFile", 
					"$Volume" };
		
		if (is_baad_record(b1 + (i * mrs))) {
			puts(FAILED);
			fprintf(stderr, "Error: Incomplete multi sector "
				       	"transfer detected in %s.\nCannot "
				       	"handle this yet. )-:\n", ESTR[i]);
			goto error_exit;
		}
		if (!is_mft_recordp(b1 + (i * mrs))) {
			puts(FAILED);
			fprintf(stderr, "Error: Invalid $Mft record for %s.\n"
					"Cannot handle this yet. )-:\n",
								      ESTR[i]);
			goto error_exit;
		}
		printf("%s\b. ", i == 0? "\b": "");
	}
	puts(OK);
	/*
	 * FIXME: Need to actually check the $MftMirr for being real. Otherwise
	 * we might corrupt the partition if someone is experimenting with
	 * software RAID and the $MftMirr is not actually in the position we
	 * expect it to be... )-:
	 * FIXME: We should emit a warning it $MftMirr is damanged and ask
	 * user whether to recreate it from $Mft or whether to abort. - The
	 * warning needs to include the danger of software RAID arrays.
	 * Maybe we should go as far as to detect whether we are running on a
	 * MD disk and if yes then bomb out right at the start of the program?
	 */
	/* Check the four MftMirr records. */
	printf("Checking entries in $MftMirr. ");
	for (i = 0; i < 4; ++i) {
		const char *ESTR[4] = { "$Mft", "$MftMirr", "$LogFile", 
					"$Volume" };
		
		if (is_baad_record(b2 + (i * mrs))) {
			puts(FAILED);
			fprintf(stderr, "Error: Incomplete multi sector "
				       	"transfer detected in %s.\nCannot "
				       	"handle this yet. )-:\n", ESTR[i]);
			goto error_exit;
		}
		if (!is_mft_recordp(b2 + (i * mrs))) {
			puts(FAILED);
			fprintf(stderr, "Error: Invalid $MftMirr record for %s.\n"
					"Cannot handle this yet. )-:\n",
								      ESTR[i]);
			goto error_exit;
		}
		printf("%s\b. ", i == 0? "\b": "");
	}
	puts(OK);
	/* Compare each record in turn and set the corresponding bit in ebits
	 * if a mismatch is encountered. Note that we EXPECT a bit-to-bit match
	 * of the $Mft and the $MftMirr. This is CORRECT behaviour(!). Even just
	 * having the USNs in $Mft and $MftMirr being different has to trigger
	 * the correction procedure! */
	printf("Comparing $MftMirr to $Mft... ");
	for (i = 0, ebits = 0; i < 4; ++i) {
		if (memcmp(b1+i*mrs, b2+i*mrs,
			   get_mft_record_size((MFT_RECORD_HEADER*)(b1+i*mrs)))) {
			ebits |= 1 << i;
#ifdef DEBUG
			printf("in memcmp: i = %x, count = 0x%x\n", i, get_mft_record_size((MFT_RECORD_HEADER*)(b1+i*mrs)));
#endif
		}
	}
	if (ebits) {
                puts(FAILED);
		printf("Assuming $Mft is valid and correcting differences "
		       "in $MftMirr... ");
		/* MST protect & write the $Mft records corresponding to the
		   mismatched ones to both $Mft and $MftMirr. */
		for (i = 0; i < 4; ++i) {
			/* Only fix if there was an error! */
			if ( !( ebits & (1 << i) ) )
				continue;
			/* Copy the buffer first (due to USN stuff, can't 
			   recycle the buffer) */
			memcpy(b2 + mrs * i, b1 + mrs * i, mrs);
			/* Do the writes now. */
			br = put_mft_record(vol, b1 + mrs * i, i);
			if (br != 1)
				goto mirr_sync_failed;
			br = mst_pwrite(vol->fd, b2 + mrs * i, mrs, 
			     (vol->mftmirr_lcn * vol->cluster_size) + 
			     					(i * mrs));
			/* If we succeeded then do the next record. */
			if (br == mrs)
				continue;
mirr_sync_failed:	/* Synchronization failed. )-: */
			puts(FAILED);
#define ESTR "Error correcting $MftMirr"
			if (br == -1)
				perror(ESTR);
			else
				fprintf(stderr, ESTR ": unknown error\n");
#undef ESTR
			goto error_exit;
		}
	}
	puts(OK);
	printf("Processing of the $Mft and $MftMirr completed successfully."
								       "\n\n");
	/* Check NTFS version is ok for us (in $Volume) */
	printf("NTFS volume version is %i.%i.\n", vol->major_ver,
							vol->minor_ver);
	switch (vol->major_ver) {
		case 1:
			if (vol->minor_ver == 1 || vol->minor_ver == 2)
				break;
			else
				goto version_error;
		case 2:	case 3:
			if (vol->minor_ver == 0)
				break;
			/* Fall through on error. */
		default:
version_error:			
                	fprintf(stderr, "Error: Unknown NTFS version.\n");
			goto error_exit;
	}
	printf("Setting required flags on partition... ");
	/* Set chkdsk flag, i.e. mark the partition dirty so chkdsk will run
	   and fix it for us. */
	flags = vol->flags;
	flags |= VOLUME_IS_DIRTY;
	/* If NTFS volume version >= 2.0 then set mounted on NT4 flag. */
	if (vol->major_ver >= 2)
		flags |= VOLUME_MOUNTED_ON_NT4;
	if (!set_ntfs_volume_flags((MFT_RECORD_HEADER*)(b1+3*mrs), flags)) {
		puts(FAILED);
		fprintf(stderr, "Error setting volume flags.\n");
		goto error_exit;
	}
	vol->flags = flags;
	/* FIXME: The above makes me puke! We definitely need functions just
	   taking the volume and flags and [sg]etting the volume flags! */
	puts(OK);
	/* Sync $MftMirr and $Mft buffers. */
	memcpy(b2 + 3 * mrs, b1 + 3 * mrs, mrs);
	/* Write $Volume to $Mft. */
	printf("Writing $Volume to $Mft... ");
	br = put_mft_record(vol, b1 + (3 * mrs), 3);
	if (br != 1) {
		puts(FAILED);
#define ESTR "Error writing $Volume to $Mft"
		if (br == -1)
			perror(ESTR);
		else
			fprintf(stderr, ESTR ": unknown error\n");
#undef ESTR
		goto error_exit;
	}
	puts(OK);
	/* Write $Volume to $MftMirr. */
	printf("Writing $Volume to $MftMirr... ");
	br = mst_pwrite(vol->fd, b2 + (3 * mrs), mrs, 
			(vol->mft_mirr_lcn << vol->cluster_size_bits) +
		       						(3 * mrs));
	if (br != mrs) {
		puts(FAILED);
		goto error_exit;
	}
	puts(OK);
	printf("\n");
	
	/* Zero the value of the $LogFile data attribute (ie. the contents of
	 * the file) thus erasing the journal.
	 * FIXME(?): We might need to zero the LSN field of every single $Mft
	 * record as well. (But, first try without doing that and see what
	 * happens, since chkdsk might pickup the pieces and do it for us...)
	 * FIXME: This results in winNT/2k saying the partition is corrupt and
	 * tells us to run chkdsk but when it is the boot drive it doesn't
	 * boot up so can't run chkdsk!!! 
	 * 
	 * Try to clear the $LogFile by modifying the restart areas... */
	printf("Going to fixup the journal ($LogFile)... ");
	/* Find the $DATA attribute. */
	a = (NONRESIDENT_ATTRIBUTE_RECORD_HEADER*)
		find_attribute((MFT_RECORD_HEADER*)(b1+(2*mrs)), $DATA, NULL);
	if (!a) {
		puts(FAILED);
		fprintf(stderr, "Error: Attribute $DATA was not found in" \
		                "$LogFile!\n");
		goto log_file_error;
	}
	/* Get length of $LogFile contents. */
	l = get_attribute_value_length((ATTRIBUTE_RECORD_HEADER*)a);
	if (!l) {
		puts(OK);
		puts("$LogFile has zero length, no need to write to disk.");
		goto log_file_error;
	}
	/* Allocate a buffer to hold all of the $LogFile contents. */
	lfd = (unsigned char*)malloc(l);
	if (!lfd) {
		puts(FAILED);
		puts("Not enough memory to load $LogFile.");
		goto log_file_error;
	}
	/* Read in the $LogFile into the buffer. */
	if (l != get_attribute_value(vol, (ATTRIBUTE_RECORD_HEADER*)a, lfd)) {
		puts(FAILED);
		puts("Amount of data read does not correspond to expected "
		     "length!");
		free(lfd);
		goto log_file_error;
	}
	/* Check and then modify restart area. */
	if (!is_rstr_recordp(lfd)) {
		puts(FAILED);
		puts("$LogFile contents are corrupt (magic RSTR missing)!");
		free(lfd);
		goto log_file_error;
	}
{	RESTART_PAGE_HEADER *rph;
	RESTART_AREA *rr;
	RESTART_CLIENT *cr;
	int pass = 1;
	int lps;
	
	rph = (RESTART_PAGE_HEADER*)lfd;
	lps = le32_to_cpu(rph->LogPageSize);
pass_loc:
	if (!post_read_mst_fixup((NTFS_RECORD_HEADER*)rph, lps) ||
	    is_baad_recordp(rph)) {
		puts(FAILED);
		puts("$LogFile incomplete multi sector transfer detected! "
		     "Cannot handle this yet!");
		free(lfd);
		goto log_file_error;
	}
	if (le16_to_cpu(rph->major_version != 1) || 
	    le16_to_cpu(rph->minor_version != 1)) {
		puts(FAILED);
		printf("$LogFile version %i.%i! Cannot handle this yet!\n",
					le16_to_cpu(rph->major_ver),
					le16_to_cpu(rph->minor_ver));
		free(lfd);
		goto log_file_error;
	}
	rr = (RESTART_AREA*)((char*)rph + le16_to_cpu(rph->restart_offset));
	cr = (RESTART_CLIENT*)((char*)rr + sizeof(RESTART_AREA));
#ifdef DEBUG
	/* Do a dump of the $LogFile restart area. */
	if (pass == 1)
		printf("\n$LogFile version %i.%i.\n",
					le16_to_cpu(rph->major_ver),
					le16_to_cpu(rph->minor_ver));
	printf("%s restart area:\n", pass == 1? "1st": "2nd");
	printf("magic = RSTR\n");
	printf("Lsn = 0x%Lx\n", sle64_to_cpu(rph->chkdsk_lsn));
	printf("SystempageSize = %u\n", le32_to_cpu(rph->system_page_size));
	printf("LogPageSize = %u\n", le32_to_cpu(rph->log_page_size));
	printf("RestartOffset = 0x%x\n", le16_to_cpu(rph->restart_offset));
	printf("\n(1st) restart record:\n");
	printf("CurrentLsn = %Lx\n", sle64_to_cpu(rr->current_lsn));
	printf("LogClients = %u\n", le16_to_cpu(rr->log_clients));
	printf("ClientFreeList = %u\n", le16_to_cpu(rr->client_free_list));
	printf("ClientInUseList = %u\n", le16_to_cpu(rr->client_in_use_list));
	printf("Flags = 0x%x\n", le16_to_cpu(rr->flags));
	printf("SeqNumberBits = %u\n", le32_to_cpu(rr->seq_number_bits));
	printf("RestartAreaLength = 0x%x\n", 
					le16_to_cpu(rr->restart_area_length));
	printf("ClientArrayOffset = 0x%x\n",
					le16_to_cpu(rr->client_array_offset));
	printf("FileSize = %Lu\n", le64_to_cpu(rr->file_size));
	printf("LastLsnDataLength = 0x%x\n",
					le32_to_cpu(rr->last_lsn_data_length));
	printf("RecordLength = 0x%x\n", le16_to_cpu(rr->record_length));
	printf("LogPageDataOffset = 0x%x\n", 
					le16_to_cpu(rr->log_page_data_offset));
	printf("\n1st Client record:\n");
	printf("OldestLsn = 0x%Lx\n", sle64_to_cpu(cr->oldest_lsn));
	printf("ClientRestartLsn = 0x%Lx\n", 
					sle64_to_cpu(cr->client_restart_lsn));
	printf("PrevClient = 0x%x\n", le16_to_cpu(cr->prev_client));
	printf("NextClient = 0x%x\n", le16_to_cpu(cr->next_client));
	printf("SeqNumber = 0x%x\n", le16_to_cpu(cr->seq_number));
	printf("ClientName = %u\n", le16_to_cpu(cr->client_name));
	printf("\nTerminator = 0x%x\n", *(__u32*)((char*)cr + 
						sizeof(RESTART_CLIENT)));
	printf("Unicode string \"NTFS\"%spresent\n", *(__u64*)((char*)cr + 
				sizeof(RESTART_CLIENT) + 0x10) == 
				cpu_to_le64(0x005300460054004e) ? " ": " not ");
#endif
	rr->log_clients = cpu_to_le16(1);
	rr->client_free_list = cpu_to_le16(0xffff);
	rr->client_in_use_list = cpu_to_le16(0);
	rr->flags = cpu_to_le16(0);
	if (le64_to_cpu(rr->file_size) != l) {
		puts(FAILED);
		puts("$LogFile restart area indicates a log file size"
		     "different from the actual size!");
		free(lfd);
		goto log_file_error;
	}
	rr->last_lsn_data_length = cpu_to_le32(0);
	rr->current_lsn = cr->client_restart_lsn;
	cr->prev_client = cpu_to_le16(0);
	cr->next_client = cpu_to_le16(0);
	if (le16_to_cpu(cr->client_name) != 0) {
		puts(FAILED);
		puts("$LogFile restart area Client Name != 0.");
		free(lfd);
		goto log_file_error;
	}
	if (*(__u32*)((char*)cr + sizeof(RESTART_CLIENT)) != 
								  0xffffffff) {
		puts(FAILED);
		puts("$LogFile restart area not terminated!");
		free(lfd);
		goto log_file_error;
	}
	if (!pre_write_mst_fixup((NTFS_RECORD_HEADER*)rph, lps)) {
		puts(FAILED);
		puts("$LogFile restart area multi sector protection not "
		     "completed!");
		free(lfd);
		goto log_file_error;
	}
	rph = (RESTART_PAGE_HEADER*)((char*)rph + lps);
	if (pass == 1) {
		++pass;
		goto pass_loc;
	}
	if (!is_rcrd_recordp(rph)) {
		puts(FAILED);
		puts("$LogFile's first record area magic RCRD is missing!");
		free(lfd);
		goto log_file_error;
	}
}
	/* Set the $DATA attribute. */
	/* FIXME: set_attribute_value needs to either:
	 * - know the MFT_RECORD_HEADER so it can adjust it accordingly with
	 *   changes in length of the resident part of the attribute.
	 * or
	 * - return a copy of the attribute so the MFT_RECORD_HEADER can be
	 * adjusted accordingly with changes in the length of the resident
	 * part of the attribute by the caller. 
	 * For now, just assume that attribute length remains constant, since
	 * this is the case for the $LogFile zeroing out. */

/* DON'T WRITE IT BACK YET!!!
	if (!set_attribute_value(vol, (ATTRIBUTE_RECORD_HEADER*)a, lfd, l)) {
		puts(FAILED);
		puts("Failed to set the $LogFile attribute value.");
		free(lfd);
		goto log_file_error;
	}
 */

	/* Release the allocated buffer. */
	free(lfd);
	puts(OK);
	puts("$LogFile was left untouched as we don't know what to do with "
	     "it yet!");

log_file_error:
	
	printf("\n");

	/* FIXME: If on NTFS 3.0+, check for presence of the usn journal and
	   disable it (if present) as Win2k might be unhappy otherwise and Bad
	   Thing(TM) could happen depending on what applications are actually
	   using it for. */
	
	/* FIXME: Should we be marking the quota out of date, too? */

	/* That's all for now! */

	printf("NTFS partition %s was processed successfully.\n", 
							      vol->vol_name);
	/* Set return code to 0. */
	i = 0;
final_exit:
	if (b1)
		free(b1);
	if (vol)
		ntfs_close(vol);
	return i;
error_exit:
	i = 1;
	goto final_exit;
}

[Linux-ntfs-cvs] CVS: linux-ntfs/include logfile.h,1.1,1.2

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv10246/include

Modified Files:
	logfile.h 
Log Message:
Added ntfsfix program.


Index: logfile.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/logfile.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** logfile.h	2001/01/24 10:30:49	1.1
--- logfile.h	2001/01/24 21:02:37	1.2
***************
*** 71,78 ****
  				   the restart record. Value has to be aligned
  				   to 8-byte boundary. = 0x30 */
! 	__s16 minor_version;	/* Log file minor version. Only check if major
  				   version is 1. (=1 but >=1 is treated the
  				   same and <=0 is also ok) */
! 	__u16 major_version;	/* Log file major version (=1 but =0 is ok) */
  } __attribute__ ((__packed__)) RESTART_PAGE_HEADER;
  
--- 71,78 ----
  				   the restart record. Value has to be aligned
  				   to 8-byte boundary. = 0x30 */
! 	__s16 minor_ver;	/* Log file minor version. Only check if major
  				   version is 1. (=1 but >=1 is treated the
  				   same and <=0 is also ok) */
! 	__u16 major_ver;	/* Log file major version (=1 but =0 is ok) */
  } __attribute__ ((__packed__)) RESTART_PAGE_HEADER;
  

[Linux-ntfs-cvs] CVS: linux-ntfs/include bootsect.h,NONE,1.1 disk_io.h,1.1,1.2

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv6561

Modified Files:
	disk_io.h 
Added Files:
	bootsect.h 
Log Message:
Added for now last header file for boot sector handling.


--- NEW FILE ---
/*
 * bootsect.h - Exports for bootsector record handling. Part of the Linux-NTFS
 *		project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef BOOTSECT_H
#define BOOTSECT_H


/* The NTFS OEMid */
#define magicNTFS	cpu_to_le64(0x202020205346544e) /* "NTFS    " */

/*
 * Location of bootsector on partition:
 * 	The standard PACKED_BOOT_SECTOR is on sector 0 of the partition.
 * 	On NT4 and above there is one backup copy of the boot sector to
 * 	be found on the last sector of the partition (not normally accessible
 * 	from within Windows as the bootsector contained number of sectors value
 * 	is one less than the actual value!).
 * 	On versions of NT 3.51 and earlier, the backup copy was located at 
 * 	number of sectors/2, i.e. in the middle of the volume.
 */

/*
 * BIOS parameter block (bpb) structure.
 */
typedef struct {
	__u16 bytes_per_sector;		/* Size of a sector in bytes. */
	__u8  sectors_per_cluster;	/* Size of a cluster in sectors. */
	__u16 reserved_sectors;		/* zero */
	__u8  fats;			/* zero */
	__u16 root_entries;		/* zero */
	__u16 sectors;			/* zero */
	__u8  media_type;		/* irrelevant */
	__u16 sectors_per_fat;		/* zero */
	__u16 sectors_per_track;	/* irrelevant */
	__u16 heads;			/* irrelevant */
	__u32 hidden_sectors;		/* zero */
	__u32 large_sectors;		/* zero */
} __attribute__ ((__packed__)) BIOS_PARAMETER_BLOCK;

/*
 * Boot sector structure.
 */
typedef struct {
	__u8  jump[3];			/* Irrelevant (jump to boot up code).*/
	__u64 oem_id;			/* Magic "NTFS    ". */
	BIOS_PARAMETER_BLOCK bpb;	/* See BIOS_PARAMETER_BLOCK. */
	__u8  unused[4];		/* zero */
	__s64 number_of_sectors;	/* Number of sectors in volume. Gives
					   maximum volume size of 2^63 sectors.
					   Assuming standard sector size of 512
					   bytes, the maximum byte size is
					   approx. 4.7x10^21 bytes. (-; */
	__s64 mft_lcn;			/* Cluster location of mft. */
	__s64 mftmirr_lcn;		/* Cluster lcoation of copy of mft. */
	__s8  clusters_per_mft_record;	/* Mft record size in clusters. */
	__u8  reserved0[3];		/* zero */
	__s8  clusters_per_index_block;	/* Index block size in clusters. */
	__u8  reserved1[3];		/* zero */
	__s64 volume_serial_number;	/* Irrelevant (serial number). */
	__u32 checksum;			/* Boot sector checksum. */
	__u8  bootstrap[426];		/* Irrelevant (boot up code). */
	__u16 end_of_sector_marker;	/* 0xaa55 in little endian. */
} __attribute__ ((__packed__)) NTFS_BOOT_SECTOR;

/**
 * is_boot_sector_ntfs - check a boot sector for describing an ntfs volume
 * @b:		buffer containing the boot sector
 * @silent:	if 1 don't display progress information
 * 
 * This function checks the boot sector in @b for describing a valid ntfs
 * volume. Return 1 if @b is a NTFS boot sector or 0 otherwise. If silent is 0
 * progress output will be output to stdout. If silent is 1 no output to stdout
 * will occur. Errors/warnings to stderr will occur disregarding the value of
 * silent.
 */
int is_boot_sector_ntfs(PACKED_BOOT_SECTOR *b, int silent);

#endif /* defined BOOTSECT_H */


Index: disk_io.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/disk_io.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** disk_io.h	2001/01/24 18:44:31	1.1
--- disk_io.h	2001/01/24 20:37:36	1.2
***************
*** 36,40 ****
   * This function will write @count bytes of data @b to file descriptor @fd at
   * position @pos.
!  
   * On success return bytes written (0 means nothing written).
   * On error return -1 with errno set appropriately to the return code of 
--- 36,40 ----
   * This function will write @count bytes of data @b to file descriptor @fd at
   * position @pos.
!  *
   * On success return bytes written (0 means nothing written).
   * On error return -1 with errno set appropriately to the return code of 

[Linux-ntfs-cvs] CVS: linux-ntfs/include disk_io.h,NONE,1.1

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv21617

Added Files:
	disk_io.h 
Log Message:
Added disk_io.h header file.


--- NEW FILE ---
/*
 * disk_io.h - Exports for disk io. Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef DISK_IO_H
#define DISK_IO_H

#include <linux/types.h>

#include "volume.h"

/**
 * ntfs_pwrite - positioned write to disk
 * @fd:		file descriptor to write to
 * @b:		data buffer to write to disk
 * @count:	number of bytes to write
 * @pos:	position in file descriptor to write to
 * 
 * This function will write @count bytes of data @b to file descriptor @fd at
 * position @pos.
 
 * On success return bytes written (0 means nothing written).
 * On error return -1 with errno set appropriately to the return code of 
 * either lseek, malloc, write or fdatasync.
 */
ssize_t ntfs_pwrite(int fd, const void *b, size_t count, off_t pos);

/**
 * mst_pwrite - multi sector transfer (mst) positioned write
 * @fd:		file descriptor to write to
 * @b:		data buffer to write to disk
 * @count:	number of bytes to write
 * @pos:	position in file descriptor to write to
 * 
 * Multi sector transfer (mst) positioned write. This function will write
 * @count bytes of data @b to file descriptor @fd at position @pos.
 * 
 * On success return bytes written (0 means nothing written).
 * On error return -1 with errno set appropriately to the return code of 
 * either lseek, malloc, write or fdatasync.
 */
ssize_t mst_pwrite(int fd, const void *b, size_t count, off_t pos);

/**
 * ntfs_pread - positioned read from disk
 * @fd:		file descriptor to read from
 * @b:		output data buffer
 * @bksize:	size of each block
 * @count:	number of blocks to read
 * @pos:	position in file descriptor to read from
 * 
 * This function will read @count @blocks of size @bksize bytes each from file
 * descriptor @fd at position @pos into the buffer @b.
 * 
 * On success, return the number of successfully read blocks. If this number is
 * lower than @count this means that we have reached end of file. 0 means end
 * of file or nothing to read (@count or @bksize is 0). On error, return -1
 * with errno set appropriately to the return code of either lseek or read, or
 * to EINVAL in case the data pointer @b was NULL or the block size (@bksize)
 * was not a multiple of NTFS_SECTOR_SIZE or @bksize was not a power of two.
 * 
 * NOTE: If a read error is encountered we return -1 even if we have already
 * 	 read some blocks successfully (this is subject to change!!!).
 */
ssize_t ntfs_pread(int fd, void *b, size_t bksize, size_t count, off_t pos);

/**
 * mst_pread - multi sector transfer (mst) positioned read
 * @fd:		file descriptor to read from
 * @b:		output data buffer
 * @bksize:	size of each block
 * @count:	number of blocks to read
 * @pos:	position in file descriptor to read from
 * 
 * Multi sector transfer (mst) positioned read. This function will read @count
 * @blocks of size @bksize bytes each from file descriptor @fd at position @pos
 * into the buffer @b.
 * 
 * On success, return the number of successfully read blocks. If this number is
 * lower than @count this means that we have reached end of file. 0 means end
 * of file or nothing to read (@count or @bksize is 0). On error, return -1
 * with errno set appropriately to the return code of either lseek or read, or
 * to EINVAL in case the data pointer @b was NULL or the block size (@bksize)
 * was not a multiple of NTFS_SECTOR_SIZE or @bksize was not a power of two.
 * 
 * NOTE: If an incomplete multi sector transfer has been detected the magic
 * 	 will have been changed to magic_BAAD but no error will be returned.
 * 	 I.e. it is possible that we return count blocks as being read but that
 * 	 any number (between zero and count!) of these blocks is actually
 * 	 subject to a multi sector transfer error. This should be detected by
 * 	 the caller by checking for the magic being "BAAD".
 * 
 * NOTE: If a read error is encountered we return -1 even if we have already
 * 	 read some blocks successfully (this is subject to change!!!).
 */
ssize_t mst_pread(int fd, void *b, size_t bksize, size_t count, off_t pos);

/**
 * get_clusters - read ntfs clusters
 * @vol:	volume to read from
 * @buf:	output data buffer
 * @lcn:	starting logical cluster number
 * @count:	number of clusters to read
 *
 * Read @count ntfs clusters starting at logical cluster number @lcn from volume
 * @vol into buffer @buf. Return number of clusters read or -ERRNO on error, 
 * where ERRNO is the error code. This function will do the error reporting so
 * caller really only needs to check for sucess / failure.
 *
 * NOTE: @buf has to be at least of size vol->ClusterSize * @count. No checking
 * is performed for this!
 */
int get_clusters(ntfs_volume *vol, __u8 *buf, __s64 lcn, int count);

/**
 * put_clusters - write ntfs clusters
 * @vol:	volume to write to
 * @buf:	data buffer to write to disk
 * @lcn:	starting logical cluster number
 * @count:	number of clusters to write
 *
 * Write @count ntfs clusters starting at logical cluster number @lcn from
 * buffer @buf to volume @vol. Return @count on success or -ERRNO on error,
 * where ERRNO is the error code. This function will do the error reporting so
 * caller really only needs to check for sucess / failure.
 */
int put_clusters(ntfs_volume *vol, const __u8 *buf, __s64 lcn, int count);

/**
 * get_mft_records - read records from the mft
 * @vol:	volume to read from
 * @buf:	output data buffer
 * @mftrec:	starting mft record number
 * @count:	number of mft records to read
 *
 * Read @count mft records starting at @mftrec from volume @vol into buffer
 * @buf. Return @count on success or -ERRNO on error, where ERRNO is the error
 * code. This function will do the error reporting so caller really only needs
 * to check for sucess / failure.
 *
 * NOTE: @buf has to be at least of size @count * vol->MftRecordSize.
 */
int get_mft_records(ntfs_volume *vol, __u8 *buf, __s64 mftrec, int count);

/**
 * put_mft_record - write a record to the mft
 * @vol:	volume to write to
 * @buf:	data buffer containing the mft record to write
 * @mftrec:	mft record number to write to
 *
 * Write mft record @mftrec from buffer @buf to volume @vol. Return 1 on
 * success or -ERRNO on error, where ERRNO is the error code. This function
 * will do the error reporting so caller really only needs to check for sucess
 * / failure.
 */
int put_mft_record(ntfs_volume *vol, const __u8 *buf, __s64 mftrec);


#endif /* defined DISK_IO_H */

[Linux-ntfs-cvs] CVS: linux-ntfs/include bitmap.h,NONE,1.1

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv17701

Added Files:
	bitmap.h 
Log Message:
Added bitmap header.


--- NEW FILE ---
/*
 * bitmap.h - Exports for bitmap handling. Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef BITMAP_H
#define BITMAP_H

#include <linux/types.h>

/*
 * NOTES:
 *
 * - Operations are 8-bit only to ensure the functions work both on little
 *   and big endian machines! So don't make them 32-bit ops!
 * - bitmap starts at bit = 0 and ends at bit = bitmap size - 1.
 * - _Caller_ has to make sure that the bit to operate on is less than the
 *   size of the bitmap.
 */

/**
 * set_bit - set a bit in a field of bits
 * @bitmap:	field of bits
 * @bit:	bit to set
 * @newvalue:	value to set bit to (0 or 1)
 *
 * Set the bit @bit in the @bitmap to @newvalue. Ignore all errors.
 */
extern inline void set_bit(__u8 *bitmap, __u64 bit, __u8 newvalue);

/**
 * get_bit - get value of a bit in a field of bits
 * @bitmap:	field of bits
 * @bit:	bit to get
 * 
 * Get and return the value of the bit @bit in @bitmap (0 or 1). Return -1 on
 * error.
 */
extern inline char get_bit(__u8 *bitmap, __u64 bit);

/**
 * get_and_set_bit - get value of a bit in a field of bits and set it afterwards
 * @bitmap:	field of bits
 * @bit:	bit to get/set
 * @newvalue:	value to set bit to (0 or 1)
 * 
 * Return the value of the bit @bit and set it to @newvalue (0 or 1). Return -1
 * on error.
 */
extern inline char get_and_set_bit(__u8 *bitmap, __u64 bit, __u8 newvalue);

#endif /* defined BITMAP_H */

[Linux-ntfs-cvs] CVS: linux-ntfs/include logfile.h,NONE,1.1

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv7472

Added Files:
	logfile.h 
Log Message:
The initial log file on disk structures (work in progress).


--- NEW FILE ---
/*
 * logfile.h - Exports for $LogFile handling. Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef LOGFILE_H
#define LOGFILE_H

#include "endians.h"
#include "ntfs_rec.h"

typedef enum {
	magic_RSTR = cpu_to_le32(0x52545352), /* "RSTR", restart area */
	magic_RCRD = cpu_to_le32(0x44524352), /* "RCRD", log record */
} LOG_FILE_RECORD_TYPES;

/*
 * Specialised magic comparison macros.
 */
#define is_rstr_record(x)	( is_magic (x, RSTR) )
#define is_rstr_recordp(p)	( is_magicp(p, RSTR) )
#define is_rcrd_record(x)       ( is_magic (x, RCRD) )
#define is_rcrd_recordp(p)      ( is_magicp(p, RCRD) )

/*
 * Log file organization:
 * 	Two restart areas present in the first two pages (restart pages). When
 * the volume is unmounted they should be identical.
 * 	These are followed by log records organized in pages headed by a record
 * header going up to log file size. Not all pages contain log records when a
 * volume is first formatted, but as the volume ages, all records will be used.
 * When the log file fills up, the records at the beginning are purged (by
 * modifying the oldest_lsn to a higher value presumably) and writing begins
 * at the beginning of the file. Effectively, the log file is viewed as a
 * circular entity.
 */

/*
 * Log file restart page header (begins the restart area).
 */
typedef struct {
	NTFS_RECORD_HEADER ntfs;/* The magic is "RSTR". */
	__u64 chkdsk_lsn;	/* The check disk log file sequence number for
				   this restart page. Only used when the
				   magic is changed to "CHKD". = 0 */
	__u32 system_page_size;	/* Byte size of system pages, has to be >= 512
				   and a power of 2. Use this to calculate the
				   required size of the usa and add this to the
				   ntfs.usa_offset value. Then verify that the
				   result is less than the value of the 
				   restart_offset. = 0x1000 */
	__u32 log_page_size;	/* Byte size of log file records, has to be
				   >= 512 and a power of 2. = 0x1000 */
	__u16 restart_offset;	/* Byte offset from the start of the record to
				   the restart record. Value has to be aligned
				   to 8-byte boundary. = 0x30 */
	__s16 minor_version;	/* Log file minor version. Only check if major
				   version is 1. (=1 but >=1 is treated the
				   same and <=0 is also ok) */
	__u16 major_version;	/* Log file major version (=1 but =0 is ok) */
} __attribute__ ((__packed__)) RESTART_PAGE_HEADER;

/*
 * Log file restart area record. The offset of this record is found by adding
 * the offset of the RESTART_PAGE_HEADER to the restart_offset value found in
 * it.
 */
typedef struct {
	__u64 current_lsn;	/* Log file record. = 0x700000, 0x700808 */
	__u16 log_clients;	/* Number of log client records following
				   the restart_area. = 1 */
	__u16 client_free_list;	/* How many clients are free(?). If != 0xffff,
				   check that log_clients > client_free_list.
				   = 0xffff */
	__u16 client_in_use_list;/* How many clients are in use(?). If != 0xffff
				   check that log_clients > client_in_use_list.
				   = 0 */
	__u16 flags;		/* ??? = 0 */
	__u32 seq_number_bits;	/* ??? = 0x2c or 0x2d */
	__u16 restart_area_length;/* Length of the restart area. Following
				   checks required if version matches.
				   Otherwise, skip them. restart_offset +
				   restart_area_length has to be <=
				   system_page_size. Also, restart_area_length
				   has to be >= client_array_offset +
				   (log_clients * 0xa0). = 0xd0 */
	__u16 client_array_offset;/* Offset from the start of this record to
				   the first client record if versions are
				   matched. The offset is otherwise assumed to
				   be (sizeof(RESTART_AREA) + 7) & ~7, i.e. 
				   rounded up to first 8-byte boundary. Either
				   way, the offset to the client array has to be
				   aligned to an 8-byte boundary. Also,
				   restart_offset + offset to the client array
				   have to be <= 510. Also, the offset to the
				   client array + (log_clients * 0xa0) have to
				   be <= SystemPageSize. = 0x30 */
	__u64 file_size;	/* Byte size of the log file. If the 
				   restart_offset + the offset of the file_size
				   are > 510 then corruption has occured. This
				   is the very first check when starting with
				   the restart_area as if it fails it means
				   that some of the above values will be
				   corrupted by the multi sector transfer
				   protection! If the structure is deprotected
				   then these checks are futile of course.
				   Calculate the file_size bits and check that
				   seq_number_bits == 0x43 - file_size bits. 
				   = 0x400000 */
	__u32 last_lsn_data_length;/* ??? = 0, 0x40 */
	__u16 record_length;	/* Byte size of this record. If the version
				   matches then check that the value of
				   record_length is a multiple of 8, i.e.
				   (record_length + 7) & ~7 == record_length.
				   = 0x30 */
	__u16 log_page_data_offset;/* ??? = 0x40 */	
} __attribute__ ((__packed__)) RESTART_AREA;

/*
 * Log file client record. Starts at 0x58 even though AFAIU the above it should
 * start at 0x60. Something fishy is going on. /-:
 */
typedef struct {
	__u64 oldest_lsn;	/* Oldest log file sequence number for this
				   client record. = 0xbd16951d */
	__u64 client_restart_lsn;/* ??? = 0x700000, 0x700827, 0x700d07 */
	__u16 prev_client;	/* ??? = 0x808, 0xd07, 0xd5d */
	__u16 next_client;	/* ??? = 0x70 */
	__u16 seq_number;	/* ??? = 0, 4 size uncertain */
	__u16 client_name;       /* ??? = empty string??? size uncertain */
} __attribute__ ((__packed__)) RESTART_CLIENT;

/* 
 * NOTE: Above client record is followed by 0xffffffff probably to indicate
 * the end of the restart area. 
 * Then there are 8 bytes = 0, then one __u32 = 8, followed by the Unicode 
 * string "NTFS" and then zeroes till the end of the page. 
 * Is this important at all?
 */

/*
 * Log page record page header. Each log page begins with this header and is
 * followed by several LOG_RECORD structures.
 */
typedef struct {
	NTFS_RECORD_HEADER ntfs;	/* The magic is "RCRD". */
	union {
		__u64 last_lsn;
		__u32 file_offset;
	} copy;
	__u32 flags;
	__u16 page_count;
	__u16 page_position;
	union {
		struct {
			__u64 next_record_offset;
			__u64 last_end_lsn;
		} packed;
	} header;
} __attribute__ ((__packed__)) RECORD_PAGE_HEADER;

/*
 * Possible flags for log records.
 */
typedef enum {
	LOG_RECORD_MULTI_PAGE = 1,	/* ??? */
	LOG_RECORD_SIZE_PLACE_HOLDER = 0xffff,
		/* This has nothing to do with the log record. It is only so
		   gcc knows to make the flags 16-bit. */
} __attribute__ ((__packed__)) LOG_RECORD_FLAGS;

/*
 * Log record header.
 */
typedef struct {
	__u64 this_lsn;
	__u64 client_previous_lsn;
	__u64 client_undo_next_lsn;
	__u32 client_data_length;
	struct {
		__u16 seq_number;
		__u16 client_index;
	} client_id;
	__u32 record_type;
	__u32 transaction_id;
	LOG_RECORD_FLAGS flags;
	__u16 reserved_or_alignment[3];
/* Now are at ofs 0x30 into struct. */
	__u16 redo_operation;
	__u16 undo_operation;
	__u16 redo_offset;
	__u16 redo_length;
	__u16 undo_offset;
	__u16 undo_length;
	__u16 target_attribute;
	__u16 lcns_to_follow;		   /* Number of lcn_list entries 
					      following this entry. */
	__u16 record_offset;
	__u16 attribute_offset;
	__u32 alignment_or_reserved;
	__u32 target_vcn;
	__u32 alignment_or_reserved1;
	struct {			   /* Only present if lcns_to_follow
					      is not 0. */
		__u32 lcn;
		__u32 alignment_or_reserved;
	} lcn_list[0];
} __attribute__ ((__packed__)) LOG_RECORD;

#endif /* defined LOGFILE_H */

[Linux-ntfs-cvs] CVS: linux-ntfs/include attrib.h,NONE,1.1 endians.h,NONE,1.1 mft.h,NONE,1.1 ntfs_rec.h,NONE,1.1 volume.h,NONE,1.1

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv19513/include

Added Files:
	attrib.h endians.h mft.h ntfs_rec.h volume.h 
Log Message:
Add a bunch of headers (attrib.h is work in progress).


--- NEW FILE ---
/*
 * attrib.h - Exports for attribute handling. Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef ATTRIB_H
#define ATTRIB_H

#include "endians.h"
#include "mft.h"

/*
 * System defined attributes (32-bit).
 */
typedef enum {
	$UNUSED                         = cpu_to_le32(         0),
        $STANDARD_INFORMATION           = cpu_to_le32(      0x10),
        $ATTRIBUTE_LIST                 = cpu_to_le32(      0x20),
        $FILENAME                       = cpu_to_le32(      0x30),
        $OBJECT_ID                      = cpu_to_le32(      0x40),
        $SECURITY_DESCRIPTOR            = cpu_to_le32(      0x50),
        $VOLUME_NAME                    = cpu_to_le32(      0x60),
	$VOLUME_INFORMATION             = cpu_to_le32(      0x70),
	$DATA                           = cpu_to_le32(      0x80),
        $INDEX_ROOT                     = cpu_to_le32(      0x90),
        $INDEX_ALLOCATION               = cpu_to_le32(      0xa0),
        $BITMAP                         = cpu_to_le32(      0xb0),
	$REPARSE_POINT                  = cpu_to_le32(      0xc0),
        $EA_INFORMATION                 = cpu_to_le32(      0xd0),
	$EA                             = cpu_to_le32(      0xe0),
        $PROPERTY_SET                   = cpu_to_le32(      0xf0),
        $LOGGED_UTILITY_STREAM          = cpu_to_le32(     0x100),
        $FIRST_USER_DEFINED_ATTRIBUTE   = cpu_to_le32(    0x1000),
        $END                            = cpu_to_le32(0xffffffff),
} ATTRIBUTE_TYPE;

/*
 * System file numbers. All these files are always marked as used in the $Mft
 * bitmap attribute, presumably in order to avoid accidental allocation for
 * random other mft records.
 */
typedef enum {
        FILE_$Mft       = 0,	/* Master file table (mft). */
        FILE_$MftMirr   = 1,	/* Mft mirror (copy of first 4 mft records). */
        FILE_$LogFile   = 2,	/* Journalling log. */
        FILE_$Volume    = 3,	/* Volume name, flags and ntfs version. */
        FILE_$AttrDef   = 4,	/* Attribute definitions. */
        FILE_$root      = 5,	/* Root directory. */
        FILE_$BitMap    = 6,	/* Allocation map of all clusters. */
        FILE_$Boot      = 7,	/* Boot sector (always at cluster 0). */
        FILE_$BadClus   = 8,	/* Contains all bad clusters. */
        FILE_$Secure    = 9,	/* Shared security descriptors. */
        FILE_$UpCase    = 10,	/* Upcase table for all 65536 Unicode chars. */
        FILE_$Extend    = 11,	/* Directory containing other system files (eg.
				   $ObjId, $Quota, $Reparse and $UsnJrnl). This
				   is new to NTFS3.0. */
        FILE_reserved12 = 12,	/* Reserved for future use (records 12-15). */
        FILE_reserved13 = 13,
        FILE_reserved14 = 14,
        FILE_reserved15 = 15,
	FILE_first_user = 16,	/* First user file, used as test limit for
				   whether to allow opening a file or not. */
} NTFS_SYSTEM_FILES;

/*
 * Attribute flags (16-bit). 
 */
typedef enum {
	ATTRIBUTE_IS_COMPRESSED	   = cpu_to_le16(0x0001),
	ATTRIBUTE_COMPRESSION_MASK = cpu_to_le16(0x00ff),  /* Compression method
							    * mask. First
							    * illegal value. */
	ATTRIBUTE_IS_ENCRYPTED	   = cpu_to_le16(0x4000),
	ATTRIBUTE_IS_SPARSE	   = cpu_to_le16(0x8000),
} __attribute__ ((__packed__)) ATTRIBUTE_FLAGS;

/*
 * The collation rules for sorting views/indexes/etc (32-bit).
 */
typedef enum {
	COLLATION_BINARY	 = cpu_to_le32(0), /* Collate by binary compare
						      where the first byte is
						      most significant. */
	COLLATION_FILENAME	 = cpu_to_le32(1), /* Collate file names as
						      Unicode strings. */
	COLLATION_UNICODE_STRING = cpu_to_le32(2), /* Collate Unicode strings
						      by comparing their binary
						      Unicode values, except
						      that when a character can
						      be uppercased, the upper
						      case value collates before
						      the lower case one. */
	COLLATION_NTOFS_ULONG		= cpu_to_le32(16),	/* ??? */
	COLLATION_NTOFS_SID		= cpu_to_le32(17),	/* ??? */
	COLLATION_NTOFS_SECURITY_HASH	= cpu_to_le32(18),	/* ??? */
	COLLATION_NTOFS_ULONGS		= cpu_to_le32(19),	/* ??? */
} COLLATION_RULES;

/*
 * Attribute record header.
 */
typedef struct {
/*Ofs*/
/*  0*/	ATTRIBUTE_TYPE type;	/* The (4-byte) type of the attribute. */
/*  4*/	__u32 length;		/* Byte size of the resident part of the
				   attribute (aligned to 8-byte boundary). */
/*  8*/	__u8 non_resident;	/* If 0, attribute is resident.
				   If 1, attribute is non-resident. */
/*  9*/	__u8 name_length;	/* Unicode character size of name of attribute.
				   0 if unnamed. */
/* 10*/	__u16 name_offset;	/* If name_length != 0, the byte offset to the
				   beginning of the name from the attribute
				   record. Note that the name is stored as a
				   Unicode string. */
/* 12*/	ATTRIBUTE_FLAGS flags;	/* Bit array of ATTRIBUTE_* flags (16-bit). */
/* 14*/	__u16 instance;		/* The instance of this attribute record. This
				   number is unique within this mft record (see 
				   MFT_RECORD_HEADER/next_attribute_instance
				   notes in mft.h for more details). */
/* sizeof() = 16 bytes */
} __attribute__ ((__packed__)) ATTRIBUTE_RECORD_HEADER;

/*
 * Flags of resident attributes (8-bit).
 */
typedef enum {
	RESIDENT_ATTRIBUTE_IS_INDEXED	= 0x01,	/* Attribute is referenced in
						   an index somewhere (has
						   implications for deleting
						   modifying the attribute). */
} __attribute__ ((__packed__)) RESIDENT_ATTRIBUTE_FLAGS;

/*
 * Resident attribute record header.
 */
typedef struct {
/*Ofs*/
/*  0*/	ATTRIBUTE_RECORD_HEADER attribute;
/* 16*/	__u32 value_length;	/* Byte size of attribute value. */
/* 20*/	__u16 value_offset;	/* Byte offset of the attribute value from the
				   start of the attribute record. */
/* 22*/	__u8 resident_flags;	/* Bit array of RESIDENT_ATTRIBUTE_* flags. */
/* 23*/	__s8 reserved;		/* Reserved/alignment to 8-byte boundary. */
/* sizeof() = 24 bytes */
} __attribute__ ((__packed__)) RESIDENT_ATTRIBUTE_RECORD_HEADER;

/*
 * Non-resident attribute record header.
 */
typedef struct {
/*Ofs*/
/*  0*/	ATTRIBUTE_RECORD_HEADER attribute;
/* 16*/	__u64 lowest_vcn;	/* Lowest valid virtual cluster number (vcn)
				   for this portion of the attribute value or
				   0 if this is the only portion (usually the
				   case. - Only when an attribute list is used
				   does lowest_vcn != 0 ever occur. */
/* 24*/	__u64 highest_vcn;	/* Highest valid vcn of this portion of the
				   attribute value. - Usually there is only one
				   portion, so this usually equals the attribute
				   value size in clusters. */
/* 30*/	__u16 mapping_pairs_offset; /* Byte offset from the beginning of the 
				   structure to the mapping pairs array which
				   contains the mappings between the vcns and
				   the logical cluster numbers (lcns). */
/* 32*/	__u8 compression_unit;	/* The compression unit expressed as the log
				   to the base 2 of the number of clusters in a
				   compression unit. 0 means not compressed.
				   (This effectively limits the compression
				   unit size to be a power of two clusters.) */
/* 33*/	__u8 reserved[5];	/* Align to 8-byte boundary. */
/* 38*/	__u64 allocated_size;	/* Byte size of disk space allocated to hold
				   the attribute value. Always is a multiple of
				   the cluster size. */
/* 46*/	__u64 data_size;	/* Byte size of the attribute value. Can be
				   larger than allocated_size if attribute
				   value is compressed or sparse. */
/* 54*/	__u64 initialized_size;	/* Byte size of initialized portion of the
				   attribute value. */
/* 62*/	__u64 compressed_size;	/* Byte size of the attribute value after
				   compression. Only present when compressed. */
/* sizeof() = 70 bytes (when compressed, otherwise = 62 bytes) */
} __attribute__ ((__packed__)) NONRESIDENT_ATTRIBUTE_RECORD_HEADER;

/*
 * FIXME: Should we combine the resident and non-resident attribute record
 * headers into the attribute record header with a union for the two structs
 * inside it? - Probably but will break existing programs so keep it ATM.
 */

/*
 * File attribute flags (32-bit).
 */
typedef enum {
	FILE_ATTRIBUTE_READONLY		= cpu_to_le32(0x00000001),
	FILE_ATTRIBUTE_HIDDEN		= cpu_to_le32(0x00000002),
	FILE_ATTRIBUTE_SYSTEM		= cpu_to_le32(0x00000004),
	/* Old DOS volid. Unused in NT.	= cpu_to_le32(0x00000008), */

	FILE_ATTRIBUTE_DIRECTORY	= cpu_to_le32(0x00000010),
	/* FILE_ATTRIBUTE_DIRECTORY is not considered valid in NT. It is
	   reserved for the DOS SUBDIRECTORY flag. */
	FILE_ATTRIBUTE_ARCHIVE		= cpu_to_le32(0x00000020),
	FILE_ATTRIBUTE_DEVICE		= cpu_to_le32(0x00000040),
	FILE_ATTRIBUTE_NORMAL		= cpu_to_le32(0x00000080),

	FILE_ATTRIBUTE_TEMPORARY	= cpu_to_le32(0x00000100),
	FILE_ATTRIBUTE_SPARSE_FILE	= cpu_to_le32(0x00000200),
	FILE_ATTRIBUTE_REPARSE_POINT	= cpu_to_le32(0x00000400),
	FILE_ATTRIBUTE_COMPRESSED	= cpu_to_le32(0x00000800),

	FILE_ATTRIBUTE_OFFLINE			= cpu_to_le32(0x00001000),
	FILE_ATTRIBUTE_NOT_CONTENT_INDEXED	= cpu_to_le32(0x00002000),
	FILE_ATTRIBUTE_ENCRYPTED		= cpu_to_le32(0x00004000),

	FILE_ATTRIBUTE_VALID_FLAGS	= cpu_to_le32(0x00007fb7),
	/* FILE_ATTRIBUTE_VALID_FLAGS masks out the old DOS VolId and the 
	   FILE_ATTRIBUTE_DEVICE and preserves everything else. This mask
	   is used to obtain all flags that are valid for reading. */
	FILE_ATTRIBUTE_VALID_SET_FLAGS	= cpu_to_le32(0x000031a7),
	/* FILE_ATTRIBUTE_VALID_SET_FLAGS masks out the old DOS VolId, the
	   F_A_DEVICE, F_A_DIRECTORY, F_A_SPARSE_FILE, F_A_REPARSE_POINT,
	   F_A_COMPRESSED and F_A_ENCRYPTED and preserves the rest. This mask
	   is used to to obtain all flags that are valid for setting. */

	FILE_ATTRIBUTE_DUP_FILENAME_INDEX_PRESENT = cpu_to_le32(0x10000000),
	/* This is a copy of the corresponding bit from the mft record, telling
	   us whether this is a directory or not, i.e. whether it has an
	   index root attribute or not. */
	FILE_ATTRIBUTE_DUP_VIEW_INDEX_PRESENT	  = cpu_to_le32(0x20000000),
	/* This is a copy of the corresponding bit from the mft record, telling
	   us whether this file has a view index present (eg. object id index
	   or quota index). */
} FILE_ATTRIBUTE_FLAGS;

/*
 * NOTE on times in NTFS: All times are in MS standard time format, i.e. they
 * are the number of 100-nanosecond intervals since 1st January 1601.
 */

/*
 * Attribute: Standard information.
 *
 * NOTE: Always resident.
 * NOTE: Present in all base file records on a volume.
 */
typedef struct {
/*Ofs*/
/*  0*/	__u64 creation_time;		/* When the file was created. */
/*  8*/	__u64 last_modification_time;	/* Time of last change of data
					   attribute. */
/* 16*/	__u64 last_change_time;		/* Time of last change of this mft
					   record. */
/* 24*/	__u64 last_access_time;		/* Approximate time when the file was
					   last accessed (obviously this is not
					   updated on read-only volumes). In
					   Windows this is only updated when
					   accessed if some time delta has
					   passed since the last update. */
/* 30*/	FILE_ATTRIBUTE_FLAGS file_attributes; /* Flags describing the file. */
/*
 * Following fields are only present in NTFS v3.0+ (i.e. Win2k+). If a volume
 * has been upgraded from a previous NTFS version, then these fields are
 * present only if the file has been accessed since the upgrade. Recognize
 * the difference by comparing the length of the resident attribute value. If
 * it is 48, then the following fields are missing. If it is 72 then the fields
 * are present. Maybe just check like this:
 * 	if (resident.ValueLength < sizeof(STANDARD_INFORMATION)) {
 * 		Assume NTFS 1.2- format.
 * 		If (volume version is 3.0+)
 * 			Upgrade attribute to NTFS 3.0 format.
 * 		else
 * 			Use NTFS 1.2- format for access.
 * 	} else
 * 		Use NTFS 3.0 format for access.
 * Only problem is that it might be legal to set the length of the value to
 * arbitrarily large values thus spoiling this check. - But chkdsk probably
 * views that as a corruption, assuming that it behaves like this for all
 * attributes.
 */
/* 34*/	__u32 maximum_versions;	/* Maximum allowed versions for file. Zero
				   means that version numbering is disabled. */
/* 38*/	__u32 version_number;	/* This file's version (if any). Should make
				   this zero if maximum_versions is zero. */
/* 42*/	__u32 class_id;		/* Class id from bidirectional class id 
				   index (?). */
/* 46*/	__u32 owner_id;		/* Id for file owner, from bidir security
				   index. This is also used to find the quota
				   associated with this file, probably as an
				   index into /$Extend/$Quota (?). Is zero if
				   quotas are disabled. */
/* 50*/	__u32 security_id;	/* Security Id for the file. Translate via
				   bidir index to granted access Acl. Probably
				   as an index into /$Secure (?). */
/* 54*/	__u64 quota_charged;	/* Byte size of the charge to the quota for
				   all streams of the file. Is zero if quotas
				   are disabled. */
/* 62*/	__u64 usn;		/* Last update sequence number of the file. This
				   is a direct index into the change (aka Usn)
				   journal file. It is zero if the journal is
				   disabled.
				   NOTE: To disable the journal need to delete
				   the journal file itself and to then walk the
				   whole mft and set all Usn entries in all mft
				   records to zero! (This can take a while!)
				   The journal is /$Extend/UsnJrnl. Windows 2k
				   will recreate the journal and initiate
				   logging if necessary when mounting the
				   partition. This, in contrast to disabling the
				   journal is a very fast process, so the user
				   won't even notice it. */
/* sizeof() = 70 bytes */
} __attribute__ ((__packed__)) STANDARD_INFORMATION;

/*
 * Attribute: Attribute list.
 *
 * The value of the attribute list attribute consists of a sequence of
 * variable length, 64-bit aligned ATTRIBUTE_LIST_ENTRY records. The value
 * can be either resident or non-resident.
 * The attribute list attribute contains one entry for each attribute of the
 * file in which the list is located, except for the list attribute itself.
 * The list is sorted first by: attribute type, then by attribute name (if 
 * present) and third by attribute value. In the third case the attribute
 * value of the referenced attribute is required to be resident. Also, it is
 * not allowed to have two attributes with all three sorting keys equal.
 * Further restrictions: 
 * 	- If not resident, the vcn to lcn mapping array has to fit inside the
 * 	  base mft record.
 * 	- The attribute list attribute value has a maximum size of 256kb. This
 * 	  is imposed by the Windows cache manager.
 */
typedef struct {
/*Ofs*/
/*  0*/	ATTRIBUTE_TYPE attribute_type;	/* Type of referenced attribute. */
/*  4*/	__u16 record_length;		/* Byte size of this entry. */
/*  6*/	__u8 attribute_name_length;	/* Size in Unicode chars of the name of
					   the attribute or 0 if unnamed. */
/*  7*/	__u8 attribute_name_offset;	/* Byte offset to beginning of attribute
					   name (always set this to where the
					   name would start even if unnamed). */
/*  8*/	__u64 lowest_vcn;	/* Lowest virtual cluster number of this portion
				   of the attribute value. This is usually 0. It
				   is non-zero for the case where one attribute
				   does not fit into one mft record and thus
				   several mft records are allocated to hold
				   this attribute. In the latter case, each mft
				   record holds one extent of the attribute and
				   there is one attribute list entry for each
				   extent. */
/* 16*/	__u64 mft_reference;	/* The reference of the mft record holding the
				   NONRESIDENT_ATTRIBUTE_RECORD_HEADER structure
				   for this portion of the attribute value or
				   holding the RESIDENT_ATTRIBUTE_RECORD_HEADER
				   structure if the reference points to the
				   same mft record as the one the attribute
				   list resides in. */
/* 24*/	__u16 instance;		/* The instance of the attribute being
				   referenced. */
/* 26*/	__u16 attribute_name[0];/* Use when creating only. When reading use
				   attribute_name_offset to determine the
				   location of the attribute_name.*/
/* sizeof() = 26 + (attribute_name_length * 2) bytes */
} __attribute__ ((__packed__)) ATTRIBUTE_LIST_ENTRY;

/*
 * The maximum allowed length for a file name.
 * 
 * FIXME: Is it 255? In NT4 using explorer can only do up to a maximum of 218
 * charcters. (?!?)
 */
#define MAXIMUM_FILENAME_LENGTH	256

/*
 * Possible namespaces for filenames in ntfs.
 */
typedef enum {
	FILENAME_POSIX			= cpu_to_le16(0x0000),
		/* This is the largest namespace. It is case sensitive and 
		   allows all Unicode characters except for: '\0' and '/'.
		   Beware that in WinNT/2k files which eg have the same name
		   except for their case will not be distinguished by the
		   standard utilities and thus a "del filename" will delete
		   both "filename" and "fileName" without warning. */
	FILENAME_WIN32			= cpu_to_le16(0x0001),
		/* The standard WinNT/2k NTFS long filenames. Case insensitive.
		   All Unicode chars except: '\0', '"', '*', '/', ':', '<', 
		   '>', '?', '\' and '|'. Further, names cannot end with a '.'
		   or a space. */
	FILENAME_DOS			= cpu_to_le16(0x0002),
		/* The standard DOS filenames (8.3 format). Uppercase only.
		   All 8-bit characters greater space, except: '"', '*', '+',
		   ',', '/', ':', ';', '<', '=', '>', '?' and '\'. */
	FILENAME_WIN32_AND_DOS		= cpu_to_le16(0x0003), 
		/* 3 means that both the Win32 and the DOS filenames are
		   identical and hence have been saved in this single filename
		   record. */
	SIZE_INDICATOR_FOR_ATTRIBUTE_PACKED = 0xffff;
		/* This is not defined by ntfs but we need it to tell gcc
		   to make this enum type 16-bit. */
} __attribute__ ((__packed__)) FILENAME_TYPE_FLAGS;

/*
 * Attribute: Filename.
 *
 * NOTE: Always resident. (?)
 */
typedef struct {
	__u64 parent_directory_mft_reference;	/* Directory this filename is
						   referenced from. */
	__u64 creation_time;			/* Time file was created. */
	__u64 last_modification_time;		/* Time data attribute was
						   last modified. */
	__u64 last_change_time;			/* Time mft record was
						   modified. */
	__u64 last_access_time;			/* Last time mft record was
						   accessed. See notes for this
						   in attribute standard
						   information above. */
	__u64 allocated_size;			/* Byte size of allocated space
					           for the data attribute.
						   NOTE: Is a multiple of the
						   cluster size. */
	__u64 data_size;			/* Byte size of actual data in
						   data attribute.
						   NOTE: Only present when
						   lowest_vcn is 0. */
	FILE_ATTRIBUTE_FLAGS file_attributes;	/* Flags describing the file.*/
	union {
		struct {
			__u16 reserved;		/* Reserved for alignment. */
			__u16 packed_ea_size;	/* Size of the buffer needed to
						   pack the extended attributes
						   (EAs), if such are present.*/
		};
		__u32 reparse_point_tag;	/* Type of reparse point,
						   present only in reparse
						   points and only if there are
						   no EAs. */
	};
	__u8 filename_length;			/* Length of filename in
						   Unicode characters. */
	__u8 filename_type;			/* Bit field of FILENAME_TYPE_*
						   flags. */
	__u16 filename[filename_length];	/* Filename in Unicode. */
} __attribute__ ((__packed__)) FILENAME_ATTRIBUTE;

/*
 * GUID structures store globally unique identifiers (GUID). A GUID is a 
 * 128-bit value consisting of one group of eight hexadecimal digits, followed
 * by three groups of four hexadecimal digits each, followed by one group of
 * twelve hexadecimal digits. GUIDs are Microsoft's implementation of the
 * distributed computing environment (DCE) universally unique identifier (UUID).
 * Example of a GUID:
 * 	1F010768-5A73-BC91-0010A52216A7
 */
typedef struct {
	__u32 data1;	/* The first eight hexadecimal digits of the GUID. */
	__u16 data2;	/* The first group of four hexadecimal digits. */
	__u16 data3;	/* The second group of four hexadecimal digits. */
	__u8 data4[8];	/* The first two bytes are the third group of four
			   hexadecimal digits. The remaining six bytes are the
			   final 12 hexadecimal digits. */
} __attribute__ ((__packed__)) GUID;

/*
 * Attribute: Object id.
 *
 * NOTE: Always resident.
 */
typedef struct {
	//MFT_REFERENCE file_system_reference;	/* Is it this structure or */
	//__u8 extended_info[48];		/* the one declared below?!? */
//} __attribute__ ((__packed__)) OBJECT_ID_ATTRIBUTE;
	GUID object_id;				/* Unique id assigned to the
						   file.*/
	union {
		struct {
			GUID birth_volume_id;	/* Unique id of volume on which
						   the file was first created.
						   NOTE: Optional. */
			GUID birth_object_id;	/* Unique id of file when it was
						   first created.
						   NOTE: Optional. */
			GUID domain_id;		/* Reserved.
						   NOTE: Optional. */
		};
		__u8 extended_info[48];
	};
} __attribute__ ((__packed__)) OBJECT_ID_ATTRIBUTE;

/*
 * Attribute: Security descriptor.
 *
 * NOTE: Always resident.
 * NOTE: Not used in NTFS 3.0+. (Not at all?)
 */
typedef struct {
	// SID sid; ???	/* A standard self-relative security descriptor. */
} __attribute__ ((__packed__)) SECURITY_DESCRIPTOR_ATTRIBUTE;

/*
 * Attribute: Volume name.
 * 
 * NOTE: Always resident.
 * NOTE: Present only in FILE_$Volume.
 */
typedef struct {
	__u16 name[0];		/* The name of the volume in Unicode. */
} __attribute__ ((__packed__)) VOLUME_NAME;

/*
 * Possible flags for the volume (16-bit).
 */
typedef enum {
	VOLUME_IS_DIRTY			= cpu_to_le16(0x0001),
	VOLUME_RESIZE_LOG_FILE		= cpu_to_le16(0x0002),
	VOLUME_UPGRADE_ON_MOUNT 	= cpu_to_le16(0x0004),
	VOLUME_MOUNTED_ON_NT4		= cpu_to_le16(0x0008),
	VOLUME_DELETE_USN_UNDERWAY	= cpu_to_le16(0x0010),
	VOLUME_REPAIR_OBJECT_ID		= cpu_to_le16(0x0020),
	VOLUME_MODIFIED_BY_CHKDSK	= cpu_to_le16(0x8000),
} __attribute__ ((__packed__)) VOLUME_FLAGS;

/*
 * Attribute: Volume information.
 *
 * NOTE: Always resident.
 * NOTE: Present only in FILE_$Volume.
 */
typedef struct {
	__u64 reserved;		/* Not used (yet?). */
	__u8 major_version;	/* Major version of the ntfs format. */
	__u8 minor_version;	/* Minor version of the ntfs format. */
	VOLUME_FLAGS flags;	/* Bit array of VOLUME_* flags. */
} __attribute__ ((__packed__)) VOLUME_INFORMATION;

/*
 * Attribute: Data attribute.
 *
 * Data contents of a file (unnamed stream) or of a named stream.
 */
typedef struct {
	__u8 data[0];		/* The file's data contents. */
} __attribute__ ((__packed__)) DATA_ATTRIBUTE;

/*
 * Index header flags.
 */
typedef enum {
	NO_INDEX_NODE	= cpu_to_le32(0), /* Small directory, i.e. the whole
					     directory fits inside the index
					     root attribute and hence there is
					     no index allocation attribute. */
	INDEX_NODE	= cpu_to_le32(1), /* Large directory, i.e. it doesn't
					     fit in the index root attribute
					     and hence an index allocation
					     attribute is present. */
} INDEX_HEADER_FLAGS;

typedef enum {
	INDEX_ENTRY_NODE = cpu_to_le32(1), /* This entry references an index
					      allocation attribute value. */
	INDEX_ENTRY_END  = cpu_to_le32(2), /* This signifies the last entry in
					      an index buffer. */
} INDEX_ROOT_INDEX_ENTRY_FLAGS;

/*
 * Attribute: Bitmap.
 */
typedef struct {
	__u8 bitmap[0];			/* Array of bits. */
} __attribute__ ((__packed__)) BITMAP_ATTRIBUTE;

/*
 * Attribute: Reparse point.
 *
 * FIXME: Describe more about reparse points here including the flags in the
 * ReparseTag.
 */
typedef struct {
	__u32 reparse_tag;		/* Reparse point type (inc. flags). */
	__u16 reparse_data_length;	/* Byte size of reparse data. */
	__u16 reserved;			/* Align to 8-byte boundary. */
	__u8 reparse_data[0];		/* Meaning depends on reparse_tag. */
} __attribute__ ((__packed__)) REPARSE_POINT;

/*
 * Attribute: Extended attribute (EA) information.
 */
typedef struct {
	__u16 packed_ea_length;		/* Byte size of the buffer needed to
					   pack the extended attributes. */
	__u16 need_ea_count;		/* The number of extended attributes
					   which have the NEED_EA bit set. */
	__u32 unpacked_ea_length;	/* Byte size of the buffer required to
					   query the extended attributes. */
} __attribute__ ((__packed__)) EA_INFORMATION;

typedef enum {
//	NEED_EA	= ???;
} EA_FLAGS;

/*
 * Attribute: Extended attribute (EA).
 * 
 * Like the attribute list and the index buffer list, the EA attribute value is 
 * a sequence of EA_ATTRIBUTE variable length records.
 */
typedef struct {
	__u32 next_entry_offset;	/* Offset to the next EA_ATTRIBUTE. */
	__u8 flags;			/* Bit array of EA_FLAGS. */
	__u8 ea_name_length;		/* Length of the name of the extended
					   attribute in characters.
					   FIXME: Unicode? */
	__u16 ea_value_length;		/* Byte size of the EA's value. */
	__u8 ea_name[ea_name_length];	/* Name of the EA.
					   FIXME: In Unicode? */
	__u8 ea_data[ea_value_length];	/* The value of the EA. Immediately
					   follows the name. */
} __attribute__ ((__packed__)) EA_ATTRIBUTE;

/*
 * Attribute: .
 */
typedef struct {
} __attribute__ ((__packed__)) INDEX_HEADER;

/*
 * Attribute: .
 */
typedef struct {
} __attribute__ ((__packed__)) INDEX_ROOT;

/*
 * Attribute: .
 */
typedef struct {
} __attribute__ ((__packed__)) INDEX_ALLOCATION;

/*
 * Attribute: .
 */
typedef struct {
} __attribute__ ((__packed__)) INDEX_ENTRY;

/* min macro used in attrib.c. */
#ifndef min
#define min(a,b)	((a) <= (b) ? (a) : (b))
#endif

typedef struct {	/* In memory VCN to LCN mapping structure element. */
	__s64 vcn;	/* VCN = starting virtual cluster number */
	__s64 lcn;	/* LCN = starting logical cluster number */
	__u64 length;	/* run length in clusters */
} run_list_element;

typedef run_list_element *run_list;/*In memory VCN to LCN mapping array.*/
/* run_list notes:
 * - The last VCN is recognised by the fact that length == 0.
 * - LCN == 0 at any point means that the count VCNs starting at VCN are not 
 *   physically allocated (ie. this is a hole). */
/* FIXME: Should this be a linked list so it is easier/quicker to edit? */

/* Allocate a run_list array and decompress the run-list of the non-resident
 * attribute attr into the run_list array.
 * Return a pointer to the run_list array or NULL on error.
 * Notes: caller has to free the run_list array when finished. */
run_list decompress_run_list(NONRESIDENT_ATTRIBUTE_RECORD_HEADER *attr);

/* Determine the logical cluster number given the virtual cluster number and
 * the run list describing the mapping between the LCNs and VCNs. 
 * Return -ERRNO on error (ERRNO being the error number) and notably -NOENT 
 * if vcn is outside the boundaries covered by the run list. */
__s64 vcn_to_lcn(run_list rl, __s64 vcn);

/* Set the volume flags in the Mft record b to flags.
 * Return 1 on success or 0 on error. */
int set_ntfs_volume_flags(MFT_RECORD_HEADER *b, __u16 flags);

/* Get the location of the desired attribute of type t and name n (n can be
 * NULL for unnamed attributes; note that n is a Unicode string). Return a
 * pointer to the attribute or NULL if the attribute is not present or an
 * error situation exists. */
ATTRIBUTE_RECORD_HEADER *find_attribute(MFT_RECORD_HEADER *b, ATTRIBUTE_TYPE t,
							      wchar_t *n);

#include "volume.h"

__u64 get_attribute_value_length(ATTRIBUTE_RECORD_HEADER *a);

/* Make a copy of the attribute value of the attribute a into the destination
 * buffer b. Note that the size of b has to be at least equal to the value
 * returned by get_attribute_value_length(a).
 * Return number of bytes copied. If this is zero check errno. If errno is 0
 * then nothing was read due to a zero-length attribute value, otherwise
 * errno describes the error. */
__u64 get_attribute_value(ntfs_volume *vol, ATTRIBUTE_RECORD_HEADER *a, __u8 *b);

int set_attribute_value(ntfs_volume *vol, ATTRIBUTE_RECORD_HEADER *a, 
						    unsigned char *b, __u64 l);


#endif /* defined ATTRIB_H */


--- NEW FILE ---
/*
 * endians.h - Definitions related to handling of byte ordering. Part of the
 * 	       Linux-NTFS project.
 * 	       
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/* 
 * Notes:
 *
 * 	We define the conversion functions including typecasts since the
 * defaults don't necessarily perform appropriate typecasts.
 * 	Also, using our own functions means that we can change them if it
 * turns out that we do need to use the unaligned access macros on 
 * architectures requirering aligned memory accesses...
 */

#ifndef ENDIANS_H
#define ENDIANS_H

#include <asm/byteorder.h>

/* Unsigned from LE to CPU conversion. */

#define le16_to_cpu(x)		(__u16)__le16_to_cpu((__u16)(x))
#define le32_to_cpu(x)		(__u32)__le32_to_cpu((__u32)(x))
#define le64_to_cpu(x)		(__u64)__le64_to_cpu((__u64)(x))

#define le16_to_cpup(x)		(__u16)__le16_to_cpu(*(__u16*)(x))
#define le32_to_cpup(x)		(__u32)__le32_to_cpu(*(__u32*)(x))
#define le64_to_cpup(x)		(__u64)__le64_to_cpu(*(__u64*)(x))

/* Signed from LE to CPU conversion. */

#define sle16_to_cpu(x)		(__s16)__le16_to_cpu((__s16)(x))
#define sle32_to_cpu(x)		(__s32)__le32_to_cpu((__s32)(x))
#define sle64_to_cpu(x)		(__s64)__le64_to_cpu((__s64)(x))

#define sle16_to_cpup(x)	(__s16)__le16_to_cpu(*(__s16*)(x))
#define sle32_to_cpup(x)	(__s32)__le32_to_cpu(*(__s32*)(x))
#define sle64_to_cpup(x)	(__s64)__le64_to_cpu(*(__s64*)(x))

/* Unsigned from CPU to LE conversion. */

#define cpu_to_le16(x)		(__u16)__cpu_to_le16((__u16)(x))
#define cpu_to_le32(x)		(__u32)__cpu_to_le32((__u32)(x))
#define cpu_to_le64(x)		(__u64)__cpu_to_le64((__u64)(x))

#define cpu_to_le16p(x)		(__u16)__cpu_to_le16(*(__u16*)(x))
#define cpu_to_le32p(x)		(__u32)__cpu_to_le32(*(__u32*)(x))
#define cpu_to_le64p(x)		(__u64)__cpu_to_le64(*(__u64*)(x))

/* Signed from CPU to LE conversion. */

#define scpu_to_le16(x)		(__s16)__cpu_to_le16((__s16)(x))
#define scpu_to_le32(x)		(__s32)__cpu_to_le32((__s32)(x))
#define scpu_to_le64(x)		(__s64)__cpu_to_le64((__s64)(x))

#define scpu_to_le16p(x)	(__s16)__cpu_to_le16(*(__s16*)(x))
#define scpu_to_le32p(x)	(__s32)__cpu_to_le32(*(__s32*)(x))
#define scpu_to_le64p(x)	(__s64)__cpu_to_le64(*(__s64*)(x))

#endif /* defined ENDIANS_H */


--- NEW FILE ---
/*
 * mft.h - Exports for MFT record handling. Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef MFT_H
#define MFT_H

#include "endians.h"
#include "ntfs_rec.h"

#define is_mft_record(x)	( is_file_record(x) )
#define is_mft_recordp(p)	( is_file_recordp(p) )

/*
 * These are the so far known MFT_RECORD_* flags which contain information
 * about the mft record in which they are present.
 */
typedef enum {
	MFT_RECORD_IN_USE	= cpu_to_le16(0x0001),
	MFT_RECORD_IS_DIRECTORY	= cpu_to_le16(0x0002),
} MFT_RECORD_FLAGS;

/*
 * mft references (aka file references or file record segment references) are
 * used whenever a structure needs to refer to a record in the mft.
 * 
 * A reference consists of the 48-bit index into the mft and the 16-bit
 * sequence number used to detect stale references.
 *
 * The sequence number is a circular counter (skipping 0) describing how many
 * times the referenced mft record has been (re)used. This has to match the
 * sequence number of the mft record being referenced, otherwise the reference
 * is considered stale and removed (FIXME: only ntfsck or the driver itself?).
 *
 * If the sequence number is zero it is assumed that no sequence number
 * consistency checking should be performed.
 *
 * FIXME: Since inodes are 32-bit as of now, the driver needs to always check
 * for high_part being 0 and if not either BUG(), cause a panic() or handle
 * the situation in some other way. This shouldn't be a problem as a volume has
 * to become HUGE in order to need more than 32 bits worth of mft records.
 * Assuming the standard mft records size of 1kb only the records (never mind
 * the non-resident attributes, etc.) would require 4Tb of space on their own
 * for the first 32 bits worth of records. This is only if some strange person
 * doesn't decide to foul play and make the mft sparse which would be a really
 * horrible thing to do as it would trash our current driver implementation. )-:
 * Do I hear screams "we want 64-bit inodes!" ?!? (-;
 */
typedef union {
    struct {
	struct {		
		__u32 low_part;	/* Mft record number being referenced split */
		__u16 high_part;/* into the low 32-bits and the high 16-bits. */
	};
	__u16 sequence_number;	/* The sequence number, see above. */
    };
    __u64 mft_reference;	/* The whole mft reference as one number. */
} __attribute__ ((__packed__)) MFT_REFERENCE;

/* The mft record header present at the beginning of every record in the mft. */
typedef struct {
/*Ofs*/
/*  0*/	NTFS_RECORD_HEADER ntfs;
/*  8*/	__s64 lsn;		/* Log file sequence number for this record. */
/* 16*/	__u16 sequence_number;	/* Number of times this mft record has been
		   		   reused. (See description for MFT_REFERENCE
				   above.) NOTE: The increment (skipping zero)
				   is done when the file is deleted. NOTE: If
				   this is zero it is left zero. */
/* 18*/	__u16 link_count; 	/* Number of hard links, i.e. the number of 
				   directory entries referencing this record.
				   NOTE: When deleting a directory entry we
				   check the link_count and if it is 1 we
				   delete the file. Otherwise we delete the
				   FILENAME_ATTRIBUTE being referenced by the
				   directory entry from the mft record and
				   decrement the link_count.
				   FIXME: Careful with Win32 + DOS names! */
/* 20*/	__u16 attributes_offset;/* Byte offset to the first attribute in this
				   mft record from the start of the mft record.
				   NOTE: Must be aligned to 8-byte boundary. */
/* 22*/	__u16 flags;		/* Bit array of MFT_RECORD_* flags. When a file
				   is deleted, the MFT_RECORD_IN_USE flag is
				   set to zero. */
/* 24*/	__u32 bytes_in_use;	/* Number of bytes used in this mft record.
				   NOTE: Must be aligned to 8-byte boundary. */
/* 28*/	__u32 bytes_allocated;	/* Number of bytes allocated for this mft
				   record. This should be equal to the mft
				   record size. */
/* 32*/	__u64 base_file_record;	/* This is zero for base mft records. When it
				   is not zero it is a mft reference pointing
				   to the base mft record to which this record
				   belongs (this is then used to locate the
				   attribute list attribute present in the base
				   record which describes the extension record
				   and hence might need modification when the
				   extension record itself is modified). */
/* 40*/	__u16 next_attribute_instance; /* The instance number that will be
				   assigned to the next attribute added to this
				   mft record. NOTE: incremented each time
				   after it is used. NOTE: Every time the mft
				   record is reused this number is set to zero.
				   NOTE: The first instance number is always 0.
				 */
/* 42 = sizeof() */
} __attribute__ ((__packed__)) MFT_RECORD_HEADER;

/**
 * get_mft_record_data_size - return number of bytes used in mft record @b
 * @b: the mft record to get the data size of
 *
 * Takes the mft record @b and returns the number of bytes used in the record
 * or 0 on error (i.e. b is not a valid mft record). Zero is not a valid size
 * for an mft record as it at least has to have the MFT_RECORD_HEADER thus
 * making the minumum size:
 * 	(sizeof(MFT_RECORD_HEADER) + 7) & ~7 + sizeof(ATTRIBUTE_TYPE) = 52 bytes
 * Aside: The 8-byte alignment and the 4 bytes for the attribute type are needed
 * as each mft record has to have a list of attributes even if it only contains
 * the attribute $END which doesn't contain anything else apart from it's type.
 * Also, you would expect every mft record to contain an update sequence array
 * as well but that could in theory be non-existent (don't know if Windows NTFS
 * wouldn't view this as corruption in itself though!).
 */
inline __u32 get_mft_record_data_size(const MFT_RECORD_HEADER *b);

#endif /* defined MFT_H */


--- NEW FILE ---
/*
 * ntfs_rec.h - Exports for NTFS record handling. Part of the Linux-NTFS
 * 		project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef NTFS_REC_H
#define NTFS_REC_H

#include "endians.h"

/*
 * Magic identifiers present at the beginning of all ntfs record containing
 * records (like mft records for example.
 */
typedef enum {
	magic_BAAD = cpu_to_le32(0x44414142), /* "BAAD" == corrupt record */
	magic_CHKD = cpu_to_le32(0x424b4843), /* "CHKD" == chkdsk ??? */
        magic_FILE = cpu_to_le32(0x454c4946), /* "FILE" == mft entry */
	magic_HOLE = cpu_to_le32(0x454c4f48), /* "HOLE" == ??? (NTFS 3.0+?) */
        magic_INDX = cpu_to_le32(0x58444e49), /* "INDX" == index buffer */
} NTFS_RECORD_TYPES;

/*
 * Generic magic comparison macros. Finally found a use for the ## preprocessor
 * operator! (-8
 */
#define is_magic(x, m)		(   (__u32)(x) == magic_##m )
#define is_magicp(p, m) 	( *(__u32*)(p) == magic_##m )

/*
 * Specialised magic comparison macros.
 */
#define is_baad_record(x)	( is_magic (x, BAAD) )
#define is_baad_recordp(p)	( is_magicp(p, BAAD) )
#define is_chkd_record(x)       ( is_magic (x, CHKD) )
#define is_chkd_recordp(p)      ( is_magicp(p, CHKD) )
#define is_file_record(x)	( is_magic (x, FILE) )
#define is_file_recordp(p)	( is_magicp(p, FILE) )
#define is_hole_record(x)       ( is_magic (x, HOLE) )
#define is_hole_recordp(p)      ( is_magicp(p, HOLE) )
#define is_indx_record(x)       ( is_magic (x, INDX) )
#define is_indx_recordp(p)      ( is_magicp(p, INDX) )

/*
 * Defines for the NTFS filesystem. Don't want to use BLOCK_SIZE and 
 * BLOCK_SIZE_BITS from the kernel as that is 1024 and hence too high for us.
 */
#define NTFS_SECTOR_SIZE 	512
#define NTFS_SECTOR_SIZE_BITS	9

/*
 * The Update Sequence Array (usa) is an array of the __u16 values which belong
 * to the end of each sector protected by the update sequence record in which
 * this array is contained. Note that the first entry is the Update Sequence
 * Number (usn), a cyclic counter of how many times the protected record has
 * been written to disk. (The values 0 and -1 (ie. 0xffff) are not used.) All
 * last __u16's of each sector have to be equal to the Usn (during reading) or
 * are set to it (during writing). If they are not, an incomplete multi sector
 * transfer has occured when the data was written.
 */
typedef struct {
	NTFS_RECORD_TYPES magic; /* A four-byte magic identifying the record
				    type and/or status. */
	__u16 usa_ofs;		 /* Offset to the Update Sequence Array (usa)
				    from the start of the ntfs record. */
	__u16 usa_count;	 /* Number of __u16 sized entries in the usa
				    including the Update Sequence Number (usn),
				    thus the number of fixups is the usa_count
				    minus 1. */
} __attribute__ ((__packed__)) NTFS_RECORD_HEADER;

/**
 * post_read_mst_fixup - deprotect multi sector transfer protected data
 * @b:		pinter to the data to deprotect
 * @size:	size in bytes of @b
 * 
 * Perform the necessary post read multi sector transfer fixup and detect the
 * presence of incomplete multi sector transfers. - In that case, overwrite the
 * magic of the ntfs record header being processed with "BAAD" (in memory only!)
 * and abort processing.
 * Return 1 on success and 0 on error ("BAAD" magic will be present).
 * NOTE: We consider the absence / invalidity of an update sequence array to
 * mean that the structure is not protected at all and hence doesn't need to
 * be fixed up. Thus, we return success and not failure in this case.
 */
int post_read_mst_fixup(NTFS_RECORD_HEADER *b, const __u32 size);

/**
 * pre_write_mst_fixup - apply multi sector transfer protection
 * @b:		pointer to the data to protect
 * @size:	size in bytes of @b
 * 
 * Perform the necessary pre write multi sector transfer fixup on the data
 * pointer to by @b of @size.
 * Return 1 if fixup applied (success) or 0 if no fixup was performed
 * (assumed not needed).
 * NOTE: We consider the absence / invalidity of an update sequence array to
 * mean that the structure is not subject to protection and hence doesn't need
 * to be fixed up. This means that you have to create a valid update sequence
 * array header in the ntfs record before calling this function, otherwise it
 * will fail and return 0 (the header needs to contain the position of the
 * update seqeuence array together with the number of elements in the array).
 * You also need to initialise the update sequence number before calling this
 * function otherwise a random word will be used (whatever was in the record
 * at that position at that time).
 */
int pre_write_mst_fixup(NTFS_RECORD_HEADER *b, const __u32 size);

#endif /* defined NTFS_REC_H */


--- NEW FILE ---
/*
 * volume.h - Exports for NTFS volume handling. Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef VOLUME_H
#define VOLUME_H

#include "attrib.h"

/*
 * FIXME: We should have a volume lock at some point (possibly a spinlock?) for
 * the volume structure also a lock for major modifications, much like the big
 * kernel lock. These two locks could be one and the same. Later on, we in
 * addition, will need finer grained locks to lock individual structures and
 * structure elements like the lcn_bitmap, mft_bitmap, etc. These locks will
 * need to protect operations like changing a directory, a mft record, etc.
 */
/*
 * FIXME: Do we really want to return a pointer to the actual volume structure
 * to the user to play with? It would be better to completely abstract the
 * structure and provide functions for accessing the public members instead.
 * In that case we would return a volume descriptor to the caller.
 *
 * DECISION: Return the actual structure. In the second release, once
 * everything is working, we still have the option of abstracting the volume
 * strcture data type.
 */
/*
 * FIXME: For RAID stuff will need the fd and dev_name variables to be arrays
 * or lists or something... Also will need to know the number of sectors (and
 * sector size if not 512) of each device making up the RAID array. Obviously,
 * will need RAID information as well like which RAID is used together with
 * state information, etc. But that is the far future.
 */

/* The ntfs volume structure describing an open volume. */
typedef struct {
	int fd;			/* File descriptor associated with volume. */
	char *dev_name;		/* Name of the device the volume is on. */
	char *vol_name;		/* Name of the volume from the volume name
				   attribute. */
	/* Version nos. and flags are from the volume information attribute. */
        __u8 major_ver;		/* Ntfs major version of volume. */
        __u8 minor_ver;		/* Ntfs minor version of volume. */
        __u16 flags;		/* Bit array of VOLUME_* flags. */
	__s64 number_of_clusters;/* Volume size in clusters, hence also the
				    number of bits in lcn_bitmap. */
	__u32 cluster_size;	/* Byte size of a cluster. */
	__u32 mft_record_size;	/* Byte size of a mft record. */
	__s64 mft_lcn;		/* Logical cluster number of the data attribute
				   for FILE_$Mft. */
       	__s64 mft_mirr_lcn;	/* Logical cluster number of the data attribute
				   for FILE_$MftMirr. */
	__u8 cluster_size_bits;	/* Log(2) of the byte size of a cluster. */
	__u8 mft_record_size_bits;/* Log(2) of the byte size of a mft record. */
	__u8 *lcn_bitmap;	/* Value of data attribute of FILE_$Bitmap. Each
				   bit represents a cluster on the volume, bit 0
				   representing lcn 0 and so on. A set bit means
				   that the cluster is in use and a zero bit
				   means the cluster is free. */
	__u8 *mft_bitmap;	/* Value of bitmap attribute of FILE_$Mft. Has
				   same interpretation as the lcn_bitmap above
				   but except that it keeps track of the usage
				   of the mft recoreds rather than the lcns. */
	run_list mft_runlist;	/* Decompressed run list of the data attribute
				   of FILE_$Mft. */
	__s64 number_of_mft_records;	/* Number of records in the mft, equals
					   the number of bits in mft_bitmap. */
	__u16 *up_case[65536];		/* Upper case equivalents of all 65536 
					   2-byte Unicode characters. Obtained
					   from FILE_$UpCase. */
	__u8 mft_records_per_cluster;	/* The number of mft records that fit
					   into one cluster or 0 if clusters
					   are smaller than mft records. */
	__u8 clusters_per_mft_record;	/* The size of a mft record in clusters
					   or 0 if a mft record is smaller than
					   a cluster. */
	
} ntfs_volume;

/**
 * ntfs_open - open ntfs volume
 * @dev_name: name of device to open
 *
 * This function opens an ntfs volume. @dev_name should contain the name
 * of the device to open as the ntfs volume.
 * 
 * The function opens the device @dev_name and verifies that it contains a
 * valid bootsector. Then, it allocates a ntfs_volume structure and initializes
 * some of the values inside the structure from the information stored in the
 * bootsector. It proceeds to load the necessary system files and completes
 * setting up the structure. 
 *
 * ntfs_open() returns a pointer to the allocated ntfs_volume structure.
 * On error, the return value is NULL and errno is set appropriately.
 *
 * Note, that a copy is made of @dev_name, and hence it can be discarded as
 * soon as the function returns.
 *
 * FIXME: Should document all error codes that can be returned and what each
 * means.
 */
ntfs_volume *ntfs_open(char *dev_name);

/**
 * ntfs_close - close ntfs volume
 * @vol: address of ntfs_volume structure of volume to close
 * @force: if true force close the volume even if it is busy
 * 
 * Flush buffers, close all files and deallocate all structures (including @vol
 * itself) associated with the ntfs volume @vol.
 *
 * Return 1 on success. On error return zero with errno set appropriately (most
 * likely to one of -EAGAIN, -EBUSY or -EINVAL). The -EAGAIN error means that
 * an operation is in progress and if you try the close later the operation
 * might be completed and the close succeed.
 *  
 * If @force is true (i.e. not zero) this function will close the volume even
 * if this means that data might be lost. In this case the function always
 * returns 1.
 *
 * @vol must have previously been returned by a call to ntfs_open().
 *
 * @vol itself is deallocated and should no longer be referenced after this
 * function returns success. If it returns an error then nothing has been done
 * so it is safe to continue using @vol.
 *
 * FIXME: Should document all error codes that can be returned and what each
 * means.
 */
int ntfs_close(ntfs_volume *vol, int force);

#endif /* defined VOLUME_H */

[Linux-ntfs-cvs] CVS: linux-ntfs TODO.ntfsfix,NONE,1.1 TODO.include,NONE,1.1

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs
In directory usw-pr-cvs1:/tmp/cvs-serv19280

Added Files:
	TODO.ntfsfix TODO.include 
Log Message:
Checkin my current todo files.


--- NEW FILE ---
* NtfsFix:
*
* - Find out what NT will accept to have been done to the $LogFile:
*
* 1. Zeroing the contents of $Logfile renders the partition
*    unreadable by Windows.
*
* 2. Truncating $LogFile to zero size gives same result.
*
* 3. Zeroing the $Mft and $MftMirr records for $LogFile gives
*    same result. 
*
* 4. Now what?!? - Maybe we really need to have a valid $LogFile
*    which means that we need to know the $LogFile format and the
*    format for the records in the file. - Argh!
*
* - On ntfs 3.0+ volumes need to disable the usn journal if it is active.
*
* - On ntfs 3.0+ volumes need to mark the quota out of date?
*
*
*
*
*

--- NEW FILE ---
Finish attrib.h
Finish migration of the rest of the headers.
Import include/* into cvs.

[Linux-ntfs-cvs] CVS: linux-ntfs/doc template.c,NONE,1.1 template.h,NONE,1.1

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/doc
In directory usw-pr-cvs1:/tmp/cvs-serv7856

Added Files:
	template.c template.h 
Log Message:
Added my templates for new source and include files.


--- NEW FILE ---
const char *EXEC_NAME = "";
const char *EXEC_VERSION= "0.0.1";
/*
 * EXEC_NAME - Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * Short description here.
 *
 * 	Anton Altaparmakov <ai...@ca...>
 *
 * 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 (in the main directory of the Linux-NTFS distribution
 * in the file COPYING); if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 * WARNING: This program might not work on architectures which do not allow 
 * unaligned access. For those, the program would need to start using 
 * get/put_unaligned macros (#include <asm/unaligned.h>), but not doing it yet,
 * since NTFS really mostly applies to ia32 only, which does allow unaligned
 * accesses. We might not actually have a problem though, since the structs are 
 * defined as being packed so that might be enough for gcc to insert the 
 * correct code.
 *
 * If anyone using a non-little endian and/or an aligned access only CPU tries
 * this program please let me know whether it works or not!
 *
 * 	Anton Altaparmakov <ai...@ca...>
 */

int main(int argc, char **argv)
{
	return 0;
}


--- NEW FILE ---
/*
 * NAME.h - Description. Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000,2001 Anton Altaparmakov.
 *
 * This program/include file 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/include file 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 (in the main directory of the Linux-NTFS 
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef NAME_H
#define NAME_H

#endif /* defined NAME_H */

[Linux-ntfs-cvs] CVS: linux-ntfs/include - New directory

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv7346/include

Log Message:
Directory /cvsroot/linux-ntfs/linux-ntfs/include added to the repository