opengnsys
/
ntfs-3g
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

AT_NONAME -> AT_UNNAMED 

2002/07/14 17:24:58-00:00 !szaka
Remove obsolote/unused set_attribute_value()

2002/07/14 17:21:32-00:00 !szaka
Move ntfs_set_volume_flags() from attrib[ch] to volume.[ch]

2002/07/14 17:16:52-00:00 !szaka
Merge set_ntfs_volume_flags() and code from ntfsfix as a new library
function: ntfs_set_volume_flags(). Note, ntfs_set_volume_flags() is
moving to volume.[ch]

2002/07/11 16:20:32-00:00 !flatcap
whitespace and include guards

2002/07/11 13:18:11-00:00 !flatcap
start to break up the dependency loops in the header files

2002/07/09 19:17:48-00:00 !flatcap
move the runlist functions from attrib.c to runlist.c

2002/07/08 23:27:15-00:00 !flatcap
added AT_NONAME so we can search for a (un)named attribute or just
iterate through all attributes

2002/07/08 00:09:41-00:00 !antona
Implement attrib.[hc]::ntfs_rl_pwrite(). Fix a dumb bug in ntfs_attr_pwrite().

2002/07/06 20:07:59-00:00 !antona
New API for compressing run lists into mapping pairs arrays and adapt mkntfs to that API. Addition of ntfs_walk_attrs().

2002/07/02 23:47:10-00:00 !antona
Global replacement of __[su]{8,16,32,64} with [su]{8,16,32,64} and layout.h define it.

2002/06/30 12:52:25-00:00 !antona
Little something or other...

2002/06/05 20:32:53-00:00 !antona
Mft mirror now updated from ntfs_write_mft_record, yey! Fixup ntfstools accordingly.

2002/06/05 00:29:18-00:00 !antona
Make ntfs_attr_pread work with resident attributes and start on ntfs_attr_pwrite (incomplete!).

2002/06/01 00:41:45-00:00 !antona
huge update!

2002/04/29 12:58:34-00:00 !antona
Finish ntfs_attr_pread and ntfs_attr_mst_pread.

2002/04/27 19:49:09-00:00 !antona
Update library, new APIs ntfs_attr_find_vcn(), misc fixes and cleanups, make all the utilities compile, fix bugs I noticed in ntfslabel and it now works properly.

2002/04/24 23:47:42-00:00 !antona
Hammer out the API for run list merging. Add calls for low level (using raw run lists and ATTR_RECORDs as parameters) run list merging, mappaing pairs decompression, and vcn to lcn conversion as well as high level (using ntfs_attr as parameter) calls for run list mapping and vcn to lcn conversion.

2002/04/24 19:02:07-00:00 !antona
Add new API ntfs_attr_{get,put}.

2002/04/23 11:02:59-00:00 !antona
Initial proposal for ntfs attribute ntfs_attr structure typedef.

2002/04/22 10:34:31-00:00 !antona
Attribute list support (merging done, part 2, some stuff still incomplete). mkntfs ntfs volume creation. See the changelog...

2002/04/20 23:09:42-00:00 !antona
Port attribute lookup functions with attribute list support from ntfs tng driver. Port/reimplement extent mft record handling code as well. Rename out all dollar signs from type names and constants. Adapt all callers to new API. Note mkntfs is currently broken due to some needed work.

2002/04/19 21:09:54-00:00 !antona
Finished provisional inode.c::ntfs_{open,close}_inode() functions. Also, started defining API provided by attrib.[ch], so far only done search context related stuff.

2002/04/15 17:51:26-00:00 !antona
read/write_mft_record(s) are here

2002/04/14 13:56:45-00:00 !antona
cleanup header files.

2001/12/15 05:13:08-00:00 !antona
Remove atomic ops and add compiler version check.

2001/06/01 02:07:24-00:00 !antona
It has been a long time since last commit. At moment have done a lot of work
on mkntfs but also at the moment ntfsfix and ntfsdump_logfile and libntfs are
broken. Basically only mkntfs works and that is not complete either.

2001/04/11 11:49:16-00:00 !antona

Header file reorganisation so that it compiles.

2001/04/08 01:58:29-00:00 !antona
User space conversion of locking complete. I settled for using simple spinlocks
and atomic variables and instead of deadlocking/livelocking when using
spin_lock(), use spin_trylock() in a while letting go of the cpu between each
call and making a maximum of 100 iterations (or we return EDEADLK error code).

This is not the most efficient way, especially as can't have multiple readers
but it is the simplest way to go about things.

Should now have (almost) all required helper functions for dealing with mft
entries implemented.

Now need the file handling and then convert the whole project to use the new
code and then can finally get back to work on attribute searching...

2001/04/05 20:14:45-00:00 !antona
Commit of current state of development including locking a la kernel.
This doesn't work on user space (semaphores don't work).
Just want to have it committed. Will take out locking / modify it where
necessary to use pthreads ASAP.

2001/04/02 22:28:39-00:00 !antona
Added cvs Id header and removed some outofdate stuff.

2001/04/02 02:04:37-00:00 !antona
Everything compiles again! Yey! (Don't know about working though, haven't tried
it... So be careful...)
The definitely final find_{first_}attr() functions are in place. Currently
still no support for attribute lists.
The two new _RE files contain the C-fied and more or less (more less than more
actually) cleaned up functions from the ntfs driver. Once they are cleaned
up (find_attr() is already completed but I left it in the _RE files for future
reference/educational value) and modified to suit my ideas of how they should
work, which are not quite the same as the driver way, they will make it into
attrib.[ch].
If anyone gives the new code a try, I would be interested in whether it worked
or not... (-;

2001/03/31 15:25:19-00:00 !antona
Added a name comparison function.

2001/03/26 14:50:58-00:00 !antona
Fix a few typos.

2001/03/26 03:35:35-00:00 !antona
New attribute searching API header part complete.
This shouldn't change any more, except for the search context structure,
which might be simplified at some point.

2001/03/22 13:16:32-00:00 !antona
Clarified the reparse point tag flags.

2001/03/15 23:12:45-00:00 !antona
About time to do a new commit...

2001/03/05 03:15:08-00:00 !antona
Forgot a few...

2001/03/05 02:45:35-00:00 !antona
Renamed things, broke everything. Should be stabilized now in the headers.
Still reworking find attribute stuff but at least I have an idea of how I want
to do it now.

2001/03/04 14:28:13-00:00 !antona
Fixes.

2001/03/03 06:52:39-00:00 !antona
Finished entering security related headers.

2001/03/03 00:11:17-00:00 !antona
Mostly finished adding the $Secure information.

2001/03/02 15:03:56-00:00 !antona
Update to latest include files.

2001/02/03 02:03:35-00:00 !antona
More files.

2001/01/30 12:55:21-00:00 !antona
Fixed the compilation issues.

2001/01/30 12:29:03-00:00 !antona
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.)

2001/01/30 00:13:11-00:00 !antona
Added in the current state of attribute handling to libntfs.
Now just missing the make files to make a first public release of ntfsfix!

2001/01/28 05:49:57-00:00 !antona
More header development. AttrDef description.

2001/01/27 14:22:02-00:00 !antona
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 <yuri@acronis.com> for pointing this out.)

2001/01/26 02:36:10-00:00 !antona
More work on attrib.h.

2001/01/24 02:13:24-00:00 !antona
Add a bunch of headers (attrib.h is work in progress).

(Logical change 1.5)
edge.strict_endians
!flatcap 2002-08-22 18:09:47 +00:00
parent b47fe4d7ad
commit b30305bf01
1 changed files with 299 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

299
include/attrib.h
View File

@ -0,0 +1,299 @@
/*
* $Id$
*
* attrib.h - Exports for attribute handling. Part of the Linux-NTFS project.
*
* Copyright (c) 2000-2002 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_ATTRIB_H
#define _NTFS_ATTRIB_H
/* Forward declarations */
typedef struct _ntfs_attr ntfs_attr;
typedef struct _ntfs_attr_search_ctx ntfs_attr_search_ctx;
#include "types.h"
#include "unistr.h"
#include "runlist.h"
#include "volume.h"
extern uchar_t AT_UNNAMED[];
/**
* ntfs_lcn_special_values - special return values for ntfs_*_vcn_to_lcn()
*
* Special return values for ntfs_rl_vcn_to_lcn() and ntfs_attr_vcn_to_lcn().
*
* TODO: Describe them.
*/
typedef enum {
LCN_HOLE = -1, /* Keep this as highest value or die! */
LCN_RL_NOT_MAPPED = -2,
LCN_ENOENT = -3,
LCN_EINVAL = -4,
LCN_EIO = -5,
} ntfs_lcn_special_values;
/**
* ntfs_attr_search_ctx - search context used in attribute search functions
* @mrec: buffer containing mft record to search
* @attr: attribute record in @mrec where to begin/continue search
* @is_first: if true lookup_attr() begins search with @attr, else after @attr
*
* Structure must be initialized to zero before the first call to one of the
* attribute search functions. Initialize @mrec to point to the mft record to
* search, and @attr to point to the first attribute within @mrec (not necessary
* if calling the _first() functions), and set @is_first to TRUE (not necessary
* if calling the _first() functions).
*
* If @is_first is TRUE, the search begins with @attr. If @is_first is FALSE,
* the search begins after @attr. This is so that, after the first call to one
* of the search attribute functions, we can call the function again, without
* any modification of the search context, to automagically get the next
* matching attribute.
*/
struct _ntfs_attr_search_ctx {
MFT_RECORD *mrec;
ATTR_RECORD *attr;
BOOL is_first;
ntfs_inode *ntfs_ino;
ATTR_LIST_ENTRY *al_entry;
ntfs_inode *base_ntfs_ino;
MFT_RECORD *base_mrec;
ATTR_RECORD *base_attr;
};
extern void ntfs_reinit_attr_search_ctx(ntfs_attr_search_ctx *ctx);
extern ntfs_attr_search_ctx *ntfs_get_attr_search_ctx(ntfs_inode *ni,
MFT_RECORD *mrec);
extern void ntfs_put_attr_search_ctx(ntfs_attr_search_ctx *ctx);
extern int ntfs_lookup_attr(const ATTR_TYPES type, const uchar_t *name,
const u32 name_len, const IGNORE_CASE_BOOL ic,
const VCN lowest_vcn, const u8 *val, const u32 val_len,
ntfs_attr_search_ctx *ctx);
/**
* ntfs_walk_attrs - syntactic sugar for walking all attributes in an inode
* @ctx: initialised attribute search context
*
* Syntactic sugar for walking attributes in an inode.
*
* Return 0 on success and -1 on error with errno set to the error code from
* ntfs_lookup_attr().
*
* Example: When you want to enumerate all attributes in an open ntfs inode
* @ni, you can simply do:
*
* int err;
* ntfs_attr_search_ctx *ctx = ntfs_get_attr_search_ctx(ni, NULL);
* if (!ctx)
* // Error code is in errno. Handle this case.
* while (!(err = ntfs_walk_attrs(ctx))) {
* ATTR_RECORD *attr = ctx->attr;
* // attr now contains the next attribute. Do whatever you want
* // with it and then just continue with the while loop.
* }
* if (err && errno != ENOENT)
* // Ooops. An error occured! You should handle this case.
* // Now finished with all attributes in the inode.
*/
static __inline__ int ntfs_walk_attrs(ntfs_attr_search_ctx *ctx)
{
return ntfs_lookup_attr(0, NULL, 0, 0, 0, NULL, 0, ctx);
}
/**
* ntfs_attr_state_bits - bits for the state field in the ntfs_attr structure
*/
typedef enum {
NA_Initialized, /* 1: structure is initialized. */
NA_NonResident, /* 1: Attribute is not resident. */
NA_Compressed, /* 1: Attribute is compressed. */
NA_Encrypted, /* 1: Attribute is encrypted. */
NA_Sparse, /* 1: Attribute is sparse. */
} ntfs_attr_state_bits;
#define test_nattr_flag(na, flag) test_bit(NA_##flag, (na)->state)
#define set_nattr_flag(na, flag) set_bit(NA_##flag, (na)->state)
#define clear_nattr_flag(na, flag) clear_bit(NA_##flag, (na)->state)
#define NAttrInitialized(na) test_nattr_flag(na, Initialized)
#define NAttrSetInitialized(na) set_nattr_flag(na, Initialized)
#define NAttrClearInitialized(na) clear_nattr_flag(na, Initialized)
#define NAttrNonResident(na) test_nattr_flag(na, NonResident)
#define NAttrSetNonResident(na) set_nattr_flag(na, NonResident)
#define NAttrClearNonResident(na) clear_nattr_flag(na, NonResident)
#define NAttrCompressed(na) test_nattr_flag(na, Compressed)
#define NAttrSetCompressed(na) set_nattr_flag(na, Compressed)
#define NAttrClearCompressed(na) clear_nattr_flag(na, Compressed)
#define NAttrEncrypted(na) test_nattr_flag(na, Encrypted)
#define NAttrSetEncrypted(na) set_nattr_flag(na, Encrypted)
#define NAttrClearEncrypted(na) clear_nattr_flag(na, Encrypted)
#define NAttrSparse(na) test_nattr_flag(na, Sparse)
#define NAttrSetSparse(na) set_nattr_flag(na, Sparse)
#define NAttrClearSparse(na) clear_nattr_flag(na, Sparse)
/**
* ntfs_attr - ntfs in memory non-resident attribute structure
* @rl: if not NULL, the decompressed run list
* @ni: base ntfs inode to which this attribute belongs
* @type: attribute type
* @name: Unicode name of the attribute
* @name_len: length of @name in Unicode characters
* @state: NTFS attribute specific flags descibing this attribute
*
* This structure exists purely to provide a mechanism of caching the run list
* of an attribute. If you want to operate on a particular attribute extent,
* you should not be using this structure at all. If you want to work with a
* resident attribute, you should not be using this structure at all. As a
* fail-safe check make sure to test NAttrNonResident() and if it is false, you
* know you shouldn't be using this structure.
*
* If you want to work on a resident attribute or on a specific attribute
* extent, you should use ntfs_lookup_attr() to retrieve the attribute (extent)
* record, edit that, and then write back the mft record (or set the
* corresponding ntfs inode dirty for delayed write back).
*
* @rl is the decompressed run list of the attribute described by this
* structure. Obviously this only makes sense if the attribute is not resident,
* i.e. NAttrNonResident() is true. If the run list hasn't been decomressed yet
* @rl is NULL, so be prepared to cope with @rl == NULL.
*
* @ni is the base ntfs inode of the attribute described by this structure.
*
* @type is the attribute type (see layout.h for the definition of ATTR_TYPES),
* @name and @name_len are the little endian Unicode name and the name length
* in Unicode characters of the attribute, respecitvely.
*
* @state contains NTFS attribute specific flags descibing this attribute
* structure. See ntfs_attr_state_bits above.
*/
struct _ntfs_attr {
run_list_element *rl;
ntfs_inode *ni;
ATTR_TYPES type;
uchar_t *name;
u32 name_len;
unsigned long state;
s64 allocated_size;
s64 data_size;
s64 initialized_size;
s64 compressed_size;
u32 compression_block_size;
u8 compression_block_size_bits;
u8 compression_block_clusters;
};
/*
* Union of all known attribute values. For convenience. Used in the attr
* structure.
*/
typedef union {
u8; /* Unnamed u8 to serve as default when just using
a_val without specifying any of the below. */
STANDARD_INFORMATION std_inf;
ATTR_LIST_ENTRY al_entry;
FILE_NAME_ATTR filename;
OBJECT_ID_ATTR obj_id;
SECURITY_DESCRIPTOR_ATTR sec_desc;
VOLUME_NAME vol_name;
VOLUME_INFORMATION vol_inf;
DATA_ATTR data;
INDEX_ROOT index_root;
INDEX_BLOCK index_blk;
BITMAP_ATTR bmp;
REPARSE_POINT reparse;
EA_INFORMATION ea_inf;
EA_ATTR ea;
PROPERTY_SET property_set;
LOGGED_UTILITY_STREAM logged_util_stream;
EFS_ATTR efs;
} attr_val;
extern void ntfs_attr_init(ntfs_attr *na, const BOOL non_resident,
const BOOL compressed, const BOOL encrypted, const BOOL sparse,
const s64 allocated_size, const s64 data_size,
const s64 initialized_size, const s64 compressed_size,
const u8 compression_unit);
extern ntfs_attr *ntfs_attr_open(ntfs_inode *ni, const ATTR_TYPES type,
uchar_t *name, const u32 name_len);
extern void ntfs_attr_close(ntfs_attr *na);
extern s64 ntfs_attr_pread(ntfs_attr *na, const s64 pos, s64 count,
void *b);
extern s64 ntfs_attr_pwrite(ntfs_attr *na, const s64 pos, s64 count,
void *b);
extern s64 ntfs_attr_mst_pread(ntfs_attr *na, const s64 pos,
const s64 bk_cnt, const u32 bk_size, void *dst);
extern s64 ntfs_attr_mst_pwrite(ntfs_attr *na, const s64 pos,
s64 bk_cnt, const u32 bk_size, void *src);
extern int ntfs_attr_map_run_list(ntfs_attr *na, VCN vcn);
extern LCN ntfs_attr_vcn_to_lcn(ntfs_attr *na, const VCN vcn);
extern run_list_element *ntfs_attr_find_vcn(ntfs_attr *na, const VCN vcn);
extern int ntfs_get_nr_significant_bytes(const s64 n);
extern int ntfs_get_size_for_mapping_pairs(const ntfs_volume *vol,
const run_list_element *rl);
extern int ntfs_write_significant_bytes(s8 *dst, const s8 *dst_max,
const s64 n);
// FIXME / TODO: Above here the file is cleaned up. (AIA)
/**
* 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.
*/
s64 get_attribute_value_length(const ATTR_RECORD *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.
*/
s64 get_attribute_value(const ntfs_volume *vol, const MFT_RECORD *m,
const ATTR_RECORD *a, u8 *b);
#endif /* defined _NTFS_ATTRIB_H */