Attachment 194532 Details for Bug 354113

preprocessed source of libntfs-3g/attrib.c (as asked for)

attrib.i (text/plain), 196.86 KB, created by Bernhard Kaindl on 2008-02-12 19:30:56 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Bernhard Kaindl

Created: 2008-02-12 19:30:56 UTC

Size: 196.86 KB

patch

obsolete

># 1 "attrib.c"
># 1 "<built-in>"
># 1 "<command-line>"
># 1 "attrib.c"
># 26 "attrib.c"
># 1 "../config.h" 1
># 27 "attrib.c" 2
>
>
>
># 1 "/usr/include/stdio.h" 1 3 4
># 28 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/features.h" 1 3 4
># 330 "/usr/include/features.h" 3 4
># 1 "/usr/include/sys/cdefs.h" 1 3 4
># 348 "/usr/include/sys/cdefs.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 349 "/usr/include/sys/cdefs.h" 2 3 4
># 331 "/usr/include/features.h" 2 3 4
># 354 "/usr/include/features.h" 3 4
># 1 "/usr/include/gnu/stubs.h" 1 3 4
>
>
>
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 5 "/usr/include/gnu/stubs.h" 2 3 4
>
>
>
>
># 1 "/usr/include/gnu/stubs-64.h" 1 3 4
># 10 "/usr/include/gnu/stubs.h" 2 3 4
># 355 "/usr/include/features.h" 2 3 4
># 29 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>
># 1 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include/stddef.h" 1 3 4
># 214 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include/stddef.h" 3 4
>typedef long unsigned int size_t;
># 35 "/usr/include/stdio.h" 2 3 4
>
># 1 "/usr/include/bits/types.h" 1 3 4
># 28 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned char __u_char;
>typedef unsigned short int __u_short;
>typedef unsigned int __u_int;
>typedef unsigned long int __u_long;
>
>
>typedef signed char __int8_t;
>typedef unsigned char __uint8_t;
>typedef signed short int __int16_t;
>typedef unsigned short int __uint16_t;
>typedef signed int __int32_t;
>typedef unsigned int __uint32_t;
>
>typedef signed long int __int64_t;
>typedef unsigned long int __uint64_t;
>
>
>
>
>
>
>
>typedef long int __quad_t;
>typedef unsigned long int __u_quad_t;
># 131 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/typesizes.h" 1 3 4
># 132 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned long int __dev_t;
>typedef unsigned int __uid_t;
>typedef unsigned int __gid_t;
>typedef unsigned long int __ino_t;
>typedef unsigned long int __ino64_t;
>typedef unsigned int __mode_t;
>typedef unsigned long int __nlink_t;
>typedef long int __off_t;
>typedef long int __off64_t;
>typedef int __pid_t;
>typedef struct { int __val[2]; } __fsid_t;
>typedef long int __clock_t;
>typedef unsigned long int __rlim_t;
>typedef unsigned long int __rlim64_t;
>typedef unsigned int __id_t;
>typedef long int __time_t;
>typedef unsigned int __useconds_t;
>typedef long int __suseconds_t;
>
>typedef int __daddr_t;
>typedef long int __swblk_t;
>typedef int __key_t;
>
>
>typedef int __clockid_t;
>
>
>typedef void * __timer_t;
>
>
>typedef long int __blksize_t;
>
>
>
>
>typedef long int __blkcnt_t;
>typedef long int __blkcnt64_t;
>
>
>typedef unsigned long int __fsblkcnt_t;
>typedef unsigned long int __fsblkcnt64_t;
>
>
>typedef unsigned long int __fsfilcnt_t;
>typedef unsigned long int __fsfilcnt64_t;
>
>typedef long int __ssize_t;
>
>
>
>typedef __off64_t __loff_t;
>typedef __quad_t *__qaddr_t;
>typedef char *__caddr_t;
>
>
>typedef long int __intptr_t;
>
>
>typedef unsigned int __socklen_t;
># 37 "/usr/include/stdio.h" 2 3 4
># 45 "/usr/include/stdio.h" 3 4
>struct _IO_FILE;
>
>
>
>typedef struct _IO_FILE FILE;
>
>
>
>
>
># 65 "/usr/include/stdio.h" 3 4
>typedef struct _IO_FILE __FILE;
># 75 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/libio.h" 1 3 4
># 32 "/usr/include/libio.h" 3 4
># 1 "/usr/include/_G_config.h" 1 3 4
># 15 "/usr/include/_G_config.h" 3 4
># 1 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include/stddef.h" 1 3 4
># 16 "/usr/include/_G_config.h" 2 3 4
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 78 "/usr/include/wchar.h" 3 4
>typedef struct
>{
>  int __count;
>  union
>  {
>
>    unsigned int __wch;
>
>
>
>    char __wchb[4];
>  } __value;
>} __mbstate_t;
># 21 "/usr/include/_G_config.h" 2 3 4
>
>typedef struct
>{
>  __off_t __pos;
>  __mbstate_t __state;
>} _G_fpos_t;
>typedef struct
>{
>  __off64_t __pos;
>  __mbstate_t __state;
>} _G_fpos64_t;
># 53 "/usr/include/_G_config.h" 3 4
>typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
># 33 "/usr/include/libio.h" 2 3 4
># 53 "/usr/include/libio.h" 3 4
># 1 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include/stdarg.h" 1 3 4
># 43 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 54 "/usr/include/libio.h" 2 3 4
># 170 "/usr/include/libio.h" 3 4
>struct _IO_jump_t; struct _IO_FILE;
># 180 "/usr/include/libio.h" 3 4
>typedef void _IO_lock_t;
>
>
>
>
>
>struct _IO_marker {
>  struct _IO_marker *_next;
>  struct _IO_FILE *_sbuf;
>
>
>
>  int _pos;
># 203 "/usr/include/libio.h" 3 4
>};
>
>
>enum __codecvt_result
>{
>  __codecvt_ok,
>  __codecvt_partial,
>  __codecvt_error,
>  __codecvt_noconv
>};
># 271 "/usr/include/libio.h" 3 4
>struct _IO_FILE {
>  int _flags;
>
>
>
>
>  char* _IO_read_ptr;
>  char* _IO_read_end;
>  char* _IO_read_base;
>  char* _IO_write_base;
>  char* _IO_write_ptr;
>  char* _IO_write_end;
>  char* _IO_buf_base;
>  char* _IO_buf_end;
>
>  char *_IO_save_base;
>  char *_IO_backup_base;
>  char *_IO_save_end;
>
>  struct _IO_marker *_markers;
>
>  struct _IO_FILE *_chain;
>
>  int _fileno;
>
>
>
>  int _flags2;
>
>  __off_t _old_offset;
>
>
>
>  unsigned short _cur_column;
>  signed char _vtable_offset;
>  char _shortbuf[1];
>
>
>
>  _IO_lock_t *_lock;
># 319 "/usr/include/libio.h" 3 4
>  __off64_t _offset;
># 328 "/usr/include/libio.h" 3 4
>  void *__pad1;
>  void *__pad2;
>  void *__pad3;
>  void *__pad4;
>  size_t __pad5;
>
>  int _mode;
>
>  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
>
>};
>
>
>typedef struct _IO_FILE _IO_FILE;
>
>
>struct _IO_FILE_plus;
>
>extern struct _IO_FILE_plus _IO_2_1_stdin_;
>extern struct _IO_FILE_plus _IO_2_1_stdout_;
>extern struct _IO_FILE_plus _IO_2_1_stderr_;
># 364 "/usr/include/libio.h" 3 4
>typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
>
>
>
>
>
>
>
>typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
>     size_t __n);
>
>
>
>
>
>
>
>typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
>
>
>typedef int __io_close_fn (void *__cookie);
>
>
>
>
>typedef __io_read_fn cookie_read_function_t;
>typedef __io_write_fn cookie_write_function_t;
>typedef __io_seek_fn cookie_seek_function_t;
>typedef __io_close_fn cookie_close_function_t;
>
>
>typedef struct
>{
>  __io_read_fn *read;
>  __io_write_fn *write;
>  __io_seek_fn *seek;
>  __io_close_fn *close;
>} _IO_cookie_io_functions_t;
>typedef _IO_cookie_io_functions_t cookie_io_functions_t;
>
>struct _IO_cookie_file;
>
>
>extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
>        void *__cookie, _IO_cookie_io_functions_t __fns);
>
>
>
>
>
>
>
>extern int __underflow (_IO_FILE *);
>extern int __uflow (_IO_FILE *);
>extern int __overflow (_IO_FILE *, int);
># 458 "/usr/include/libio.h" 3 4
>extern int _IO_getc (_IO_FILE *__fp);
>extern int _IO_putc (int __c, _IO_FILE *__fp);
>extern int _IO_feof (_IO_FILE *__fp) __attribute__ ((__nothrow__));
>extern int _IO_ferror (_IO_FILE *__fp) __attribute__ ((__nothrow__));
>
>extern int _IO_peekc_locked (_IO_FILE *__fp);
>
>
>
>
>
>extern void _IO_flockfile (_IO_FILE *) __attribute__ ((__nothrow__));
>extern void _IO_funlockfile (_IO_FILE *) __attribute__ ((__nothrow__));
>extern int _IO_ftrylockfile (_IO_FILE *) __attribute__ ((__nothrow__));
># 488 "/usr/include/libio.h" 3 4
>extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
>   __gnuc_va_list, int *__restrict);
>extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
>    __gnuc_va_list);
>extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
>extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
>
>extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
>extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
>
>extern void _IO_free_backup_area (_IO_FILE *) __attribute__ ((__nothrow__));
># 76 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>typedef __gnuc_va_list va_list;
># 89 "/usr/include/stdio.h" 3 4
>
>
>typedef _G_fpos_t fpos_t;
>
>
>
>
>
>typedef _G_fpos64_t fpos64_t;
># 141 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 142 "/usr/include/stdio.h" 2 3 4
>
>
>
>extern struct _IO_FILE *stdin;
>extern struct _IO_FILE *stdout;
>extern struct _IO_FILE *stderr;
>
>
>
>
>
>
>
>
>
>extern int remove (__const char *__filename) __attribute__ ((__nothrow__));
>
>extern int rename (__const char *__old, __const char *__new) __attribute__ ((__nothrow__));
>
>
>
>
>extern int renameat (int __oldfd, __const char *__old, int __newfd,
>       __const char *__new) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern FILE *tmpfile (void) ;
># 184 "/usr/include/stdio.h" 3 4
>extern FILE *tmpfile64 (void) ;
>
>
>
>extern char *tmpnam (char *__s) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__)) ;
># 206 "/usr/include/stdio.h" 3 4
>extern char *tempnam (__const char *__dir, __const char *__pfx)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) ;
>
>
>
>
>
>
>
>
>extern int fclose (FILE *__stream);
>
>
>
>
>extern int fflush (FILE *__stream);
>
># 231 "/usr/include/stdio.h" 3 4
>extern int fflush_unlocked (FILE *__stream);
># 241 "/usr/include/stdio.h" 3 4
>extern int fcloseall (void);
>
>
>
>
>
>
>
>
>
>extern FILE *fopen (__const char *__restrict __filename,
>      __const char *__restrict __modes) ;
>
>
>
>
>extern FILE *freopen (__const char *__restrict __filename,
>        __const char *__restrict __modes,
>        FILE *__restrict __stream) ;
># 274 "/usr/include/stdio.h" 3 4
>
>
>extern FILE *fopen64 (__const char *__restrict __filename,
>        __const char *__restrict __modes) ;
>extern FILE *freopen64 (__const char *__restrict __filename,
>   __const char *__restrict __modes,
>   FILE *__restrict __stream) ;
>
>
>
>
>extern FILE *fdopen (int __fd, __const char *__modes) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>extern FILE *fopencookie (void *__restrict __magic_cookie,
>     __const char *__restrict __modes,
>     _IO_cookie_io_functions_t __io_funcs) __attribute__ ((__nothrow__)) ;
>
>
>extern FILE *fmemopen (void *__s, size_t __len, __const char *__modes)
>  __attribute__ ((__nothrow__)) ;
>
>
>
>
>extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>
>extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__));
>
>
>
>extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
>      int __modes, size_t __n) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
>         size_t __size) __attribute__ ((__nothrow__));
>
>
>extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern int fprintf (FILE *__restrict __stream,
>      __const char *__restrict __format, ...);
>
>
>
>
>extern int printf (__const char *__restrict __format, ...);
>
>extern int sprintf (char *__restrict __s,
>      __const char *__restrict __format, ...) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
>       __gnuc_va_list __arg);
>
>
>
>
>extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg);
>
>extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
>       __gnuc_va_list __arg) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int snprintf (char *__restrict __s, size_t __maxlen,
>       __const char *__restrict __format, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));
>
>extern int vsnprintf (char *__restrict __s, size_t __maxlen,
>        __const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));
>
>
>
>
>
>
>extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f,
>        __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 0))) ;
>extern int __asprintf (char **__restrict __ptr,
>         __const char *__restrict __fmt, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3))) ;
>extern int asprintf (char **__restrict __ptr,
>       __const char *__restrict __fmt, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3))) ;
>
>
>
>
>
>
>
>extern int vdprintf (int __fd, __const char *__restrict __fmt,
>       __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__printf__, 2, 0)));
>extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
>     __attribute__ ((__format__ (__printf__, 2, 3)));
>
>
>
>
>
>
>
>
>extern int fscanf (FILE *__restrict __stream,
>     __const char *__restrict __format, ...) ;
>
>
>
>
>extern int scanf (__const char *__restrict __format, ...) ;
>
>extern int sscanf (__const char *__restrict __s,
>     __const char *__restrict __format, ...) __attribute__ ((__nothrow__));
># 443 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>
>
>extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
>      __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
>
>
>
>
>
>extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
>
>
>extern int vsscanf (__const char *__restrict __s,
>      __const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__scanf__, 2, 0)));
># 502 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>
>
>
>extern int fgetc (FILE *__stream);
>extern int getc (FILE *__stream);
>
>
>
>
>
>extern int getchar (void);
>
># 530 "/usr/include/stdio.h" 3 4
>extern int getc_unlocked (FILE *__stream);
>extern int getchar_unlocked (void);
># 541 "/usr/include/stdio.h" 3 4
>extern int fgetc_unlocked (FILE *__stream);
>
>
>
>
>
>
>
>
>
>
>
>extern int fputc (int __c, FILE *__stream);
>extern int putc (int __c, FILE *__stream);
>
>
>
>
>
>extern int putchar (int __c);
>
># 574 "/usr/include/stdio.h" 3 4
>extern int fputc_unlocked (int __c, FILE *__stream);
>
>
>
>
>
>
>
>extern int putc_unlocked (int __c, FILE *__stream);
>extern int putchar_unlocked (int __c);
>
>
>
>
>
>
>extern int getw (FILE *__stream);
>
>
>extern int putw (int __w, FILE *__stream);
>
>
>
>
>
>
>
>
>extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
>     ;
>
>
>
>
>
>
>extern char *gets (char *__s) ;
>
># 620 "/usr/include/stdio.h" 3 4
>extern char *fgets_unlocked (char *__restrict __s, int __n,
>        FILE *__restrict __stream) ;
># 636 "/usr/include/stdio.h" 3 4
>extern __ssize_t __getdelim (char **__restrict __lineptr,
>          size_t *__restrict __n, int __delimiter,
>          FILE *__restrict __stream) ;
>extern __ssize_t getdelim (char **__restrict __lineptr,
>        size_t *__restrict __n, int __delimiter,
>        FILE *__restrict __stream) ;
>
>
>
>
>
>
>
>extern __ssize_t getline (char **__restrict __lineptr,
>       size_t *__restrict __n,
>       FILE *__restrict __stream) ;
>
>
>
>
>
>
>
>
>extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);
>
>
>
>
>
>extern int puts (__const char *__s);
>
>
>
>
>
>
>extern int ungetc (int __c, FILE *__stream);
>
>
>
>
>
>
>extern size_t fread (void *__restrict __ptr, size_t __size,
>       size_t __n, FILE *__restrict __stream) ;
>
>
>
>
>extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
>        size_t __n, FILE *__restrict __s) ;
>
># 697 "/usr/include/stdio.h" 3 4
>extern int fputs_unlocked (__const char *__restrict __s,
>      FILE *__restrict __stream);
># 708 "/usr/include/stdio.h" 3 4
>extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
>         size_t __n, FILE *__restrict __stream) ;
>extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
>          size_t __n, FILE *__restrict __stream) ;
>
>
>
>
>
>
>
>
>extern int fseek (FILE *__stream, long int __off, int __whence);
>
>
>
>
>extern long int ftell (FILE *__stream) ;
>
>
>
>
>extern void rewind (FILE *__stream);
>
># 744 "/usr/include/stdio.h" 3 4
>extern int fseeko (FILE *__stream, __off_t __off, int __whence);
>
>
>
>
>extern __off_t ftello (FILE *__stream) ;
># 763 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
>
>
>
>
>extern int fsetpos (FILE *__stream, __const fpos_t *__pos);
># 786 "/usr/include/stdio.h" 3 4
>
>
>
>extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
>extern __off64_t ftello64 (FILE *__stream) ;
>extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
>extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos);
>
>
>
>
>extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__));
>
>extern int feof (FILE *__stream) __attribute__ ((__nothrow__)) ;
>
>extern int ferror (FILE *__stream) __attribute__ ((__nothrow__)) ;
>
>
>
>
>extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__));
>extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__)) ;
>extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>
>
>
>extern void perror (__const char *__s);
>
>
>
>
>
>
># 1 "/usr/include/bits/sys_errlist.h" 1 3 4
># 27 "/usr/include/bits/sys_errlist.h" 3 4
>extern int sys_nerr;
>extern __const char *__const sys_errlist[];
>
>
>extern int _sys_nerr;
>extern __const char *__const _sys_errlist[];
># 825 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>extern int fileno (FILE *__stream) __attribute__ ((__nothrow__)) ;
>
>
>
>
>extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__)) ;
># 844 "/usr/include/stdio.h" 3 4
>extern FILE *popen (__const char *__command, __const char *__modes) ;
>
>
>
>
>
>extern int pclose (FILE *__stream);
>
>
>
>
>
>extern char *ctermid (char *__s) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern char *cuserid (char *__s);
>
>
>
>
>struct obstack;
>
>
>extern int obstack_printf (struct obstack *__restrict __obstack,
>      __const char *__restrict __format, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3)));
>extern int obstack_vprintf (struct obstack *__restrict __obstack,
>       __const char *__restrict __format,
>       __gnuc_va_list __args)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 0)));
>
>
>
>
>
>
>
>extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__));
>
>
>
>extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__)) ;
>
>
>extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__));
># 914 "/usr/include/stdio.h" 3 4
>
># 31 "attrib.c" 2
>
>
># 1 "/usr/include/string.h" 1 3 4
># 28 "/usr/include/string.h" 3 4
>
>
>
>
>
># 1 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include/stddef.h" 1 3 4
># 34 "/usr/include/string.h" 2 3 4
>
>
>
>
>extern void *memcpy (void *__restrict __dest,
>       __const void *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memmove (void *__dest, __const void *__src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
>        int __c, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern void *memset (void *__s, int __c, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memchr (__const void *__s, int __c, size_t __n)
>      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern void *rawmemchr (__const void *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern void *memrchr (__const void *__s, int __c, size_t __n)
>      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncpy (char *__restrict __dest,
>        __const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
>        size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcmp (__const char *__s1, __const char *__s2)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcoll (__const char *__s1, __const char *__s2)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern size_t strxfrm (char *__restrict __dest,
>         __const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
># 1 "/usr/include/xlocale.h" 1 3 4
># 28 "/usr/include/xlocale.h" 3 4
>typedef struct __locale_struct
>{
>
>  struct locale_data *__locales[13];
>
>
>  const unsigned short int *__ctype_b;
>  const int *__ctype_tolower;
>  const int *__ctype_toupper;
>
>
>  const char *__names[13];
>} *__locale_t;
># 119 "/usr/include/string.h" 2 3 4
>
>
>extern int strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>extern size_t strxfrm_l (char *__dest, __const char *__src, size_t __n,
>    __locale_t __l) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 4)));
>
>
>
>
>extern char *strdup (__const char *__s)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *strndup (__const char *__string, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
># 165 "/usr/include/string.h" 3 4
>
>
>extern char *strchr (__const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>extern char *strrchr (__const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern char *strchrnul (__const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern size_t strcspn (__const char *__s, __const char *__reject)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern size_t strspn (__const char *__s, __const char *__accept)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strpbrk (__const char *__s, __const char *__accept)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strstr (__const char *__haystack, __const char *__needle)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern char *__strtok_r (char *__restrict __s,
>    __const char *__restrict __delim,
>    char **__restrict __save_ptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
>
>extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
>         char **__restrict __save_ptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
>
>
>
>
>extern char *strcasestr (__const char *__haystack, __const char *__needle)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern void *memmem (__const void *__haystack, size_t __haystacklen,
>       __const void *__needle, size_t __needlelen)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern void *__mempcpy (void *__restrict __dest,
>   __const void *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern void *mempcpy (void *__restrict __dest,
>        __const void *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern size_t strlen (__const char *__s)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern size_t strnlen (__const char *__string, size_t __maxlen)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern char *strerror (int __errnum) __attribute__ ((__nothrow__));
>
># 281 "/usr/include/string.h" 3 4
>extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern char *strerror_l (int __errnum, __locale_t __l) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern void __bzero (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern void bcopy (__const void *__src, void *__dest, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void bzero (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *index (__const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern char *rindex (__const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int ffs (int __i) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>extern int ffsl (long int __l) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>__extension__ extern int ffsll (long long int __ll)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>extern int strcasecmp (__const char *__s1, __const char *__s2)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int strcasecmp_l (__const char *__s1, __const char *__s2,
>    __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>extern int strncasecmp_l (__const char *__s1, __const char *__s2,
>     size_t __n, __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
>
>
>
>
>
>extern char *strsep (char **__restrict __stringp,
>       __const char *__restrict __delim)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int strverscmp (__const char *__s1, __const char *__s2)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strsignal (int __sig) __attribute__ ((__nothrow__));
>
>
>extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern char *__stpncpy (char *__restrict __dest,
>   __const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpncpy (char *__restrict __dest,
>        __const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strfry (char *__string) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern void *memfrob (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *basename (__const char *__filename) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
># 432 "/usr/include/string.h" 3 4
>
># 34 "attrib.c" 2
>
>
># 1 "/usr/include/stdlib.h" 1 3 4
># 33 "/usr/include/stdlib.h" 3 4
># 1 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include/stddef.h" 1 3 4
># 326 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include/stddef.h" 3 4
>typedef int wchar_t;
># 34 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>
>
>
># 1 "/usr/include/bits/waitflags.h" 1 3 4
># 43 "/usr/include/stdlib.h" 2 3 4
># 1 "/usr/include/bits/waitstatus.h" 1 3 4
># 65 "/usr/include/bits/waitstatus.h" 3 4
># 1 "/usr/include/endian.h" 1 3 4
># 37 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/endian.h" 1 3 4
># 38 "/usr/include/endian.h" 2 3 4
># 66 "/usr/include/bits/waitstatus.h" 2 3 4
>
>union wait
>  {
>    int w_status;
>    struct
>      {
>
> unsigned int __w_termsig:7;
> unsigned int __w_coredump:1;
> unsigned int __w_retcode:8;
> unsigned int:16;
>
>
>
>
>
>
>
>      } __wait_terminated;
>    struct
>      {
>
> unsigned int __w_stopval:8;
> unsigned int __w_stopsig:8;
> unsigned int:16;
>
>
>
>
>
>
>      } __wait_stopped;
>  };
># 44 "/usr/include/stdlib.h" 2 3 4
># 68 "/usr/include/stdlib.h" 3 4
>typedef union
>  {
>    union wait *__uptr;
>    int *__iptr;
>  } __WAIT_STATUS __attribute__ ((__transparent_union__));
># 96 "/usr/include/stdlib.h" 3 4
>
>
>typedef struct
>  {
>    int quot;
>    int rem;
>  } div_t;
>
>
>
>typedef struct
>  {
>    long int quot;
>    long int rem;
>  } ldiv_t;
>
>
>
>
>
>
>
>__extension__ typedef struct
>  {
>    long long int quot;
>    long long int rem;
>  } lldiv_t;
>
>
># 140 "/usr/include/stdlib.h" 3 4
>extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__)) ;
>
>
>
>
>extern double atof (__const char *__nptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern int atoi (__const char *__nptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern long int atol (__const char *__nptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>__extension__ extern long long int atoll (__const char *__nptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern double strtod (__const char *__restrict __nptr,
>        char **__restrict __endptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern float strtof (__const char *__restrict __nptr,
>       char **__restrict __endptr) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern long double strtold (__const char *__restrict __nptr,
>       char **__restrict __endptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern long int strtol (__const char *__restrict __nptr,
>   char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern unsigned long int strtoul (__const char *__restrict __nptr,
>      char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>__extension__
>extern long long int strtoq (__const char *__restrict __nptr,
>        char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>__extension__
>extern unsigned long long int strtouq (__const char *__restrict __nptr,
>           char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>__extension__
>extern long long int strtoll (__const char *__restrict __nptr,
>         char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>__extension__
>extern unsigned long long int strtoull (__const char *__restrict __nptr,
>     char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
># 240 "/usr/include/stdlib.h" 3 4
>extern long int strtol_l (__const char *__restrict __nptr,
>     char **__restrict __endptr, int __base,
>     __locale_t __loc) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 4))) ;
>
>extern unsigned long int strtoul_l (__const char *__restrict __nptr,
>        char **__restrict __endptr,
>        int __base, __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 4))) ;
>
>__extension__
>extern long long int strtoll_l (__const char *__restrict __nptr,
>    char **__restrict __endptr, int __base,
>    __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 4))) ;
>
>__extension__
>extern unsigned long long int strtoull_l (__const char *__restrict __nptr,
>       char **__restrict __endptr,
>       int __base, __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 4))) ;
>
>extern double strtod_l (__const char *__restrict __nptr,
>   char **__restrict __endptr, __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3))) ;
>
>extern float strtof_l (__const char *__restrict __nptr,
>         char **__restrict __endptr, __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3))) ;
>
>extern long double strtold_l (__const char *__restrict __nptr,
>         char **__restrict __endptr,
>         __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3))) ;
># 311 "/usr/include/stdlib.h" 3 4
>extern char *l64a (long int __n) __attribute__ ((__nothrow__)) ;
>
>
>extern long int a64l (__const char *__s)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
># 1 "/usr/include/sys/types.h" 1 3 4
># 29 "/usr/include/sys/types.h" 3 4
>
>
>
>
>
>
>typedef __u_char u_char;
>typedef __u_short u_short;
>typedef __u_int u_int;
>typedef __u_long u_long;
>typedef __quad_t quad_t;
>typedef __u_quad_t u_quad_t;
>typedef __fsid_t fsid_t;
>
>
>
>
>typedef __loff_t loff_t;
>
>
>
>typedef __ino_t ino_t;
>
>
>
>
>
>
>typedef __ino64_t ino64_t;
>
>
>
>
>typedef __dev_t dev_t;
>
>
>
>
>typedef __gid_t gid_t;
>
>
>
>
>typedef __mode_t mode_t;
>
>
>
>
>typedef __nlink_t nlink_t;
>
>
>
>
>typedef __uid_t uid_t;
>
>
>
>
>
>typedef __off_t off_t;
>
>
>
>
>
>
>typedef __off64_t off64_t;
>
>
>
>
>typedef __pid_t pid_t;
>
>
>
>
>typedef __id_t id_t;
>
>
>
>
>typedef __ssize_t ssize_t;
>
>
>
>
>
>typedef __daddr_t daddr_t;
>typedef __caddr_t caddr_t;
>
>
>
>
>
>typedef __key_t key_t;
># 133 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 59 "/usr/include/time.h" 3 4
>
>
>typedef __clock_t clock_t;
>
>
>
># 75 "/usr/include/time.h" 3 4
>
>
>typedef __time_t time_t;
>
>
>
># 93 "/usr/include/time.h" 3 4
>typedef __clockid_t clockid_t;
># 105 "/usr/include/time.h" 3 4
>typedef __timer_t timer_t;
># 134 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef __useconds_t useconds_t;
>
>
>
>typedef __suseconds_t suseconds_t;
>
>
>
>
>
># 1 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include/stddef.h" 1 3 4
># 148 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef unsigned long int ulong;
>typedef unsigned short int ushort;
>typedef unsigned int uint;
># 195 "/usr/include/sys/types.h" 3 4
>typedef int int8_t __attribute__ ((__mode__ (__QI__)));
>typedef int int16_t __attribute__ ((__mode__ (__HI__)));
>typedef int int32_t __attribute__ ((__mode__ (__SI__)));
>typedef int int64_t __attribute__ ((__mode__ (__DI__)));
>
>
>typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
>typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
>
>typedef int register_t __attribute__ ((__mode__ (__word__)));
># 220 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/sys/select.h" 1 3 4
># 31 "/usr/include/sys/select.h" 3 4
># 1 "/usr/include/bits/select.h" 1 3 4
># 32 "/usr/include/sys/select.h" 2 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 24 "/usr/include/bits/sigset.h" 3 4
>typedef int __sig_atomic_t;
>
>
>
>
>typedef struct
>  {
>    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
>  } __sigset_t;
># 35 "/usr/include/sys/select.h" 2 3 4
>
>
>
>typedef __sigset_t sigset_t;
>
>
>
>
>
># 1 "/usr/include/time.h" 1 3 4
># 121 "/usr/include/time.h" 3 4
>struct timespec
>  {
>    __time_t tv_sec;
>    long int tv_nsec;
>  };
># 45 "/usr/include/sys/select.h" 2 3 4
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 69 "/usr/include/bits/time.h" 3 4
>struct timeval
>  {
>    __time_t tv_sec;
>    __suseconds_t tv_usec;
>  };
># 47 "/usr/include/sys/select.h" 2 3 4
># 55 "/usr/include/sys/select.h" 3 4
>typedef long int __fd_mask;
># 67 "/usr/include/sys/select.h" 3 4
>typedef struct
>  {
>
>
>
>    __fd_mask fds_bits[1024 / (8 * sizeof (__fd_mask))];
>
>
>
>
>
>  } fd_set;
>
>
>
>
>
>
>typedef __fd_mask fd_mask;
># 99 "/usr/include/sys/select.h" 3 4
>
># 109 "/usr/include/sys/select.h" 3 4
>extern int select (int __nfds, fd_set *__restrict __readfds,
>     fd_set *__restrict __writefds,
>     fd_set *__restrict __exceptfds,
>     struct timeval *__restrict __timeout);
># 121 "/usr/include/sys/select.h" 3 4
>extern int pselect (int __nfds, fd_set *__restrict __readfds,
>      fd_set *__restrict __writefds,
>      fd_set *__restrict __exceptfds,
>      const struct timespec *__restrict __timeout,
>      const __sigset_t *__restrict __sigmask);
>
>
>
># 221 "/usr/include/sys/types.h" 2 3 4
>
>
># 1 "/usr/include/sys/sysmacros.h" 1 3 4
># 30 "/usr/include/sys/sysmacros.h" 3 4
>__extension__
>extern unsigned int gnu_dev_major (unsigned long long int __dev)
>     __attribute__ ((__nothrow__));
>__extension__
>extern unsigned int gnu_dev_minor (unsigned long long int __dev)
>     __attribute__ ((__nothrow__));
>__extension__
>extern unsigned long long int gnu_dev_makedev (unsigned int __major,
>            unsigned int __minor)
>     __attribute__ ((__nothrow__));
># 224 "/usr/include/sys/types.h" 2 3 4
>
>
>
>
>typedef __blksize_t blksize_t;
>
>
>
>
>
>
>typedef __blkcnt_t blkcnt_t;
>
>
>
>typedef __fsblkcnt_t fsblkcnt_t;
>
>
>
>typedef __fsfilcnt_t fsfilcnt_t;
># 262 "/usr/include/sys/types.h" 3 4
>typedef __blkcnt64_t blkcnt64_t;
>typedef __fsblkcnt64_t fsblkcnt64_t;
>typedef __fsfilcnt64_t fsfilcnt64_t;
>
>
>
>
>
># 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
># 23 "/usr/include/bits/pthreadtypes.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 24 "/usr/include/bits/pthreadtypes.h" 2 3 4
># 50 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef unsigned long int pthread_t;
>
>
>typedef union
>{
>  char __size[56];
>  long int __align;
>} pthread_attr_t;
>
>
>
>typedef struct __pthread_internal_list
>{
>  struct __pthread_internal_list *__prev;
>  struct __pthread_internal_list *__next;
>} __pthread_list_t;
># 76 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef union
>{
>  struct __pthread_mutex_s
>  {
>    int __lock;
>    unsigned int __count;
>    int __owner;
>
>    unsigned int __nusers;
>
>
>
>    int __kind;
>
>    int __spins;
>    __pthread_list_t __list;
># 101 "/usr/include/bits/pthreadtypes.h" 3 4
>  } __data;
>  char __size[40];
>  long int __align;
>} pthread_mutex_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_mutexattr_t;
>
>
>
>
>typedef union
>{
>  struct
>  {
>    int __lock;
>    unsigned int __futex;
>    __extension__ unsigned long long int __total_seq;
>    __extension__ unsigned long long int __wakeup_seq;
>    __extension__ unsigned long long int __woken_seq;
>    void *__mutex;
>    unsigned int __nwaiters;
>    unsigned int __broadcast_seq;
>  } __data;
>  char __size[48];
>  __extension__ long long int __align;
>} pthread_cond_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_condattr_t;
>
>
>
>typedef unsigned int pthread_key_t;
>
>
>
>typedef int pthread_once_t;
>
>
>
>
>
>typedef union
>{
>
>  struct
>  {
>    int __lock;
>    unsigned int __nr_readers;
>    unsigned int __readers_wakeup;
>    unsigned int __writer_wakeup;
>    unsigned int __nr_readers_queued;
>    unsigned int __nr_writers_queued;
>    int __writer;
>    int __shared;
>    unsigned long int __pad1;
>    unsigned long int __pad2;
>
>
>    unsigned int __flags;
>  } __data;
># 187 "/usr/include/bits/pthreadtypes.h" 3 4
>  char __size[56];
>  long int __align;
>} pthread_rwlock_t;
>
>typedef union
>{
>  char __size[8];
>  long int __align;
>} pthread_rwlockattr_t;
>
>
>
>
>
>typedef volatile int pthread_spinlock_t;
>
>
>
>
>typedef union
>{
>  char __size[32];
>  long int __align;
>} pthread_barrier_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_barrierattr_t;
># 271 "/usr/include/sys/types.h" 2 3 4
>
>
>
># 321 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>
>extern long int random (void) __attribute__ ((__nothrow__));
>
>
>extern void srandom (unsigned int __seed) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern char *initstate (unsigned int __seed, char *__statebuf,
>   size_t __statelen) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>extern char *setstate (char *__statebuf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>struct random_data
>  {
>    int32_t *fptr;
>    int32_t *rptr;
>    int32_t *state;
>    int rand_type;
>    int rand_deg;
>    int rand_sep;
>    int32_t *end_ptr;
>  };
>
>extern int random_r (struct random_data *__restrict __buf,
>       int32_t *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int srandom_r (unsigned int __seed, struct random_data *__buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
>   size_t __statelen,
>   struct random_data *__restrict __buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 4)));
>
>extern int setstate_r (char *__restrict __statebuf,
>         struct random_data *__restrict __buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int rand (void) __attribute__ ((__nothrow__));
>
>extern void srand (unsigned int __seed) __attribute__ ((__nothrow__));
>
>
>
>
>extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern double drand48 (void) __attribute__ ((__nothrow__));
>extern double erand48 (unsigned short int __xsubi[3]) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int lrand48 (void) __attribute__ ((__nothrow__));
>extern long int nrand48 (unsigned short int __xsubi[3])
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int mrand48 (void) __attribute__ ((__nothrow__));
>extern long int jrand48 (unsigned short int __xsubi[3])
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern void srand48 (long int __seedval) __attribute__ ((__nothrow__));
>extern unsigned short int *seed48 (unsigned short int __seed16v[3])
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>extern void lcong48 (unsigned short int __param[7]) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>struct drand48_data
>  {
>    unsigned short int __x[3];
>    unsigned short int __old_x[3];
>    unsigned short int __c;
>    unsigned short int __init;
>    unsigned long long int __a;
>  };
>
>
>extern int drand48_r (struct drand48_data *__restrict __buffer,
>        double *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int erand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        double *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int lrand48_r (struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int nrand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int mrand48_r (struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int jrand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>extern int seed48_r (unsigned short int __seed16v[3],
>       struct drand48_data *__buffer) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int lcong48_r (unsigned short int __param[7],
>        struct drand48_data *__buffer)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>
>
>
>extern void *malloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) ;
>
>extern void *calloc (size_t __nmemb, size_t __size)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) ;
>
>
>
>
>
>
>
>
>
>
>extern void *realloc (void *__ptr, size_t __size)
>     __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));
>
>extern void free (void *__ptr) __attribute__ ((__nothrow__));
>
>
>
>
>extern void cfree (void *__ptr) __attribute__ ((__nothrow__));
>
>
>
># 1 "/usr/include/alloca.h" 1 3 4
># 25 "/usr/include/alloca.h" 3 4
># 1 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include/stddef.h" 1 3 4
># 26 "/usr/include/alloca.h" 2 3 4
>
>
>
>
>
>
>
>extern void *alloca (size_t __size) __attribute__ ((__nothrow__));
>
>
>
>
>
>
># 498 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>extern void *valloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) ;
>
>
>
>
>extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>extern void abort (void) __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
>
>
>
>extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern void exit (int __status) __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>extern void _Exit (int __status) __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>extern char *getenv (__const char *__name) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>extern char *__secure_getenv (__const char *__name)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern int putenv (char *__string) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int setenv (__const char *__name, __const char *__value, int __replace)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>extern int unsetenv (__const char *__name) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern int clearenv (void) __attribute__ ((__nothrow__));
># 583 "/usr/include/stdlib.h" 3 4
>extern char *mktemp (char *__template) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
># 594 "/usr/include/stdlib.h" 3 4
>extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
># 604 "/usr/include/stdlib.h" 3 4
>extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
># 614 "/usr/include/stdlib.h" 3 4
>extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
># 625 "/usr/include/stdlib.h" 3 4
>extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
># 635 "/usr/include/stdlib.h" 3 4
>extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>
>
>
>extern int system (__const char *__command) ;
>
>
>
>
>
>
>extern char *canonicalize_file_name (__const char *__name)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
># 662 "/usr/include/stdlib.h" 3 4
>extern char *realpath (__const char *__restrict __name,
>         char *__restrict __resolved) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>
>typedef int (*__compar_fn_t) (__const void *, __const void *);
>
>
>typedef __compar_fn_t comparison_fn_t;
>
>
>
>
>
>
>extern void *bsearch (__const void *__key, __const void *__base,
>        size_t __nmemb, size_t __size, __compar_fn_t __compar)
>     __attribute__ ((__nonnull__ (1, 2, 5))) ;
>
>
>
>extern void qsort (void *__base, size_t __nmemb, size_t __size,
>     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
>
>
>
>extern int abs (int __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>extern long int labs (long int __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>
>
>
>__extension__ extern long long int llabs (long long int __x)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>
>
>
>
>
>
>
>extern div_t div (int __numer, int __denom)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>extern ldiv_t ldiv (long int __numer, long int __denom)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>
>
>
>
>__extension__ extern lldiv_t lldiv (long long int __numer,
>        long long int __denom)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>
># 727 "/usr/include/stdlib.h" 3 4
>extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4))) ;
>
>
>
>
>extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4))) ;
>
>
>
>
>extern char *gcvt (double __value, int __ndigit, char *__buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3))) ;
>
>
>
>
>extern char *qecvt (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4))) ;
>extern char *qfcvt (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4))) ;
>extern char *qgcvt (long double __value, int __ndigit, char *__buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3))) ;
>
>
>
>
>extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign, char *__restrict __buf,
>     size_t __len) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign, char *__restrict __buf,
>     size_t __len) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>
>extern int qecvt_r (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign,
>      char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int qfcvt_r (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign,
>      char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>
>
>
>
>
>
>
>extern int mblen (__const char *__s, size_t __n) __attribute__ ((__nothrow__)) ;
>
>
>extern int mbtowc (wchar_t *__restrict __pwc,
>     __const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__)) ;
>
>
>extern int wctomb (char *__s, wchar_t __wchar) __attribute__ ((__nothrow__)) ;
>
>
>
>extern size_t mbstowcs (wchar_t *__restrict __pwcs,
>   __const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__));
>
>extern size_t wcstombs (char *__restrict __s,
>   __const wchar_t *__restrict __pwcs, size_t __n)
>     __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern int rpmatch (__const char *__response) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
># 815 "/usr/include/stdlib.h" 3 4
>extern int getsubopt (char **__restrict __optionp,
>        char *__const *__restrict __tokens,
>        char **__restrict __valuep)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2, 3))) ;
>
>
>
>
>
>extern void setkey (__const char *__key) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int posix_openpt (int __oflag) ;
>
>
>
>
>
>
>
>extern int grantpt (int __fd) __attribute__ ((__nothrow__));
>
>
>
>extern int unlockpt (int __fd) __attribute__ ((__nothrow__));
>
>
>
>
>extern char *ptsname (int __fd) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>
>extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>extern int getpt (void);
>
>
>
>
>
>
>extern int getloadavg (double __loadavg[], int __nelem)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
># 883 "/usr/include/stdlib.h" 3 4
>
># 37 "attrib.c" 2
>
>
># 1 "/usr/include/errno.h" 1 3 4
># 32 "/usr/include/errno.h" 3 4
>
>
>
>
># 1 "/usr/include/bits/errno.h" 1 3 4
># 25 "/usr/include/bits/errno.h" 3 4
># 1 "/usr/include/linux/errno.h" 1 3 4
>
>
>
># 1 "/usr/include/asm/errno.h" 1 3 4
># 1 "/usr/include/asm-generic/errno.h" 1 3 4
>
>
>
># 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
># 5 "/usr/include/asm-generic/errno.h" 2 3 4
># 1 "/usr/include/asm/errno.h" 2 3 4
># 5 "/usr/include/linux/errno.h" 2 3 4
># 26 "/usr/include/bits/errno.h" 2 3 4
># 43 "/usr/include/bits/errno.h" 3 4
>extern int *__errno_location (void) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
># 37 "/usr/include/errno.h" 2 3 4
># 55 "/usr/include/errno.h" 3 4
>extern char *program_invocation_name, *program_invocation_short_name;
>
>
>
>
># 69 "/usr/include/errno.h" 3 4
>typedef int error_t;
># 40 "attrib.c" 2
>
>
># 1 "../include/ntfs-3g/compat.h" 1
># 27 "../include/ntfs-3g/compat.h"
># 1 "../config.h" 1
># 28 "../include/ntfs-3g/compat.h" 2
># 43 "attrib.c" 2
># 1 "../include/ntfs-3g/attrib.h" 1
># 28 "../include/ntfs-3g/attrib.h"
>typedef struct _ntfs_attr ntfs_attr;
>typedef struct _ntfs_attr_search_ctx ntfs_attr_search_ctx;
>
># 1 "../include/ntfs-3g/types.h" 1
># 27 "../include/ntfs-3g/types.h"
># 1 "../config.h" 1
># 28 "../include/ntfs-3g/types.h" 2
>
>
>
># 1 "/usr/include/stdint.h" 1 3 4
># 27 "/usr/include/stdint.h" 3 4
># 1 "/usr/include/bits/wchar.h" 1 3 4
># 28 "/usr/include/stdint.h" 2 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/stdint.h" 2 3 4
># 49 "/usr/include/stdint.h" 3 4
>typedef unsigned char uint8_t;
>typedef unsigned short int uint16_t;
>
>typedef unsigned int uint32_t;
>
>
>
>typedef unsigned long int uint64_t;
># 66 "/usr/include/stdint.h" 3 4
>typedef signed char int_least8_t;
>typedef short int int_least16_t;
>typedef int int_least32_t;
>
>typedef long int int_least64_t;
>
>
>
>
>
>
>typedef unsigned char uint_least8_t;
>typedef unsigned short int uint_least16_t;
>typedef unsigned int uint_least32_t;
>
>typedef unsigned long int uint_least64_t;
># 91 "/usr/include/stdint.h" 3 4
>typedef signed char int_fast8_t;
>
>typedef long int int_fast16_t;
>typedef long int int_fast32_t;
>typedef long int int_fast64_t;
># 104 "/usr/include/stdint.h" 3 4
>typedef unsigned char uint_fast8_t;
>
>typedef unsigned long int uint_fast16_t;
>typedef unsigned long int uint_fast32_t;
>typedef unsigned long int uint_fast64_t;
># 120 "/usr/include/stdint.h" 3 4
>typedef long int intptr_t;
>
>
>typedef unsigned long int uintptr_t;
># 135 "/usr/include/stdint.h" 3 4
>typedef long int intmax_t;
>typedef unsigned long int uintmax_t;
># 32 "../include/ntfs-3g/types.h" 2
>
>
>
>
>
>typedef uint8_t u8;
>typedef uint16_t u16;
>typedef uint32_t u32;
>typedef uint64_t u64;
>
>typedef int8_t s8;
>typedef int16_t s16;
>typedef int32_t s32;
>typedef int64_t s64;
>
>typedef u16 le16;
>typedef u32 le32;
>typedef u64 le64;
>
>
>
>
>
>typedef u16 sle16;
>typedef u32 sle32;
>typedef u64 sle64;
>
>typedef u16 ntfschar;
>
>
>
>
>
>
>typedef s64 VCN;
>typedef sle64 leVCN;
>typedef s64 LCN;
>typedef sle64 leLCN;
>
>
>
>
>
>
>typedef s64 LSN;
>typedef sle64 leLSN;
># 87 "../include/ntfs-3g/types.h"
>typedef enum {
>
> FALSE = 0,
>
>
> NO = 0,
>
>
> ZERO = 0,
>
>
> TRUE = 1,
>
>
> YES = 1,
>
>
> ONE = 1,
>
>} BOOL;
>
>
>
>
>
>typedef enum {
> CASE_SENSITIVE = 0,
> IGNORE_CASE = 1,
>} IGNORE_CASE_BOOL;
># 32 "../include/ntfs-3g/attrib.h" 2
># 1 "../include/ntfs-3g/inode.h" 1
># 29 "../include/ntfs-3g/inode.h"
>typedef struct _ntfs_inode ntfs_inode;
>
>
># 1 "../include/ntfs-3g/layout.h" 1
># 28 "../include/ntfs-3g/layout.h"
># 1 "../include/ntfs-3g/endians.h" 1
># 27 "../include/ntfs-3g/endians.h"
># 1 "../config.h" 1
># 28 "../include/ntfs-3g/endians.h" 2
># 52 "../include/ntfs-3g/endians.h"
># 1 "/usr/include/sys/param.h" 1 3 4
># 22 "/usr/include/sys/param.h" 3 4
># 1 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include-fixed/limits.h" 1 3 4
># 11 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include-fixed/limits.h" 3 4
># 1 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include-fixed/syslimits.h" 1 3 4
>
>
>
>
>
>
># 1 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include-fixed/limits.h" 1 3 4
># 122 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include-fixed/limits.h" 3 4
># 1 "/usr/include/limits.h" 1 3 4
># 145 "/usr/include/limits.h" 3 4
># 1 "/usr/include/bits/posix1_lim.h" 1 3 4
># 153 "/usr/include/bits/posix1_lim.h" 3 4
># 1 "/usr/include/bits/local_lim.h" 1 3 4
># 36 "/usr/include/bits/local_lim.h" 3 4
># 1 "/usr/include/linux/limits.h" 1 3 4
># 37 "/usr/include/bits/local_lim.h" 2 3 4
># 154 "/usr/include/bits/posix1_lim.h" 2 3 4
># 146 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/posix2_lim.h" 1 3 4
># 150 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/xopen_lim.h" 1 3 4
># 34 "/usr/include/bits/xopen_lim.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 35 "/usr/include/bits/xopen_lim.h" 2 3 4
># 154 "/usr/include/limits.h" 2 3 4
># 123 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include-fixed/limits.h" 2 3 4
># 8 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include-fixed/syslimits.h" 2 3 4
># 12 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include-fixed/limits.h" 2 3 4
># 23 "/usr/include/sys/param.h" 2 3 4
>
># 1 "/usr/include/linux/param.h" 1 3 4
>
>
>
># 1 "/usr/include/asm/param.h" 1 3 4
># 5 "/usr/include/linux/param.h" 2 3 4
># 25 "/usr/include/sys/param.h" 2 3 4
># 53 "../include/ntfs-3g/endians.h" 2
># 104 "../include/ntfs-3g/endians.h"
># 1 "/usr/include/byteswap.h" 1 3 4
># 23 "/usr/include/byteswap.h" 3 4
># 1 "/usr/include/bits/byteswap.h" 1 3 4
># 28 "/usr/include/bits/byteswap.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/bits/byteswap.h" 2 3 4
># 24 "/usr/include/byteswap.h" 2 3 4
># 105 "../include/ntfs-3g/endians.h" 2
># 29 "../include/ntfs-3g/layout.h" 2
># 1 "../include/ntfs-3g/support.h" 1
># 26 "../include/ntfs-3g/support.h"
># 1 "../config.h" 1
># 27 "../include/ntfs-3g/support.h" 2
>
>
>
># 1 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include/stddef.h" 1 3 4
># 152 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include/stddef.h" 3 4
>typedef long int ptrdiff_t;
># 31 "../include/ntfs-3g/support.h" 2
># 30 "../include/ntfs-3g/layout.h" 2
># 49 "../include/ntfs-3g/layout.h"
>typedef struct {
> u16 bytes_per_sector;
> u8 sectors_per_cluster;
> u16 reserved_sectors;
> u8 fats;
> u16 root_entries;
> u16 sectors;
> u8 media_type;
> u16 sectors_per_fat;
>        u16 sectors_per_track;
>        u16 heads;
>        u32 hidden_sectors;
>
>
>        u32 large_sectors;
>
>} __attribute__((__packed__)) BIOS_PARAMETER_BLOCK;
>
>
>
>
>typedef struct {
> u8 jump[3];
> u64 oem_id;
>        BIOS_PARAMETER_BLOCK bpb;
> u8 physical_drive;
> u8 current_head;
> u8 extended_boot_signature;
> u8 reserved2;
>        s64 number_of_sectors;
>
>
>
>
> s64 mft_lcn;
> s64 mftmirr_lcn;
> s8 clusters_per_mft_record;
> u8 reserved0[3];
> s8 clusters_per_index_record;
> u8 reserved1[3];
> u64 volume_serial_number;
> u32 checksum;
>        u8 bootstrap[426];
> u16 end_of_sector_marker;
>
>
>} __attribute__((__packed__)) NTFS_BOOT_SECTOR;
>
>
>
>
>
>
>
>typedef enum {
>
> magic_FILE = (0x454c4946),
> magic_INDX = (0x58444e49),
> magic_HOLE = (0x454c4f48),
>
>
> magic_RSTR = (0x52545352),
> magic_RCRD = (0x44524352),
>
>
> magic_CHKD = (0x444b4843),
>
>
> magic_BAAD = (0x44414142),
>
>
>
>
>
>
>
> magic_empty = (0xffffffff),
>
>
>} NTFS_RECORD_TYPES;
># 185 "../include/ntfs-3g/layout.h"
>typedef struct {
> NTFS_RECORD_TYPES magic;
>
> u16 usa_ofs;
>
> u16 usa_count;
>
>
>
>} __attribute__((__packed__)) NTFS_RECORD;
># 204 "../include/ntfs-3g/layout.h"
>typedef enum {
> FILE_MFT = 0,
>
>
> FILE_MFTMirr = 1,
>
>
>
> FILE_LogFile = 2,
> FILE_Volume = 3,
>
>
>
> FILE_AttrDef = 4,
>
> FILE_root = 5,
> FILE_Bitmap = 6,
>
> FILE_Boot = 7,
>
> FILE_BadClus = 8,
>
> FILE_Secure = 9,
>
>
>
> FILE_UpCase = 10,
>
> FILE_Extend = 11,
>
>
> FILE_reserved12 = 12,
> FILE_reserved13 = 13,
> FILE_reserved14 = 14,
> FILE_reserved15 = 15,
> FILE_first_user = 16,
>
>} NTFS_SYSTEM_FILES;
># 257 "../include/ntfs-3g/layout.h"
>typedef enum {
> MFT_RECORD_IN_USE = (0x0001),
> MFT_RECORD_IS_DIRECTORY = (0x0002),
> MFT_RECORD_IS_4 = (0x0004),
> MFT_RECORD_IS_VIEW_INDEX = (0x0008),
> MFT_REC_SPACE_FILLER = 0xffff,
>
>} __attribute__((__packed__)) MFT_RECORD_FLAGS;
># 313 "../include/ntfs-3g/layout.h"
>typedef u64 MFT_REF;
># 338 "../include/ntfs-3g/layout.h"
>typedef struct {
>
>
> NTFS_RECORD_TYPES magic;
> u16 usa_ofs;
> u16 usa_count;
>
>        LSN lsn;
>
>        u16 sequence_number;
>
>
>
>
>        u16 link_count;
># 362 "../include/ntfs-3g/layout.h"
>        u16 attrs_offset;
>
>
>        MFT_RECORD_FLAGS flags;
>
>
>        u32 bytes_in_use;
>
>        u32 bytes_allocated;
>
>
>        MFT_REF base_mft_record;
># 385 "../include/ntfs-3g/layout.h"
>        u16 next_attr_instance;
>
>
>
>
>
>
>
>        u16 reserved;
>        u32 mft_record_number;
># 405 "../include/ntfs-3g/layout.h"
>} __attribute__((__packed__)) MFT_RECORD;
>
>
>
>
>
>
>typedef struct {
>
>
> NTFS_RECORD_TYPES magic;
> u16 usa_ofs;
> u16 usa_count;
>
>        LSN lsn;
>
>        u16 sequence_number;
>
>
>
>
>        u16 link_count;
># 436 "../include/ntfs-3g/layout.h"
>        u16 attrs_offset;
>
>
>        MFT_RECORD_FLAGS flags;
>
>
>        u32 bytes_in_use;
>
>        u32 bytes_allocated;
>
>
>        MFT_REF base_mft_record;
># 459 "../include/ntfs-3g/layout.h"
>        u16 next_attr_instance;
># 476 "../include/ntfs-3g/layout.h"
>} __attribute__((__packed__)) MFT_RECORD_OLD;
># 489 "../include/ntfs-3g/layout.h"
>typedef enum {
> AT_UNUSED = (0),
> AT_STANDARD_INFORMATION = (0x10),
> AT_ATTRIBUTE_LIST = (0x20),
> AT_FILE_NAME = (0x30),
> AT_OBJECT_ID = (0x40),
> AT_SECURITY_DESCRIPTOR = (0x50),
> AT_VOLUME_NAME = (0x60),
> AT_VOLUME_INFORMATION = (0x70),
> AT_DATA = (0x80),
> AT_INDEX_ROOT = (0x90),
> AT_INDEX_ALLOCATION = (0xa0),
> AT_BITMAP = (0xb0),
> AT_REPARSE_POINT = (0xc0),
> AT_EA_INFORMATION = (0xd0),
> AT_EA = (0xe0),
> AT_PROPERTY_SET = (0xf0),
> AT_LOGGED_UTILITY_STREAM = (0x100),
> AT_FIRST_USER_DEFINED_ATTRIBUTE = (0x1000),
> AT_END = (0xffffffff),
>} ATTR_TYPES;
># 548 "../include/ntfs-3g/layout.h"
>typedef enum {
> COLLATION_BINARY = (0),
>
>
> COLLATION_FILE_NAME = (1),
>
> COLLATION_UNICODE_STRING = (2),
>
>
>
>
>
> COLLATION_NTOFS_ULONG = (16),
> COLLATION_NTOFS_SID = (17),
> COLLATION_NTOFS_SECURITY_HASH = (18),
> COLLATION_NTOFS_ULONGS = (19),
>} COLLATION_RULES;
># 576 "../include/ntfs-3g/layout.h"
>typedef enum {
> ATTR_DEF_INDEXABLE = (0x02),
>
> ATTR_DEF_MULTIPLE = (0x04),
>
>
> ATTR_DEF_NOT_ZERO = (0x08),
>
>
> ATTR_DEF_INDEXED_UNIQUE = (0x10),
>
>
>
> ATTR_DEF_NAMED_UNIQUE = (0x20),
>
>
>
> ATTR_DEF_RESIDENT = (0x40),
>
> ATTR_DEF_ALWAYS_LOG = (0x80),
>
>
>
>
>
>} ATTR_DEF_FLAGS;
># 614 "../include/ntfs-3g/layout.h"
>typedef struct {
>
>        ntfschar name[0x40];
>
>        ATTR_TYPES type;
>        u32 display_rule;
>
>        COLLATION_RULES collation_rule;
>        ATTR_DEF_FLAGS flags;
>        s64 min_size;
>        s64 max_size;
>
>} __attribute__((__packed__)) ATTR_DEF;
>
>
>
>
>typedef enum {
> ATTR_IS_COMPRESSED = (0x0001),
> ATTR_COMPRESSION_MASK = (0x00ff),
>
>
> ATTR_IS_ENCRYPTED = (0x4000),
> ATTR_IS_SPARSE = (0x8000),
>} __attribute__((__packed__)) ATTR_FLAGS;
># 710 "../include/ntfs-3g/layout.h"
>typedef enum {
> RESIDENT_ATTR_IS_INDEXED = 0x01,
>
>
>} __attribute__((__packed__)) RESIDENT_ATTR_FLAGS;
>
>
>
>
>
>
>typedef struct {
>
>        ATTR_TYPES type;
>        u32 length;
>
>
>        u8 non_resident;
>
>        u8 name_length;
>
>        u16 name_offset;
># 740 "../include/ntfs-3g/layout.h"
>        ATTR_FLAGS flags;
>        u16 instance;
>
>
>
>        union {
>
>  struct {
>          u32 value_length;
>          u16 value_offset;
>
>
>
>
>
>
>          RESIDENT_ATTR_FLAGS resident_flags;
>          s8 reservedR;
>
>          void *resident_end[0];
>
>
>  } __attribute__((__packed__));
>
>  struct {
>          VCN lowest_vcn;
>
>
>
>
>          VCN highest_vcn;
>
>
>
>
>
>          u16 mapping_pairs_offset;
>
>
>
>
>
>          u8 compression_unit;
>
>
>
>
>
>          u8 reserved1[5];
>
>
>          s64 allocated_size;
>
>
>
>
>
>
>
>          s64 data_size;
>
>
>          s64 initialized_size;
>
>
>          void *non_resident_end[0];
>
>
>
>
>          s64 compressed_size;
>
>
>
>
>          void *compressed_end[0];
>
>
>
>  } __attribute__((__packed__));
> } __attribute__((__packed__));
>} __attribute__((__packed__)) ATTR_RECORD;
>
>typedef ATTR_RECORD ATTR_REC;
>
>
>
>
>typedef enum {
>
>
>
>
> FILE_ATTR_READONLY = (0x00000001),
> FILE_ATTR_HIDDEN = (0x00000002),
> FILE_ATTR_SYSTEM = (0x00000004),
>
>
> FILE_ATTR_DIRECTORY = (0x00000010),
>
>
> FILE_ATTR_ARCHIVE = (0x00000020),
> FILE_ATTR_DEVICE = (0x00000040),
> FILE_ATTR_NORMAL = (0x00000080),
>
> FILE_ATTR_TEMPORARY = (0x00000100),
> FILE_ATTR_SPARSE_FILE = (0x00000200),
> FILE_ATTR_REPARSE_POINT = (0x00000400),
> FILE_ATTR_COMPRESSED = (0x00000800),
>
> FILE_ATTR_OFFLINE = (0x00001000),
> FILE_ATTR_NOT_CONTENT_INDEXED = (0x00002000),
> FILE_ATTR_ENCRYPTED = (0x00004000),
>
> FILE_ATTR_VALID_FLAGS = (0x00007fb7),
>
>
>
> FILE_ATTR_VALID_SET_FLAGS = (0x000031a7),
># 875 "../include/ntfs-3g/layout.h"
> FILE_ATTR_I30_INDEX_PRESENT = (0x10000000),
># 888 "../include/ntfs-3g/layout.h"
> FILE_ATTR_VIEW_INDEX_PRESENT = (0x20000000),
>} __attribute__((__packed__)) FILE_ATTR_FLAGS;
># 908 "../include/ntfs-3g/layout.h"
>typedef struct {
>
>        s64 creation_time;
>
>        s64 last_data_change_time;
>
>        s64 last_mft_change_time;
>
>        s64 last_access_time;
>
>
>
>
>
>
>
>        FILE_ATTR_FLAGS file_attributes;
>        union {
>
>  struct {
>           u8 reserved12[12];
>
>           void *v1_end[0];
>  } __attribute__((__packed__));
>
>
>  struct {
># 954 "../include/ntfs-3g/layout.h"
>          u32 maximum_versions;
>
>          u32 version_number;
>
>          u32 class_id;
>
>          u32 owner_id;
>
>
>
>          u32 security_id;
>
>
>          u64 quota_charged;
>
>
>          u64 usn;
># 984 "../include/ntfs-3g/layout.h"
>          void *v3_end[0];
>  } __attribute__((__packed__));
> } __attribute__((__packed__));
>
>} __attribute__((__packed__)) STANDARD_INFORMATION;
># 1019 "../include/ntfs-3g/layout.h"
>typedef struct {
>
>        ATTR_TYPES type;
>        u16 length;
>        u8 name_length;
>
>        u8 name_offset;
>
>
>        VCN lowest_vcn;
># 1040 "../include/ntfs-3g/layout.h"
>        MFT_REF mft_reference;
>
>
>        u16 instance;
>
>        ntfschar name[0];
>
>
>
>} __attribute__((__packed__)) ATTR_LIST_ENTRY;
># 1060 "../include/ntfs-3g/layout.h"
>typedef enum {
> FILE_NAME_POSIX = 0x00,
>
>
>
>
>
>
> FILE_NAME_WIN32 = 0x01,
>
>
>
>
> FILE_NAME_DOS = 0x02,
>
>
>
> FILE_NAME_WIN32_AND_DOS = 0x03,
>
>
>
>} __attribute__((__packed__)) FILE_NAME_TYPE_FLAGS;
># 1096 "../include/ntfs-3g/layout.h"
>typedef struct {
>
>        MFT_REF parent_directory;
>
>        s64 creation_time;
>        s64 last_data_change_time;
>
>        s64 last_mft_change_time;
>
>        s64 last_access_time;
>
>        s64 allocated_size;
># 1116 "../include/ntfs-3g/layout.h"
>        s64 data_size;
>
>        FILE_ATTR_FLAGS file_attributes;
>        union {
>         struct {
>          u16 packed_ea_size;
>
>
>          u16 reserved;
>  } __attribute__((__packed__));
>         u32 reparse_point_tag;
>
>
>
> } __attribute__((__packed__));
>        u8 file_name_length;
>
>        FILE_NAME_TYPE_FLAGS file_name_type;
>        ntfschar file_name[0];
>} __attribute__((__packed__)) FILE_NAME_ATTR;
># 1149 "../include/ntfs-3g/layout.h"
>typedef struct {
> u32 data1;
> u16 data2;
> u16 data3;
> u8 data4[8];
>
>
>} __attribute__((__packed__)) GUID;
># 1171 "../include/ntfs-3g/layout.h"
>typedef struct {
> MFT_REF mft_reference;
>
> union {
>  struct {
>   GUID birth_volume_id;
>   GUID birth_object_id;
>   GUID domain_id;
>  } __attribute__((__packed__));
>  u8 extended_info[48];
> } __attribute__((__packed__));
>} __attribute__((__packed__)) OBJ_ID_INDEX_DATA;
>
>
>
>
>
>
>typedef struct {
> GUID object_id;
># 1199 "../include/ntfs-3g/layout.h"
> union {
>  struct {
>   GUID birth_volume_id;
>
>   GUID birth_object_id;
>
>   GUID domain_id;
>  } __attribute__((__packed__));
>  u8 extended_info[48];
> } __attribute__((__packed__));
>} __attribute__((__packed__)) OBJECT_ID_ATTR;
># 1240 "../include/ntfs-3g/layout.h"
>typedef enum {
> SECURITY_NULL_RID = 0,
> SECURITY_WORLD_RID = 0,
> SECURITY_LOCAL_RID = 0,
>
> SECURITY_CREATOR_OWNER_RID = 0,
> SECURITY_CREATOR_GROUP_RID = 1,
>
> SECURITY_CREATOR_OWNER_SERVER_RID = 2,
> SECURITY_CREATOR_GROUP_SERVER_RID = 3,
>
> SECURITY_DIALUP_RID = 1,
> SECURITY_NETWORK_RID = 2,
> SECURITY_BATCH_RID = 3,
> SECURITY_INTERACTIVE_RID = 4,
> SECURITY_SERVICE_RID = 6,
> SECURITY_ANONYMOUS_LOGON_RID = 7,
> SECURITY_PROXY_RID = 8,
> SECURITY_ENTERPRISE_CONTROLLERS_RID=9,
> SECURITY_SERVER_LOGON_RID = 9,
> SECURITY_PRINCIPAL_SELF_RID = 0xa,
> SECURITY_AUTHENTICATED_USER_RID = 0xb,
> SECURITY_RESTRICTED_CODE_RID = 0xc,
> SECURITY_TERMINAL_SERVER_RID = 0xd,
>
> SECURITY_LOGON_IDS_RID = 5,
> SECURITY_LOGON_IDS_RID_COUNT = 3,
>
> SECURITY_LOCAL_SYSTEM_RID = 0x12,
>
> SECURITY_NT_NON_UNIQUE = 0x15,
>
> SECURITY_BUILTIN_DOMAIN_RID = 0x20,
>
>
>
>
>
>
> DOMAIN_USER_RID_ADMIN = 0x1f4,
> DOMAIN_USER_RID_GUEST = 0x1f5,
> DOMAIN_USER_RID_KRBTGT = 0x1f6,
>
>
> DOMAIN_GROUP_RID_ADMINS = 0x200,
> DOMAIN_GROUP_RID_USERS = 0x201,
> DOMAIN_GROUP_RID_GUESTS = 0x202,
> DOMAIN_GROUP_RID_COMPUTERS = 0x203,
> DOMAIN_GROUP_RID_CONTROLLERS = 0x204,
> DOMAIN_GROUP_RID_CERT_ADMINS = 0x205,
> DOMAIN_GROUP_RID_SCHEMA_ADMINS = 0x206,
> DOMAIN_GROUP_RID_ENTERPRISE_ADMINS= 0x207,
> DOMAIN_GROUP_RID_POLICY_ADMINS = 0x208,
>
>
> DOMAIN_ALIAS_RID_ADMINS = 0x220,
> DOMAIN_ALIAS_RID_USERS = 0x221,
> DOMAIN_ALIAS_RID_GUESTS = 0x222,
> DOMAIN_ALIAS_RID_POWER_USERS = 0x223,
>
> DOMAIN_ALIAS_RID_ACCOUNT_OPS = 0x224,
> DOMAIN_ALIAS_RID_SYSTEM_OPS = 0x225,
> DOMAIN_ALIAS_RID_PRINT_OPS = 0x226,
> DOMAIN_ALIAS_RID_BACKUP_OPS = 0x227,
>
> DOMAIN_ALIAS_RID_REPLICATOR = 0x228,
> DOMAIN_ALIAS_RID_RAS_SERVERS = 0x229,
> DOMAIN_ALIAS_RID_PREW2KCOMPACCESS = 0x22a,
>} RELATIVE_IDENTIFIERS;
># 1352 "../include/ntfs-3g/layout.h"
>typedef union {
> struct {
>  u16 high_part;
>  u32 low_part;
> } __attribute__((__packed__));
> u8 value[6];
>} __attribute__((__packed__)) SID_IDENTIFIER_AUTHORITY;
># 1388 "../include/ntfs-3g/layout.h"
>typedef struct {
> u8 revision;
> u8 sub_authority_count;
> SID_IDENTIFIER_AUTHORITY identifier_authority;
> u32 sub_authority[1];
>} __attribute__((__packed__)) SID;
>
>
>
>
>typedef enum {
> SID_REVISION = 1,
> SID_MAX_SUB_AUTHORITIES = 15,
> SID_RECOMMENDED_SUB_AUTHORITIES = 1,
>
>} SID_CONSTANTS;
>
>
>
>
>typedef enum {
> ACCESS_MIN_MS_ACE_TYPE = 0,
> ACCESS_ALLOWED_ACE_TYPE = 0,
> ACCESS_DENIED_ACE_TYPE = 1,
> SYSTEM_AUDIT_ACE_TYPE = 2,
> SYSTEM_ALARM_ACE_TYPE = 3,
> ACCESS_MAX_MS_V2_ACE_TYPE = 3,
>
> ACCESS_ALLOWED_COMPOUND_ACE_TYPE= 4,
> ACCESS_MAX_MS_V3_ACE_TYPE = 4,
>
>
> ACCESS_MIN_MS_OBJECT_ACE_TYPE = 5,
> ACCESS_ALLOWED_OBJECT_ACE_TYPE = 5,
> ACCESS_DENIED_OBJECT_ACE_TYPE = 6,
> SYSTEM_AUDIT_OBJECT_ACE_TYPE = 7,
> SYSTEM_ALARM_OBJECT_ACE_TYPE = 8,
> ACCESS_MAX_MS_OBJECT_ACE_TYPE = 8,
>
> ACCESS_MAX_MS_V4_ACE_TYPE = 8,
>
>
> ACCESS_MAX_MS_ACE_TYPE = 8,
>} __attribute__((__packed__)) ACE_TYPES;
># 1443 "../include/ntfs-3g/layout.h"
>typedef enum {
>
> OBJECT_INHERIT_ACE = 0x01,
> CONTAINER_INHERIT_ACE = 0x02,
> NO_PROPAGATE_INHERIT_ACE = 0x04,
> INHERIT_ONLY_ACE = 0x08,
> INHERITED_ACE = 0x10,
> VALID_INHERIT_FLAGS = 0x1f,
>
>
> SUCCESSFUL_ACCESS_ACE_FLAG = 0x40,
> FAILED_ACCESS_ACE_FLAG = 0x80,
>} __attribute__((__packed__)) ACE_FLAGS;
># 1470 "../include/ntfs-3g/layout.h"
>typedef struct {
> ACE_TYPES type;
> ACE_FLAGS flags;
> u16 size;
>} __attribute__((__packed__)) ACE_HEADER;
>
>
>
>
>
>
>typedef enum {
># 1490 "../include/ntfs-3g/layout.h"
> FILE_READ_DATA = (0x00000001),
>
> FILE_LIST_DIRECTORY = (0x00000001),
>
>
> FILE_WRITE_DATA = (0x00000002),
>
> FILE_ADD_FILE = (0x00000002),
>
>
> FILE_APPEND_DATA = (0x00000004),
>
> FILE_ADD_SUBDIRECTORY = (0x00000004),
>
>
> FILE_READ_EA = (0x00000008),
>
>
> FILE_WRITE_EA = (0x00000010),
>
>
> FILE_EXECUTE = (0x00000020),
>
> FILE_TRAVERSE = (0x00000020),
>
>
>
>
>
> FILE_DELETE_CHILD = (0x00000040),
>
>
> FILE_READ_ATTRIBUTES = (0x00000080),
>
>
> FILE_WRITE_ATTRIBUTES = (0x00000100),
>
>
>
>
>
>
>
> DELETE = (0x00010000),
>
>
>
>
>
>
> READ_CONTROL = (0x00020000),
>
>
> WRITE_DAC = (0x00040000),
>
>
> WRITE_OWNER = (0x00080000),
>
>
>
>
>
>
> SYNCHRONIZE = (0x00100000),
>
>
>
>
>
>
>
> STANDARD_RIGHTS_READ = (0x00020000),
> STANDARD_RIGHTS_WRITE = (0x00020000),
> STANDARD_RIGHTS_EXECUTE = (0x00020000),
>
>
> STANDARD_RIGHTS_REQUIRED = (0x000f0000),
>
>
>
>
>
> STANDARD_RIGHTS_ALL = (0x001f0000),
>
>
>
>
>
> ACCESS_SYSTEM_SECURITY = (0x01000000),
> MAXIMUM_ALLOWED = (0x02000000),
>
>
>
>
>
>
>
> GENERIC_ALL = (0x10000000),
>
>
> GENERIC_EXECUTE = (0x20000000),
># 1599 "../include/ntfs-3g/layout.h"
> GENERIC_WRITE = (0x40000000),
># 1608 "../include/ntfs-3g/layout.h"
> GENERIC_READ = (0x80000000),
>} ACCESS_MASK;
># 1619 "../include/ntfs-3g/layout.h"
>typedef struct {
> ACCESS_MASK generic_read;
> ACCESS_MASK generic_write;
> ACCESS_MASK generic_execute;
> ACCESS_MASK generic_all;
>} __attribute__((__packed__)) GENERIC_MAPPING;
># 1635 "../include/ntfs-3g/layout.h"
>typedef struct {
>
> ACE_TYPES type;
> ACE_FLAGS flags;
> u16 size;
>
>        ACCESS_MASK mask;
>        SID sid;
>} __attribute__((__packed__)) ACCESS_ALLOWED_ACE, ACCESS_DENIED_ACE,
>          SYSTEM_AUDIT_ACE, SYSTEM_ALARM_ACE;
>
>
>
>
>typedef enum {
> ACE_OBJECT_TYPE_PRESENT = (1),
> ACE_INHERITED_OBJECT_TYPE_PRESENT = (2),
>} OBJECT_ACE_FLAGS;
>
>
>
>
>typedef struct {
>
> ACE_TYPES type;
> ACE_FLAGS flags;
> u16 size;
>
>        ACCESS_MASK mask;
>        OBJECT_ACE_FLAGS object_flags;
>        GUID object_type;
>        GUID inherited_object_type;
>        SID sid;
>} __attribute__((__packed__)) ACCESS_ALLOWED_OBJECT_ACE,
>          ACCESS_DENIED_OBJECT_ACE,
>          SYSTEM_AUDIT_OBJECT_ACE,
>          SYSTEM_ALARM_OBJECT_ACE;
># 1681 "../include/ntfs-3g/layout.h"
>typedef struct {
> u8 revision;
> u8 alignment1;
> u16 size;
>
> u16 ace_count;
> u16 alignment2;
>
>} __attribute__((__packed__)) ACL;
>
>
>
>
>typedef enum {
>
> ACL_REVISION = 2,
> ACL_REVISION_DS = 4,
>
>
> ACL_REVISION1 = 1,
> MIN_ACL_REVISION = 2,
> ACL_REVISION2 = 2,
> ACL_REVISION3 = 3,
> ACL_REVISION4 = 4,
> MAX_ACL_REVISION = 4,
>} ACL_CONSTANTS;
># 1757 "../include/ntfs-3g/layout.h"
>typedef enum {
> SE_OWNER_DEFAULTED = (0x0001),
> SE_GROUP_DEFAULTED = (0x0002),
> SE_DACL_PRESENT = (0x0004),
> SE_DACL_DEFAULTED = (0x0008),
> SE_SACL_PRESENT = (0x0010),
> SE_SACL_DEFAULTED = (0x0020),
> SE_DACL_AUTO_INHERIT_REQ = (0x0100),
> SE_SACL_AUTO_INHERIT_REQ = (0x0200),
> SE_DACL_AUTO_INHERITED = (0x0400),
> SE_SACL_AUTO_INHERITED = (0x0800),
> SE_DACL_PROTECTED = (0x1000),
> SE_SACL_PROTECTED = (0x2000),
> SE_RM_CONTROL_VALID = (0x4000),
> SE_SELF_RELATIVE = (0x8000),
>} __attribute__((__packed__)) SECURITY_DESCRIPTOR_CONTROL;
>
>
>
>
>
>
>
>typedef struct {
> u8 revision;
> u8 alignment;
> SECURITY_DESCRIPTOR_CONTROL control;
>
> u32 owner;
>
>
> u32 group;
>
>
> u32 sacl;
>
>
>
> u32 dacl;
>
>
>
>
>} __attribute__((__packed__)) SECURITY_DESCRIPTOR_RELATIVE;
># 1812 "../include/ntfs-3g/layout.h"
>typedef struct {
> u8 revision;
> u8 alignment;
> SECURITY_DESCRIPTOR_CONTROL control;
>
> SID *owner;
>
>
> SID *group;
>
>
> ACL *sacl;
>
>
>
> ACL *dacl;
>
>
>
>} __attribute__((__packed__)) SECURITY_DESCRIPTOR;
>
>
>
>
>
>
>typedef enum {
>
> SECURITY_DESCRIPTOR_REVISION = 1,
> SECURITY_DESCRIPTOR_REVISION1 = 1,
>
>
>
> SECURITY_DESCRIPTOR_MIN_LENGTH = sizeof(SECURITY_DESCRIPTOR),
>} SECURITY_DESCRIPTOR_CONSTANTS;
># 1858 "../include/ntfs-3g/layout.h"
>typedef SECURITY_DESCRIPTOR_RELATIVE SECURITY_DESCRIPTOR_ATTR;
># 1905 "../include/ntfs-3g/layout.h"
>typedef struct {
> u32 hash;
> u32 security_id;
> u64 offset;
> u32 length;
>} __attribute__((__packed__)) SECURITY_DESCRIPTOR_HEADER;
>
>
>
>
>typedef struct {
> u32 hash;
> u32 security_id;
> u64 offset;
> u32 length;
> u32 reserved_II;
>
>} __attribute__((__packed__)) SDH_INDEX_DATA;
>
>
>
>
>typedef SECURITY_DESCRIPTOR_HEADER SII_INDEX_DATA;
># 1942 "../include/ntfs-3g/layout.h"
>typedef struct {
>
>
> u32 hash;
> u32 security_id;
> u64 offset;
> u32 length;
>        SECURITY_DESCRIPTOR_RELATIVE sid;
>
>} __attribute__((__packed__)) SDS_ENTRY;
>
>
>
>
>
>
>typedef struct {
> u32 security_id;
>} __attribute__((__packed__)) SII_INDEX_KEY;
>
>
>
>
>
>
>
>typedef struct {
> u32 hash;
> u32 security_id;
>} __attribute__((__packed__)) SDH_INDEX_KEY;
>
>
>
>
>
>
>
>typedef struct {
> ntfschar name[0];
>} __attribute__((__packed__)) VOLUME_NAME;
>
>
>
>
>typedef enum {
> VOLUME_IS_DIRTY = (0x0001),
> VOLUME_RESIZE_LOG_FILE = (0x0002),
> VOLUME_UPGRADE_ON_MOUNT = (0x0004),
> VOLUME_MOUNTED_ON_NT4 = (0x0008),
> VOLUME_DELETE_USN_UNDERWAY = (0x0010),
> VOLUME_REPAIR_OBJECT_ID = (0x0020),
> VOLUME_CHKDSK_UNDERWAY = (0x4000),
> VOLUME_MODIFIED_BY_CHKDSK = (0x8000),
> VOLUME_FLAGS_MASK = (0xc03f),
>} __attribute__((__packed__)) VOLUME_FLAGS;
># 2006 "../include/ntfs-3g/layout.h"
>typedef struct {
> u64 reserved;
> u8 major_ver;
> u8 minor_ver;
> VOLUME_FLAGS flags;
>} __attribute__((__packed__)) VOLUME_INFORMATION;
># 2020 "../include/ntfs-3g/layout.h"
>typedef struct {
> u8 data[0];
>} __attribute__((__packed__)) DATA_ATTR;
>
>
>
>
>typedef enum {
>
> SMALL_INDEX = 0,
>
>
> LARGE_INDEX = 1,
>
>
>
>
>
>
> LEAF_NODE = 0,
>
> INDEX_NODE = 1,
>
> NODE_MASK = 1,
>} __attribute__((__packed__)) INDEX_HEADER_FLAGS;
># 2057 "../include/ntfs-3g/layout.h"
>typedef struct {
>        u32 entries_offset;
>
>        u32 index_length;
>
>        u32 allocated_size;
># 2073 "../include/ntfs-3g/layout.h"
>        INDEX_HEADER_FLAGS ih_flags;
>        u8 reserved[3];
>
>} __attribute__((__packed__)) INDEX_HEADER;
># 2097 "../include/ntfs-3g/layout.h"
>typedef struct {
>        ATTR_TYPES type;
>
>
>
>        COLLATION_RULES collation_rule;
>
>
>        u32 index_block_size;
>
>        s8 clusters_per_index_block;
>
>
>
>        u8 reserved[3];
>        INDEX_HEADER index;
>
>
>} __attribute__((__packed__)) INDEX_ROOT;
># 2126 "../include/ntfs-3g/layout.h"
>typedef struct {
>
> NTFS_RECORD_TYPES magic;
> u16 usa_ofs;
> u16 usa_count;
>
>        LSN lsn;
>
>        VCN index_block_vcn;
>        INDEX_HEADER index;
># 2146 "../include/ntfs-3g/layout.h"
>} __attribute__((__packed__)) INDEX_BLOCK;
>
>typedef INDEX_BLOCK INDEX_ALLOCATION;
># 2161 "../include/ntfs-3g/layout.h"
>typedef struct {
> u32 reparse_tag;
> MFT_REF file_id;
>
>} __attribute__((__packed__)) REPARSE_INDEX_KEY;
>
>
>
>
>typedef enum {
>
> QUOTA_FLAG_DEFAULT_LIMITS = (0x00000001),
> QUOTA_FLAG_LIMIT_REACHED = (0x00000002),
> QUOTA_FLAG_ID_DELETED = (0x00000004),
>
> QUOTA_FLAG_USER_MASK = (0x00000007),
>
>
>
>
> QUOTA_FLAG_TRACKING_ENABLED = (0x00000010),
> QUOTA_FLAG_ENFORCEMENT_ENABLED = (0x00000020),
> QUOTA_FLAG_TRACKING_REQUESTED = (0x00000040),
> QUOTA_FLAG_LOG_THRESHOLD = (0x00000080),
> QUOTA_FLAG_LOG_LIMIT = (0x00000100),
> QUOTA_FLAG_OUT_OF_DATE = (0x00000200),
> QUOTA_FLAG_CORRUPT = (0x00000400),
> QUOTA_FLAG_PENDING_DELETES = (0x00000800),
>} QUOTA_FLAGS;
># 2214 "../include/ntfs-3g/layout.h"
>typedef struct {
> u32 version;
> QUOTA_FLAGS flags;
> u64 bytes_used;
> s64 change_time;
> s64 threshold;
> s64 limit;
> s64 exceeded_time;
>
> SID sid;
>
>
>
>
>
>
>
>} __attribute__((__packed__)) QUOTA_CONTROL_ENTRY;
>
>
>
>
>typedef struct {
> u32 owner_id;
> u32 unknown;
>
>
>} __attribute__((__packed__)) QUOTA_O_INDEX_DATA;
>
>
>
>
>typedef enum {
> QUOTA_INVALID_ID = (0x00000000),
> QUOTA_DEFAULTS_ID = (0x00000001),
> QUOTA_FIRST_USER_ID = (0x00000100),
>} PREDEFINED_OWNER_IDS;
>
>
>
>
>typedef enum {
> INDEX_ENTRY_NODE = (1),
>
>
>
> INDEX_ENTRY_END = (2),
>
>
>
> INDEX_ENTRY_SPACE_FILLER = 0xffff,
>} __attribute__((__packed__)) INDEX_ENTRY_FLAGS;
># 2274 "../include/ntfs-3g/layout.h"
>typedef struct {
>        union {
>  MFT_REF indexed_file;
>  struct {
>   u16 data_offset;
>   u16 data_length;
>   u32 reservedV;
>  } __attribute__((__packed__));
> } __attribute__((__packed__));
>        u16 length;
>        u16 key_length;
>        INDEX_ENTRY_FLAGS flags;
>        u16 reserved;
>
>} __attribute__((__packed__)) INDEX_ENTRY_HEADER;
># 2299 "../include/ntfs-3g/layout.h"
>typedef struct {
>
> union {
>  MFT_REF indexed_file;
>
>
>
>  struct {
>   u16 data_offset;
>
>
>   u16 data_length;
>   u32 reservedV;
>  } __attribute__((__packed__));
> } __attribute__((__packed__));
>        u16 length;
>
>
>        u16 key_length;
>
>
>        INDEX_ENTRY_FLAGS ie_flags;
>        u16 reserved;
>
>        union {
>
>
>
>
>  FILE_NAME_ATTR file_name;
>  SII_INDEX_KEY sii;
>  SDH_INDEX_KEY sdh;
>  GUID object_id;
>
>
>  REPARSE_INDEX_KEY reparse;
>
>  SID sid;
>
>  u32 owner_id;
>
>
>
> } __attribute__((__packed__)) key;
># 2355 "../include/ntfs-3g/layout.h"
>} __attribute__((__packed__)) INDEX_ENTRY;
># 2367 "../include/ntfs-3g/layout.h"
>typedef struct {
> u8 bitmap[0];
>} __attribute__((__packed__)) BITMAP_ATTR;
># 2391 "../include/ntfs-3g/layout.h"
>typedef enum {
> IO_REPARSE_TAG_IS_ALIAS = (0x20000000),
> IO_REPARSE_TAG_IS_HIGH_LATENCY = (0x40000000),
> IO_REPARSE_TAG_IS_MICROSOFT = (0x80000000),
>
> IO_REPARSE_TAG_RESERVED_ZERO = (0x00000000),
> IO_REPARSE_TAG_RESERVED_ONE = (0x00000001),
> IO_REPARSE_TAG_RESERVED_RANGE = (0x00000001),
>
> IO_REPARSE_TAG_NSS = (0x68000005),
> IO_REPARSE_TAG_NSS_RECOVER = (0x68000006),
> IO_REPARSE_TAG_SIS = (0x68000007),
> IO_REPARSE_TAG_DFS = (0x68000008),
>
> IO_REPARSE_TAG_MOUNT_POINT = (0x88000003),
>
> IO_REPARSE_TAG_HSM = (0xa8000004),
>
> IO_REPARSE_TAG_SYMBOLIC_LINK = (0xe8000000),
>
> IO_REPARSE_TAG_VALID_VALUES = (0xe000ffff),
>} PREDEFINED_REPARSE_TAGS;
>
>
>
>
>
>
>typedef struct {
> u32 reparse_tag;
> u16 reparse_data_length;
> u16 reserved;
> u8 reparse_data[0];
>} __attribute__((__packed__)) REPARSE_POINT;
>
>
>
>
>
>
>typedef struct {
> u16 ea_length;
>
> u16 need_ea_count;
>
> u32 ea_query_length;
>
>
>
>
>} __attribute__((__packed__)) EA_INFORMATION;
>
>
>
>
>typedef enum {
> NEED_EA = 0x80,
>
>
>
>} __attribute__((__packed__)) EA_FLAGS;
># 2462 "../include/ntfs-3g/layout.h"
>typedef struct {
> u32 next_entry_offset;
> EA_FLAGS flags;
> u8 name_length;
>
> u16 value_length;
> u8 name[0];
> u8 value[0];
>
>} __attribute__((__packed__)) EA_ATTR;
>
>
>
>
>
>
>
>typedef struct {
>
>} __attribute__((__packed__)) PROPERTY_SET;
># 2494 "../include/ntfs-3g/layout.h"
>typedef struct {
>
>} __attribute__((__packed__)) LOGGED_UTILITY_STREAM;
># 2530 "../include/ntfs-3g/layout.h"
>typedef struct {
>        u32 length;
> u32 state;
> u32 version;
> u32 crypto_api_version;
>        u8 unknown4[16];
>
>
>
>
>        u8 unknown5[16];
>        u8 unknown6[16];
>        u32 offset_to_ddf_array;
>
>
> u32 offset_to_drf_array;
>
>
> u32 reserved;
>} __attribute__((__packed__)) EFS_ATTR_HEADER;
>
>
>
>
>typedef struct {
> u32 df_count;
>
>} __attribute__((__packed__)) EFS_DF_ARRAY_HEADER;
>
>
>
>
>typedef struct {
>        u32 df_length;
>
> u32 cred_header_offset;
> u32 fek_size;
>
> u32 fek_offset;
>
>        u32 unknown1;
>} __attribute__((__packed__)) EFS_DF_HEADER;
>
>
>
>
>typedef struct {
>        u32 cred_length;
> u32 sid_offset;
>
>
>        u32 type;
>
>
>
>
> union {
>
>  struct {
>          u32 container_name_offset;
>
>
>          u32 provider_name_offset;
>
>
>   u32 public_key_blob_offset;
>
>
>          u32 public_key_blob_size;
>
>  } __attribute__((__packed__));
>
>  struct {
>          u32 cert_thumbprint_header_size;
>
>
>          u32 cert_thumbprint_header_offset;
>
>
>   u32 unknown1;
>   u32 unknown2;
>  } __attribute__((__packed__));
> } __attribute__((__packed__));
>} __attribute__((__packed__)) EFS_DF_CREDENTIAL_HEADER;
>
>typedef EFS_DF_CREDENTIAL_HEADER EFS_DF_CRED_HEADER;
>
>
>
>
>typedef struct {
>        u32 thumbprint_offset;
> u32 thumbprint_size;
>        u32 container_name_offset;
>
>
> u32 provider_name_offset;
>
>
>
>        u32 user_name_offset;
>
>
>
>} __attribute__((__packed__)) EFS_DF_CERTIFICATE_THUMBPRINT_HEADER;
>
>typedef EFS_DF_CERTIFICATE_THUMBPRINT_HEADER EFS_DF_CERT_THUMBPRINT_HEADER;
>
>typedef enum {
> INTX_SYMBOLIC_LINK =
>  (0x014B4E4C78746E49ULL),
> INTX_CHARACTER_DEVICE =
>  (0x0052484378746E49ULL),
> INTX_BLOCK_DEVICE =
>  (0x004B4C4278746E49ULL),
>} INTX_FILE_TYPES;
>
>typedef struct {
> INTX_FILE_TYPES magic;
> union {
>
>  struct {
>   u64 major;
>   u64 minor;
>   void *device_end[0];
>  } __attribute__((__packed__));
>
>  ntfschar target[0];
> } __attribute__((__packed__));
>} __attribute__((__packed__)) INTX_FILE;
># 33 "../include/ntfs-3g/inode.h" 2
>
># 1 "../include/ntfs-3g/volume.h" 1
># 29 "../include/ntfs-3g/volume.h"
># 1 "../config.h" 1
># 30 "../include/ntfs-3g/volume.h" 2
># 39 "../include/ntfs-3g/volume.h"
># 1 "/usr/include/sys/mount.h" 1 3 4
># 26 "/usr/include/sys/mount.h" 3 4
># 1 "/usr/include/sys/ioctl.h" 1 3 4
># 24 "/usr/include/sys/ioctl.h" 3 4
>
>
>
># 1 "/usr/include/bits/ioctls.h" 1 3 4
># 24 "/usr/include/bits/ioctls.h" 3 4
># 1 "/usr/include/asm/ioctls.h" 1 3 4
>
>
>
># 1 "/usr/include/asm/ioctl.h" 1 3 4
># 1 "/usr/include/asm-generic/ioctl.h" 1 3 4
># 51 "/usr/include/asm-generic/ioctl.h" 3 4
>extern unsigned int __invalid_size_argument_for_IOC;
># 1 "/usr/include/asm/ioctl.h" 2 3 4
># 5 "/usr/include/asm/ioctls.h" 2 3 4
># 25 "/usr/include/bits/ioctls.h" 2 3 4
># 28 "/usr/include/sys/ioctl.h" 2 3 4
>
>
># 1 "/usr/include/bits/ioctl-types.h" 1 3 4
># 28 "/usr/include/bits/ioctl-types.h" 3 4
>struct winsize
>  {
>    unsigned short int ws_row;
>    unsigned short int ws_col;
>    unsigned short int ws_xpixel;
>    unsigned short int ws_ypixel;
>  };
>
>
>struct termio
>  {
>    unsigned short int c_iflag;
>    unsigned short int c_oflag;
>    unsigned short int c_cflag;
>    unsigned short int c_lflag;
>    unsigned char c_line;
>    unsigned char c_cc[8];
>};
># 31 "/usr/include/sys/ioctl.h" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/sys/ttydefaults.h" 1 3 4
># 38 "/usr/include/sys/ioctl.h" 2 3 4
>
>
>
>
>extern int ioctl (int __fd, unsigned long int __request, ...) __attribute__ ((__nothrow__));
>
>
># 27 "/usr/include/sys/mount.h" 2 3 4
>
>
>
>
>
>
>
>enum
>{
>  MS_RDONLY = 1,
>
>  MS_NOSUID = 2,
>
>  MS_NODEV = 4,
>
>  MS_NOEXEC = 8,
>
>  MS_SYNCHRONOUS = 16,
>
>  MS_REMOUNT = 32,
>
>  MS_MANDLOCK = 64,
>
>  S_WRITE = 128,
>
>  S_APPEND = 256,
>
>  S_IMMUTABLE = 512,
>
>  MS_NOATIME = 1024,
>
>  MS_NODIRATIME = 2048,
>
>  MS_BIND = 4096,
>
>};
># 97 "/usr/include/sys/mount.h" 3 4
>enum
>{
>  MNT_FORCE = 1
>
>};
>
>
>
>
>
>extern int mount (__const char *__special_file, __const char *__dir,
>    __const char *__fstype, unsigned long int __rwflag,
>    __const void *__data) __attribute__ ((__nothrow__));
>
>
>extern int umount (__const char *__special_file) __attribute__ ((__nothrow__));
>
>
>extern int umount2 (__const char *__special_file, int __flags) __attribute__ ((__nothrow__));
>
>
># 40 "../include/ntfs-3g/volume.h" 2
>
>
># 1 "/usr/include/mntent.h" 1 3 4
># 26 "/usr/include/mntent.h" 3 4
># 1 "/usr/include/paths.h" 1 3 4
># 27 "/usr/include/mntent.h" 2 3 4
># 51 "/usr/include/mntent.h" 3 4
>
>
>
>struct mntent
>  {
>    char *mnt_fsname;
>    char *mnt_dir;
>    char *mnt_type;
>    char *mnt_opts;
>    int mnt_freq;
>    int mnt_passno;
>  };
>
>
>
>
>extern FILE *setmntent (__const char *__file, __const char *__mode) __attribute__ ((__nothrow__));
>
>
>
>
>extern struct mntent *getmntent (FILE *__stream) __attribute__ ((__nothrow__));
>
>
>
>extern struct mntent *getmntent_r (FILE *__restrict __stream,
>       struct mntent *__restrict __result,
>       char *__restrict __buffer,
>       int __bufsize) __attribute__ ((__nothrow__));
>
>
>
>
>extern int addmntent (FILE *__restrict __stream,
>        __const struct mntent *__restrict __mnt) __attribute__ ((__nothrow__));
>
>
>extern int endmntent (FILE *__stream) __attribute__ ((__nothrow__));
>
>
>
>extern char *hasmntopt (__const struct mntent *__mnt,
>   __const char *__opt) __attribute__ ((__nothrow__));
>
>
>
># 43 "../include/ntfs-3g/volume.h" 2
># 60 "../include/ntfs-3g/volume.h"
>typedef struct _ntfs_volume ntfs_volume;
>
>
>
># 1 "../include/ntfs-3g/device.h" 1
># 26 "../include/ntfs-3g/device.h"
># 1 "../config.h" 1
># 27 "../include/ntfs-3g/device.h" 2
>
>
># 1 "../include/ntfs-3g/device_io.h" 1
># 26 "../include/ntfs-3g/device_io.h"
># 1 "../config.h" 1
># 27 "../include/ntfs-3g/device_io.h" 2
># 70 "../include/ntfs-3g/device_io.h"
>struct ntfs_device_operations;
>
>extern struct ntfs_device_operations ntfs_device_unix_io_ops;
># 30 "../include/ntfs-3g/device.h" 2
>
>
># 1 "../include/ntfs-3g/volume.h" 1
># 33 "../include/ntfs-3g/device.h" 2
>
>
>
>
>
>
>typedef enum {
> ND_Open,
> ND_ReadOnly,
> ND_Dirty,
> ND_Block,
>} ntfs_device_state_bits;
># 72 "../include/ntfs-3g/device.h"
>struct ntfs_device {
> struct ntfs_device_operations *d_ops;
> unsigned long d_state;
> char *d_name;
> void *d_private;
>
>};
>
>struct stat;
>
>
>
>
>
>
>
>struct ntfs_device_operations {
> int (*open)(struct ntfs_device *dev, int flags);
> int (*close)(struct ntfs_device *dev);
> s64 (*seek)(struct ntfs_device *dev, s64 offset, int whence);
> s64 (*read)(struct ntfs_device *dev, void *buf, s64 count);
> s64 (*write)(struct ntfs_device *dev, const void *buf, s64 count);
> s64 (*pread)(struct ntfs_device *dev, void *buf, s64 count, s64 offset);
> s64 (*pwrite)(struct ntfs_device *dev, const void *buf, s64 count,
>   s64 offset);
> int (*sync)(struct ntfs_device *dev);
> int (*stat)(struct ntfs_device *dev, struct stat *buf);
> int (*ioctl)(struct ntfs_device *dev, int request, void *argp);
>};
>
>extern struct ntfs_device *ntfs_device_alloc(const char *name, const long state,
>  struct ntfs_device_operations *dops, void *priv_data);
>extern int ntfs_device_free(struct ntfs_device *dev);
>
>extern s64 ntfs_pread(struct ntfs_device *dev, const s64 pos, s64 count,
>  void *b);
>extern s64 ntfs_pwrite(struct ntfs_device *dev, const s64 pos, s64 count,
>  const void *b);
>
>extern s64 ntfs_mst_pread(struct ntfs_device *dev, const s64 pos, s64 count,
>  const u32 bksize, void *b);
>extern s64 ntfs_mst_pwrite(struct ntfs_device *dev, const s64 pos, s64 count,
>  const u32 bksize, void *b);
>
>extern s64 ntfs_cluster_read(const ntfs_volume *vol, const s64 lcn,
>  const s64 count, void *b);
>extern s64 ntfs_cluster_write(const ntfs_volume *vol, const s64 lcn,
>  const s64 count, const void *b);
>
>extern s64 ntfs_device_size_get(struct ntfs_device *dev, int block_size);
>extern s64 ntfs_device_partition_start_sector_get(struct ntfs_device *dev);
>extern int ntfs_device_heads_get(struct ntfs_device *dev);
>extern int ntfs_device_sectors_per_track_get(struct ntfs_device *dev);
>extern int ntfs_device_sector_size_get(struct ntfs_device *dev);
>extern int ntfs_device_block_size_set(struct ntfs_device *dev, int block_size);
># 65 "../include/ntfs-3g/volume.h" 2
># 1 "../include/ntfs-3g/inode.h" 1
># 66 "../include/ntfs-3g/volume.h" 2
># 1 "../include/ntfs-3g/attrib.h" 1
># 67 "../include/ntfs-3g/volume.h" 2
>
>
>
>
>
>
>typedef enum {
> NTFS_MF_MOUNTED = 1,
> NTFS_MF_ISROOT = 2,
> NTFS_MF_READONLY = 4,
>} ntfs_mount_flags;
>
>extern int ntfs_check_if_mounted(const char *file, unsigned long *mnt_flags);
>
>typedef enum {
> NTFS_VOLUME_OK = 0,
> NTFS_VOLUME_SYNTAX_ERROR = 11,
> NTFS_VOLUME_NOT_NTFS = 12,
> NTFS_VOLUME_CORRUPT = 13,
> NTFS_VOLUME_HIBERNATED = 14,
> NTFS_VOLUME_UNCLEAN_UNMOUNT = 15,
> NTFS_VOLUME_LOCKED = 16,
> NTFS_VOLUME_RAID = 17,
> NTFS_VOLUME_UNKNOWN_REASON = 18,
> NTFS_VOLUME_NO_PRIVILEGE = 19,
> NTFS_VOLUME_OUT_OF_MEMORY = 20,
> NTFS_VOLUME_FUSE_ERROR = 21
>} ntfs_volume_status;
>
>
>
>
>
>
>typedef enum {
> NV_ReadOnly,
> NV_CaseSensitive,
> NV_LogFileEmpty,
>} ntfs_volume_state_bits;
># 141 "../include/ntfs-3g/volume.h"
>struct _ntfs_volume {
> union {
>  struct ntfs_device *dev;
>
>  void *sb;
> };
> char *vol_name;
> unsigned long state;
>
>
> ntfs_inode *vol_ni;
> u8 major_ver;
> u8 minor_ver;
> u16 flags;
>
> u16 sector_size;
> u8 sector_size_bits;
> u32 cluster_size;
> u32 mft_record_size;
> u32 indx_record_size;
> u8 cluster_size_bits;
> u8 mft_record_size_bits;
> u8 indx_record_size_bits;
>
>
> u8 mft_zone_multiplier;
> s64 mft_data_pos;
>
> LCN mft_zone_start;
> LCN mft_zone_end;
> LCN mft_zone_pos;
> LCN data1_zone_pos;
> LCN data2_zone_pos;
>
> s64 nr_clusters;
>
> ntfs_inode *lcnbmp_ni;
> ntfs_attr *lcnbmp_na;
>
>
>
>
>
> LCN mft_lcn;
>
> ntfs_inode *mft_ni;
> ntfs_attr *mft_na;
>
> ntfs_attr *mftbmp_na;
>
>
>
>
>
>
> int mftmirr_size;
> LCN mftmirr_lcn;
>
> ntfs_inode *mftmirr_ni;
> ntfs_attr *mftmirr_na;
>
>
> ntfschar *upcase;
>
>
> u32 upcase_len;
>
>
> ATTR_DEF *attrdef;
>
> s32 attrdef_len;
>
>
> s64 free_clusters;
>
> s64 free_mft_records;
>
>
> void *private_data;
> void *private_bmp1;
> void *private_bmp2;
>};
>
>extern ntfs_volume *ntfs_volume_alloc(void);
>
>extern ntfs_volume *ntfs_volume_startup(struct ntfs_device *dev,
>  unsigned long flags);
>
>extern ntfs_volume *ntfs_device_mount(struct ntfs_device *dev,
>  unsigned long flags);
>
>extern ntfs_volume *ntfs_mount(const char *name, unsigned long flags);
>extern int ntfs_umount(ntfs_volume *vol, const BOOL force);
>
>extern int ntfs_version_is_supported(ntfs_volume *vol);
>extern int ntfs_logfile_reset(ntfs_volume *vol);
>
>extern int ntfs_volume_write_flags(ntfs_volume *vol, const u16 flags);
>
>extern int ntfs_volume_error(int err);
># 35 "../include/ntfs-3g/inode.h" 2
>
>
>
>
>
>
>
>typedef enum {
> NI_Dirty,
>
>
> NI_AttrList,
> NI_AttrListDirty,
>
> NI_FileNameDirty,
>
>} ntfs_inode_state_bits;
># 102 "../include/ntfs-3g/inode.h"
>struct _ntfs_inode {
> u64 mft_no;
> MFT_RECORD *mrec;
> ntfs_volume *vol;
> unsigned long state;
>
> FILE_ATTR_FLAGS flags;
>
>
>
>
>
>
> u32 attr_list_size;
> u8 *attr_list;
>
> s32 nr_extents;
>
>
> union {
>  ntfs_inode **extent_nis;
>
>
>
>  ntfs_inode *base_ni;
>
> };
>
>
> void *private_data;
> int ref_count;
>
>
> s64 data_size;
> s64 allocated_size;
>
>
>
>
>
>
> time_t creation_time;
> time_t last_data_change_time;
> time_t last_mft_change_time;
> time_t last_access_time;
>};
>
>typedef enum {
> NTFS_UPDATE_ATIME = 1 << 0,
> NTFS_UPDATE_MTIME = 1 << 1,
> NTFS_UPDATE_CTIME = 1 << 2,
>} ntfs_time_update_flags;
>
>
>
>
>extern ntfs_inode *ntfs_inode_base(ntfs_inode *ni);
>
>extern ntfs_inode *ntfs_inode_allocate(ntfs_volume *vol);
>
>extern ntfs_inode *ntfs_inode_open(ntfs_volume *vol, const MFT_REF mref);
>
>extern int ntfs_inode_close(ntfs_inode *ni);
>
>extern ntfs_inode *ntfs_extent_inode_open(ntfs_inode *base_ni,
>  const MFT_REF mref);
>
>extern int ntfs_inode_attach_all_extents(ntfs_inode *ni);
>
>extern void ntfs_inode_mark_dirty(ntfs_inode *ni);
>
>extern void ntfs_inode_update_times(ntfs_inode *ni, ntfs_time_update_flags mask);
>
>extern int ntfs_inode_sync(ntfs_inode *ni);
>
>extern int ntfs_inode_add_attrlist(ntfs_inode *ni);
>
>extern int ntfs_inode_free_space(ntfs_inode *ni, int size);
>
>extern int ntfs_inode_badclus_bad(u64 mft_no, ATTR_RECORD *a);
># 33 "../include/ntfs-3g/attrib.h" 2
># 1 "../include/ntfs-3g/unistr.h" 1
># 29 "../include/ntfs-3g/unistr.h"
>extern BOOL ntfs_names_are_equal(const ntfschar *s1, size_t s1_len,
>  const ntfschar *s2, size_t s2_len, const IGNORE_CASE_BOOL ic,
>  const ntfschar *upcase, const u32 upcase_size);
>
>extern int ntfs_names_collate(const ntfschar *name1, const u32 name1_len,
>  const ntfschar *name2, const u32 name2_len,
>  const int err_val, const IGNORE_CASE_BOOL ic,
>  const ntfschar *upcase, const u32 upcase_len);
>
>extern int ntfs_ucsncmp(const ntfschar *s1, const ntfschar *s2, size_t n);
>
>extern int ntfs_ucsncasecmp(const ntfschar *s1, const ntfschar *s2, size_t n,
>  const ntfschar *upcase, const u32 upcase_size);
>
>extern u32 ntfs_ucsnlen(const ntfschar *s, u32 maxlen);
>
>extern ntfschar *ntfs_ucsndup(const ntfschar *s, u32 maxlen);
>
>extern void ntfs_name_upcase(ntfschar *name, u32 name_len,
>  const ntfschar *upcase, const u32 upcase_len);
>
>extern void ntfs_file_value_upcase(FILE_NAME_ATTR *file_name_attr,
>  const ntfschar *upcase, const u32 upcase_len);
>
>extern int ntfs_file_values_compare(const FILE_NAME_ATTR *file_name_attr1,
>  const FILE_NAME_ATTR *file_name_attr2,
>  const int err_val, const IGNORE_CASE_BOOL ic,
>  const ntfschar *upcase, const u32 upcase_len);
>
>extern int ntfs_ucstombs(const ntfschar *ins, const int ins_len, char **outs,
>  int outs_len);
>extern int ntfs_mbstoucs(const char *ins, ntfschar **outs, int outs_len);
>
>extern void ntfs_upcase_table_build(ntfschar *uc, u32 uc_len);
>
>extern ntfschar *ntfs_str2ucs(const char *s, int *len);
>
>extern void ntfs_ucsfree(ntfschar *ucs);
># 34 "../include/ntfs-3g/attrib.h" 2
># 1 "../include/ntfs-3g/runlist.h" 1
># 29 "../include/ntfs-3g/runlist.h"
>typedef struct _runlist_element runlist_element;
>typedef runlist_element runlist;
># 46 "../include/ntfs-3g/runlist.h"
>struct _runlist_element {
> VCN vcn;
> LCN lcn;
> s64 length;
>};
>
>extern LCN ntfs_rl_vcn_to_lcn(const runlist_element *rl, const VCN vcn);
>
>extern s64 ntfs_rl_pread(const ntfs_volume *vol, const runlist_element *rl,
>  const s64 pos, s64 count, void *b);
>extern s64 ntfs_rl_pwrite(const ntfs_volume *vol, const runlist_element *rl,
>  const s64 pos, s64 count, void *b);
>
>extern runlist_element *ntfs_runlists_merge(runlist_element *drl,
>  runlist_element *srl);
>
>extern runlist_element *ntfs_mapping_pairs_decompress(const ntfs_volume *vol,
>  const ATTR_RECORD *attr, runlist_element *old_rl);
>
>extern int ntfs_get_nr_significant_bytes(const s64 n);
>
>extern int ntfs_get_size_for_mapping_pairs(const ntfs_volume *vol,
>  const runlist_element *rl, const VCN start_vcn);
>
>extern int ntfs_write_significant_bytes(u8 *dst, const u8 *dst_max,
>  const s64 n);
>
>extern int ntfs_mapping_pairs_build(const ntfs_volume *vol, u8 *dst,
>  const int dst_len, const runlist_element *rl,
>  const VCN start_vcn, VCN *const stop_vcn);
>
>extern int ntfs_rl_truncate(runlist **arl, const VCN start_vcn);
>
>extern int ntfs_rl_sparse(runlist *rl);
>extern s64 ntfs_rl_get_compressed_size(ntfs_volume *vol, runlist *rl);
># 35 "../include/ntfs-3g/attrib.h" 2
>
># 1 "../include/ntfs-3g/debug.h" 1
># 26 "../include/ntfs-3g/debug.h"
># 1 "../config.h" 1
># 27 "../include/ntfs-3g/debug.h" 2
>
>
># 1 "../include/ntfs-3g/logging.h" 1
># 26 "../include/ntfs-3g/logging.h"
># 1 "../config.h" 1
># 27 "../include/ntfs-3g/logging.h" 2
>
>
>
># 1 "/usr/lib64/gcc/x86_64-suse-linux/4.3/include/stdarg.h" 1 3 4
># 31 "../include/ntfs-3g/logging.h" 2
>
>
>
>
>
>typedef int (ntfs_log_handler)(const char *function, const char *file, int line,
> u32 level, void *data, const char *format, va_list args);
>
>
>void ntfs_log_set_handler(ntfs_log_handler *handler
>     __attribute__((format(printf, 6, 0))));
>
>
>ntfs_log_handler ntfs_log_handler_syslog __attribute__((format(printf, 6, 0)));
>ntfs_log_handler ntfs_log_handler_fprintf __attribute__((format(printf, 6, 0)));
>ntfs_log_handler ntfs_log_handler_null __attribute__((format(printf, 6, 0)));
>ntfs_log_handler ntfs_log_handler_stdout __attribute__((format(printf, 6, 0)));
>ntfs_log_handler ntfs_log_handler_outerr __attribute__((format(printf, 6, 0)));
>ntfs_log_handler ntfs_log_handler_stderr __attribute__((format(printf, 6, 0)));
>
>
>u32 ntfs_log_set_levels(u32 levels);
>u32 ntfs_log_clear_levels(u32 levels);
>u32 ntfs_log_get_levels(void);
>
>
>u32 ntfs_log_set_flags(u32 flags);
>u32 ntfs_log_clear_flags(u32 flags);
>u32 ntfs_log_get_flags(void);
>
>
>BOOL ntfs_log_parse_option(const char *option);
>
>int ntfs_log_redirect(const char *function, const char *file, int line,
> u32 level, void *data, const char *format, ...)
> __attribute__((format(printf, 6, 7)));
># 30 "../include/ntfs-3g/debug.h" 2
>
>struct _runlist_element;
>
>
>
>
>static __inline__ void ntfs_debug_runlist_dump(const struct _runlist_element *rl __attribute__((unused))) {}
># 37 "../include/ntfs-3g/attrib.h" 2
>
>
>extern ntfschar AT_UNNAMED[];
># 48 "../include/ntfs-3g/attrib.h"
>typedef enum {
> LCN_HOLE = -1,
> LCN_RL_NOT_MAPPED = -2,
> LCN_ENOENT = -3,
> LCN_EINVAL = -4,
> LCN_EIO = -5,
>} ntfs_lcn_special_values;
># 74 "../include/ntfs-3g/attrib.h"
>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_attr_reinit_search_ctx(ntfs_attr_search_ctx *ctx);
>extern ntfs_attr_search_ctx *ntfs_attr_get_search_ctx(ntfs_inode *ni,
>  MFT_RECORD *mrec);
>extern void ntfs_attr_put_search_ctx(ntfs_attr_search_ctx *ctx);
>
>extern int ntfs_attr_lookup(const ATTR_TYPES type, const ntfschar *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);
>
>extern ATTR_DEF *ntfs_attr_find_in_attrdef(const ntfs_volume *vol,
>  const ATTR_TYPES type);
># 123 "../include/ntfs-3g/attrib.h"
>static __inline__ int ntfs_attrs_walk(ntfs_attr_search_ctx *ctx)
>{
> return ntfs_attr_lookup(AT_UNUSED, ((void *)0), 0, CASE_SENSITIVE, 0,
>   ((void *)0), 0, ctx);
>}
># 171 "../include/ntfs-3g/attrib.h"
>struct _ntfs_attr {
> runlist_element *rl;
> ntfs_inode *ni;
> ATTR_TYPES type;
> ntfschar *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;
>};
>
>
>
>
>typedef enum {
> NA_Initialized,
> NA_NonResident,
>} ntfs_attr_state_bits;
># 212 "../include/ntfs-3g/attrib.h"
>extern int NAttrCompressed(ntfs_attr *na); extern void NAttrSetCompressed(ntfs_attr *na); extern void NAttrClearCompressed(ntfs_attr *na);
>extern int NAttrEncrypted(ntfs_attr *na); extern void NAttrSetEncrypted(ntfs_attr *na); extern void NAttrClearEncrypted(ntfs_attr *na);
>extern int NAttrSparse(ntfs_attr *na); extern void NAttrSetSparse(ntfs_attr *na); extern void NAttrClearSparse(ntfs_attr *na);
>
>
>
>
>
>
>
>typedef union {
> u8 _default;
>
> 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_HEADER 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,
>  ntfschar *name, 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,
>  const void *b);
>
>extern void *ntfs_attr_readall(ntfs_inode *ni, const ATTR_TYPES type,
>          ntfschar *name, u32 name_len, s64 *data_size);
>
>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_runlist(ntfs_attr *na, VCN vcn);
>extern int ntfs_attr_map_whole_runlist(ntfs_attr *na);
>
>extern LCN ntfs_attr_vcn_to_lcn(ntfs_attr *na, const VCN vcn);
>extern runlist_element *ntfs_attr_find_vcn(ntfs_attr *na, const VCN vcn);
>
>extern int ntfs_attr_size_bounds_check(const ntfs_volume *vol,
>  const ATTR_TYPES type, const s64 size);
>extern int ntfs_attr_can_be_non_resident(const ntfs_volume *vol,
>  const ATTR_TYPES type);
>extern int ntfs_attr_can_be_resident(const ntfs_volume *vol,
>  const ATTR_TYPES type);
>
>extern int ntfs_make_room_for_attr(MFT_RECORD *m, u8 *pos, u32 size);
>
>extern int ntfs_resident_attr_record_add(ntfs_inode *ni, ATTR_TYPES type,
>  ntfschar *name, u8 name_len, u8 *val, u32 size,
>  ATTR_FLAGS flags);
>extern int ntfs_non_resident_attr_record_add(ntfs_inode *ni, ATTR_TYPES type,
>  ntfschar *name, u8 name_len, VCN lowest_vcn, int dataruns_size,
>  ATTR_FLAGS flags);
>extern int ntfs_attr_record_rm(ntfs_attr_search_ctx *ctx);
>
>extern int ntfs_attr_add(ntfs_inode *ni, ATTR_TYPES type,
>  ntfschar *name, u8 name_len, u8 *val, s64 size);
>extern int ntfs_attr_rm(ntfs_attr *na);
>
>extern int ntfs_attr_record_resize(MFT_RECORD *m, ATTR_RECORD *a, u32 new_size);
>
>extern int ntfs_resident_attr_value_resize(MFT_RECORD *m, ATTR_RECORD *a,
>  const u32 new_size);
>
>extern int ntfs_attr_record_move_to(ntfs_attr_search_ctx *ctx, ntfs_inode *ni);
>extern int ntfs_attr_record_move_away(ntfs_attr_search_ctx *ctx, int extra);
>
>extern int ntfs_attr_update_mapping_pairs(ntfs_attr *na, VCN from_vcn);
>
>extern int ntfs_attr_truncate(ntfs_attr *na, const s64 newsize);
># 317 "../include/ntfs-3g/attrib.h"
>extern s64 ntfs_get_attribute_value_length(const ATTR_RECORD *a);
># 333 "../include/ntfs-3g/attrib.h"
>extern s64 ntfs_get_attribute_value(const ntfs_volume *vol,
>        const ATTR_RECORD *a, u8 *b);
>
>extern void ntfs_attr_name_free(char **name);
>extern char *ntfs_attr_name_get(const ntfschar *uname, const int uname_len);
>extern int ntfs_attr_exist(ntfs_inode *ni, const ATTR_TYPES type,
>        ntfschar *name, u32 name_len);
>extern int ntfs_attr_remove(ntfs_inode *ni, const ATTR_TYPES type,
>         ntfschar *name, u32 name_len);
>extern s64 ntfs_attr_get_free_bits(ntfs_attr *na);
># 44 "attrib.c" 2
># 1 "../include/ntfs-3g/attrlist.h" 1
># 29 "../include/ntfs-3g/attrlist.h"
>extern int ntfs_attrlist_need(ntfs_inode *ni);
>
>extern int ntfs_attrlist_entry_add(ntfs_inode *ni, ATTR_RECORD *attr);
>extern int ntfs_attrlist_entry_rm(ntfs_attr_search_ctx *ctx);
># 43 "../include/ntfs-3g/attrlist.h"
>static __inline__ void ntfs_attrlist_mark_dirty(ntfs_inode *ni)
>{
> if (ni->nr_extents == -1)
>  ((ni->base_ni)->state) |= 1 << (NI_AttrListDirty);
> else
>  ((ni)->state) |= 1 << (NI_AttrListDirty);
>}
># 45 "attrib.c" 2
># 1 "../include/ntfs-3g/device.h" 1
># 46 "attrib.c" 2
># 1 "../include/ntfs-3g/mft.h" 1
># 31 "../include/ntfs-3g/mft.h"
>extern int ntfs_mft_records_read(const ntfs_volume *vol, const MFT_REF mref,
>  const s64 count, MFT_RECORD *b);
># 49 "../include/ntfs-3g/mft.h"
>static __inline__ int ntfs_mft_record_read(const ntfs_volume *vol,
>  const MFT_REF mref, MFT_RECORD *b)
>{
> return ntfs_mft_records_read(vol, mref, 1, b);
>}
>
>extern int ntfs_file_record_read(const ntfs_volume *vol, const MFT_REF mref,
>  MFT_RECORD **mrec, ATTR_RECORD **attr);
>
>extern int ntfs_mft_records_write(const ntfs_volume *vol, const MFT_REF mref,
>  const s64 count, MFT_RECORD *b);
># 76 "../include/ntfs-3g/mft.h"
>static __inline__ int ntfs_mft_record_write(const ntfs_volume *vol,
>  const MFT_REF mref, MFT_RECORD *b)
>{
> return ntfs_mft_records_write(vol, mref, 1, b);
>}
># 98 "../include/ntfs-3g/mft.h"
>static __inline__ u32 ntfs_mft_record_get_data_size(const MFT_RECORD *m)
>{
> if (!m || !( ( ( (u32)(m->magic) == (u32)magic_FILE ) ) ))
>  return 0;
>
> return (u32)((u32)(m->bytes_in_use));
>}
>
>extern int ntfs_mft_record_layout(const ntfs_volume *vol, const MFT_REF mref,
>  MFT_RECORD *mrec);
>
>extern int ntfs_mft_record_format(const ntfs_volume *vol, const MFT_REF mref);
>
>extern ntfs_inode *ntfs_mft_record_alloc(ntfs_volume *vol, ntfs_inode *base_ni);
>
>extern int ntfs_mft_record_free(ntfs_volume *vol, ntfs_inode *ni);
>
>extern int ntfs_mft_usn_dec(MFT_RECORD *mrec);
># 47 "attrib.c" 2
># 1 "../include/ntfs-3g/debug.h" 1
># 48 "attrib.c" 2
># 1 "../include/ntfs-3g/mst.h" 1
># 29 "../include/ntfs-3g/mst.h"
>extern int ntfs_mst_post_read_fixup(NTFS_RECORD *b, const u32 size);
>extern int ntfs_mst_pre_write_fixup(NTFS_RECORD *b, const u32 size);
>extern void ntfs_mst_post_write_fixup(NTFS_RECORD *b);
># 49 "attrib.c" 2
># 1 "../include/ntfs-3g/volume.h" 1
># 50 "attrib.c" 2
># 1 "../include/ntfs-3g/types.h" 1
># 51 "attrib.c" 2
># 1 "../include/ntfs-3g/layout.h" 1
># 52 "attrib.c" 2
># 1 "../include/ntfs-3g/inode.h" 1
># 53 "attrib.c" 2
># 1 "../include/ntfs-3g/runlist.h" 1
># 54 "attrib.c" 2
># 1 "../include/ntfs-3g/lcnalloc.h" 1
># 34 "../include/ntfs-3g/lcnalloc.h"
>typedef enum {
> FIRST_ZONE = 0,
> MFT_ZONE = 0,
> DATA_ZONE = 1,
> LAST_ZONE = 1,
>} NTFS_CLUSTER_ALLOCATION_ZONES;
>
>extern runlist *ntfs_cluster_alloc(ntfs_volume *vol, VCN start_vcn, s64 count,
>  LCN start_lcn, const NTFS_CLUSTER_ALLOCATION_ZONES zone);
>
>extern int ntfs_cluster_free_from_rl(ntfs_volume *vol, runlist *rl);
>
>extern int ntfs_cluster_free(ntfs_volume *vol, ntfs_attr *na, VCN start_vcn,
>  s64 count);
># 55 "attrib.c" 2
># 1 "../include/ntfs-3g/dir.h" 1
># 58 "../include/ntfs-3g/dir.h"
>extern ntfschar NTFS_INDEX_I30[5];
>extern ntfschar NTFS_INDEX_SII[5];
>extern ntfschar NTFS_INDEX_SDH[5];
>extern ntfschar NTFS_INDEX_O[3];
>extern ntfschar NTFS_INDEX_Q[3];
>extern ntfschar NTFS_INDEX_R[3];
>
>extern u64 ntfs_inode_lookup_by_name(ntfs_inode *dir_ni,
>  const ntfschar *uname, const int uname_len);
>
>extern ntfs_inode *ntfs_pathname_to_inode(ntfs_volume *vol, ntfs_inode *parent,
>  const char *pathname);
>
>extern ntfs_inode *ntfs_create(ntfs_inode *dir_ni, ntfschar *name, u8 name_len,
>  dev_t type);
>extern ntfs_inode *ntfs_create_device(ntfs_inode *dir_ni,
>  ntfschar *name, u8 name_len, dev_t type, dev_t dev);
>extern ntfs_inode *ntfs_create_symlink(ntfs_inode *dir_ni,
>  ntfschar *name, u8 name_len, ntfschar *target, u8 target_len);
>extern int ntfs_check_empty_dir(ntfs_inode *ni);
>extern int ntfs_delete(ntfs_inode *ni, ntfs_inode *dir_ni, ntfschar *name,
>  u8 name_len);
>
>extern int ntfs_link(ntfs_inode *ni, ntfs_inode *dir_ni, ntfschar *name,
>  u8 name_len);
># 103 "../include/ntfs-3g/dir.h"
>typedef int (*ntfs_filldir_t)(void *dirent, const ntfschar *name,
>  const int name_len, const int name_type, const s64 pos,
>  const MFT_REF mref, const unsigned dt_type);
>
>extern int ntfs_readdir(ntfs_inode *dir_ni, s64 *pos,
>  void *dirent, ntfs_filldir_t filldir);
># 56 "attrib.c" 2
># 1 "../include/ntfs-3g/compress.h" 1
># 29 "../include/ntfs-3g/compress.h"
>extern s64 ntfs_compressed_attr_pread(ntfs_attr *na, s64 pos, s64 count,
>  void *b);
># 57 "attrib.c" 2
># 1 "../include/ntfs-3g/bitmap.h" 1
># 39 "../include/ntfs-3g/bitmap.h"
>extern void ntfs_bit_set(u8 *bitmap, const u64 bit, const u8 new_value);
>extern char ntfs_bit_get(const u8 *bitmap, const u64 bit);
>extern char ntfs_bit_get_and_set(u8 *bitmap, const u64 bit, const u8 new_value);
>extern int ntfs_bitmap_set_run(ntfs_attr *na, s64 start_bit, s64 count);
>extern int ntfs_bitmap_clear_run(ntfs_attr *na, s64 start_bit, s64 count);
># 54 "../include/ntfs-3g/bitmap.h"
>static __inline__ int ntfs_bitmap_set_bit(ntfs_attr *na, s64 bit)
>{
> return ntfs_bitmap_set_run(na, bit, 1);
>}
># 68 "../include/ntfs-3g/bitmap.h"
>static __inline__ int ntfs_bitmap_clear_bit(ntfs_attr *na, s64 bit)
>{
> return ntfs_bitmap_clear_run(na, bit, 1);
>}
>
>
>
>
>
>
>
>static __inline__ u32 ntfs_rol32(u32 word, unsigned int shift)
>{
>        return (word << shift) | (word >> (32 - shift));
>}
>
>
>
>
>
>
>
>static __inline__ u32 ntfs_ror32(u32 word, unsigned int shift)
>{
>        return (word >> shift) | (word << (32 - shift));
>}
># 58 "attrib.c" 2
># 1 "../include/ntfs-3g/logging.h" 1
># 59 "attrib.c" 2
># 1 "../include/ntfs-3g/misc.h" 1
>
>
>
>void *ntfs_calloc(size_t size);
>void *ntfs_malloc(size_t size);
># 60 "attrib.c" 2
>
>ntfschar AT_UNNAMED[] = { ('\0') };
>
>static int NAttrFlag(ntfs_attr *na, FILE_ATTR_FLAGS flag)
>{
> if (na->type == AT_DATA && na->name == AT_UNNAMED)
>  return (na->ni->flags & flag);
> return 0;
>}
>
>static void NAttrSetFlag(ntfs_attr *na, FILE_ATTR_FLAGS flag)
>{
> if (na->type == AT_DATA && na->name == AT_UNNAMED)
>  na->ni->flags |= flag;
> else
>  do {} while (0);
>
>}
>
>static void NAttrClearFlag(ntfs_attr *na, FILE_ATTR_FLAGS flag)
>{
> if (na->type == AT_DATA && na->name == AT_UNNAMED)
>  na->ni->flags &= ~flag;
>}
>
>
>
>
>
>
>int NAttrCompressed(ntfs_attr *na) { return NAttrFlag (na, FILE_ATTR_COMPRESSED); } void NAttrSetCompressed(ntfs_attr *na) { NAttrSetFlag (na, FILE_ATTR_COMPRESSED); } void NAttrClearCompressed(ntfs_attr *na){ NAttrClearFlag(na, FILE_ATTR_COMPRESSED); }
>int NAttrEncrypted(ntfs_attr *na) { return NAttrFlag (na, FILE_ATTR_ENCRYPTED); } void NAttrSetEncrypted(ntfs_attr *na) { NAttrSetFlag (na, FILE_ATTR_ENCRYPTED); } void NAttrClearEncrypted(ntfs_attr *na){ NAttrClearFlag(na, FILE_ATTR_ENCRYPTED); }
>int NAttrSparse(ntfs_attr *na) { return NAttrFlag (na, FILE_ATTR_SPARSE_FILE); } void NAttrSetSparse(ntfs_attr *na) { NAttrSetFlag (na, FILE_ATTR_SPARSE_FILE); } void NAttrClearSparse(ntfs_attr *na){ NAttrClearFlag(na, FILE_ATTR_SPARSE_FILE); }
># 102 "attrib.c"
>s64 ntfs_get_attribute_value_length(const ATTR_RECORD *a)
>{
> if (!a) {
>  (*__errno_location ()) = 22;
>  return 0;
> }
> (*__errno_location ()) = 0;
> if (a->non_resident)
>  return (s64)((s64)(a->data_size));
>
> return (s64)(u32)((u32)(a->value_length));
>}
># 125 "attrib.c"
>s64 ntfs_get_attribute_value(const ntfs_volume *vol,
>  const ATTR_RECORD *a, u8 *b)
>{
> runlist *rl;
> s64 total, r;
> int i;
>
>
> if (!vol || !a || !b) {
>  (*__errno_location ()) = 22;
>  return 0;
> }
>
>
>
>
>
>
> if (a->type != AT_ATTRIBUTE_LIST && a->flags) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",145,(1 << 7),((void *)0),"Non-zero (%04x) attribute flags. Cannot handle " "this yet.\n", (u16)((u16)(a->flags)));
>
>  (*__errno_location ()) = 95;
>  return 0;
> }
> if (!a->non_resident) {
>
>
>
>  if ((u32)((u32)(a->value_length)) + (u16)((u16)(a->value_offset))
>    > (u32)((u32)(a->length))) {
>   return 0;
>  }
>
>  memcpy(b, (const char*)a + (u16)((u16)(a->value_offset)),
>    (u32)((u32)(a->value_length)));
>  (*__errno_location ()) = 0;
>  return (s64)(u32)((u32)(a->value_length));
> }
>
>
>
>
> if (!(a->data_size)) {
>  (*__errno_location ()) = 0;
>  return 0;
> }
>
>
>
>
> rl = ntfs_mapping_pairs_decompress(vol, a, ((void *)0));
> if (!rl) {
>  (*__errno_location ()) = 22;
>  return 0;
> }
># 192 "attrib.c"
> for (i = 0, total = 0; rl[i].length; i++) {
>  if (total + (rl[i].length << vol->cluster_size_bits) >=
>    (s64)((s64)(a->data_size))) {
>   unsigned char *intbuf = ((void *)0);
># 210 "attrib.c"
>   intbuf = ntfs_malloc(rl[i].length << vol->cluster_size_bits);
>   if (!intbuf) {
>    free(rl);
>    return 0;
>   }
># 226 "attrib.c"
>   r = ntfs_pread(vol->dev, rl[i].lcn <<
>     vol->cluster_size_bits, rl[i].length <<
>     vol->cluster_size_bits, intbuf);
>   if (r != rl[i].length << vol->cluster_size_bits) {
>
>    if (r == -1)
>     ntfs_log_redirect(__FUNCTION__,"attrib.c",232,(1 << 8),((void *)0),"Error reading attribute value");
>    else if (r < rl[i].length <<
>      vol->cluster_size_bits) {
>     do {} while (0);
>     (*__errno_location ()) = 5;
>    } else {
>     do {} while (0);
>     (*__errno_location ()) = 5;
>    }
>
>    free(rl);
>    free(intbuf);
>    return 0;
>   }
>   memcpy(b + total, intbuf, (s64)((s64)(a->data_size)) -
>     total);
>   free(intbuf);
>   total = (s64)((s64)(a->data_size));
>   break;
>  }
># 262 "attrib.c"
>  r = ntfs_pread(vol->dev, rl[i].lcn << vol->cluster_size_bits,
>    rl[i].length << vol->cluster_size_bits,
>    b + total);
>  if (r != rl[i].length << vol->cluster_size_bits) {
>
>   if (r == -1)
>    ntfs_log_redirect(__FUNCTION__,"attrib.c",268,(1 << 8),((void *)0),"Error reading attribute value");
>   else if (r < rl[i].length << vol->cluster_size_bits) {
>    do {} while (0);
>    (*__errno_location ()) = 5;
>   } else {
>    do {} while (0);
>    (*__errno_location ()) = 5;
>   }
>
>   free(rl);
>   return 0;
>  }
>  total += r;
> }
> free(rl);
> return total;
>}
># 298 "attrib.c"
>static void __ntfs_attr_init(ntfs_attr *na, ntfs_inode *ni,
>  const ATTR_TYPES type, ntfschar *name, const u32 name_len)
>{
> na->rl = ((void *)0);
> na->ni = ni;
> na->type = type;
> na->name = name;
> if (name)
>  na->name_len = name_len;
> else
>  na->name_len = 0;
>}
># 326 "attrib.c"
>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)
>{
> if (!(((na)->state) & (1 << (NA_Initialized)))) {
>  if (non_resident)
>   ((na)->state) |= 1 << (NA_NonResident);
>  if (compressed)
>   NAttrSetCompressed(na);
>  if (encrypted)
>   NAttrSetEncrypted(na);
>  if (sparse)
>   NAttrSetSparse(na);
>  na->allocated_size = allocated_size;
>  na->data_size = data_size;
>  na->initialized_size = initialized_size;
>  if (compressed || sparse) {
>   ntfs_volume *vol = na->ni->vol;
>
>   na->compressed_size = compressed_size;
>   na->compression_block_clusters = 1 << compression_unit;
>   na->compression_block_size = 1 << (compression_unit +
>     vol->cluster_size_bits);
>   na->compression_block_size_bits = ffs(
>     na->compression_block_size) - 1;
>  }
>  ((na)->state) |= 1 << (NA_Initialized);
> }
>}
># 373 "attrib.c"
>ntfs_attr *ntfs_attr_open(ntfs_inode *ni, const ATTR_TYPES type,
>  ntfschar *name, u32 name_len)
>{
> ntfs_attr_search_ctx *ctx;
> ntfs_attr *na;
> ATTR_RECORD *a;
> int err;
> BOOL cs;
>
> do {} while (0);
>
> if (!ni || !ni->vol || !ni->mrec) {
>  (*__errno_location ()) = 22;
>  return ((void *)0);
> }
> na = calloc(sizeof(ntfs_attr), 1);
> if (!na)
>  return ((void *)0);
> if (name && name != AT_UNNAMED && name != NTFS_INDEX_I30) {
>  name = ntfs_ucsndup(name, name_len);
>  if (!name) {
>   free(na);
>   return ((void *)0);
>  }
> }
>
> ctx = ntfs_attr_get_search_ctx(ni, ((void *)0));
> if (!ctx) {
>  err = (*__errno_location ());
>  goto err_out;
> }
> if (ntfs_attr_lookup(type, name, name_len, 0, 0, ((void *)0), 0, ctx)) {
>  err = (*__errno_location ());
>  goto put_err_out;
> }
>
> a = ctx->attr;
>
>
>
>
>
> if (type == AT_ATTRIBUTE_LIST)
>  a->flags = 0;
> cs = a->flags & (ATTR_IS_COMPRESSED | ATTR_IS_SPARSE);
> if (!name) {
>  if (a->name_length) {
>   name = ntfs_ucsndup((ntfschar*)((u8*)a + (u16)((u16)(a->name_offset))), a->name_length);
>
>   if (!name) {
>    err = (*__errno_location ());
>    goto put_err_out;
>   }
>   name_len = a->name_length;
>  } else {
>   name = AT_UNNAMED;
>   name_len = 0;
>  }
> }
> __ntfs_attr_init(na, ni, type, name, name_len);
> if (a->non_resident) {
>  ntfs_attr_init(na, TRUE, a->flags & ATTR_IS_COMPRESSED,
>    a->flags & ATTR_IS_ENCRYPTED,
>    a->flags & ATTR_IS_SPARSE,
>    (s64)((s64)(a->allocated_size)),
>    (s64)((s64)(a->data_size)),
>    (s64)((s64)(a->initialized_size)),
>    cs ? (s64)((s64)(a->compressed_size)) : 0,
>    cs ? a->compression_unit : 0);
> } else {
>  s64 l = (u32)((u32)(a->value_length));
>  ntfs_attr_init(na, FALSE, a->flags & ATTR_IS_COMPRESSED,
>    a->flags & ATTR_IS_ENCRYPTED,
>    a->flags & ATTR_IS_SPARSE, (l + 7) & ~7, l, l,
>    cs ? (l + 7) & ~7 : 0, 0);
> }
> ntfs_attr_put_search_ctx(ctx);
> return na;
>put_err_out:
> ntfs_attr_put_search_ctx(ctx);
>err_out:
> free(na);
> (*__errno_location ()) = err;
> return ((void *)0);
>}
># 466 "attrib.c"
>void ntfs_attr_close(ntfs_attr *na)
>{
> if (!na)
>  return;
> if ((((na)->state) & (1 << (NA_NonResident))) && na->rl)
>  free(na->rl);
>
> if (na->name != AT_UNNAMED && na->name != NTFS_INDEX_I30)
>  free(na->name);
> free(na);
>}
># 487 "attrib.c"
>int ntfs_attr_map_runlist(ntfs_attr *na, VCN vcn)
>{
> LCN lcn;
> ntfs_attr_search_ctx *ctx;
>
> do {} while (0);
>
>
> lcn = ntfs_rl_vcn_to_lcn(na->rl, vcn);
> if (lcn >= 0 || lcn == LCN_HOLE || lcn == LCN_ENOENT)
>  return 0;
>
> ctx = ntfs_attr_get_search_ctx(na->ni, ((void *)0));
> if (!ctx)
>  return -1;
>
>
> if (!ntfs_attr_lookup(na->type, na->name, na->name_len, CASE_SENSITIVE,
>   vcn, ((void *)0), 0, ctx)) {
>  runlist_element *rl;
>
>
>  rl = ntfs_mapping_pairs_decompress(na->ni->vol, ctx->attr,
>    na->rl);
>  if (rl) {
>   na->rl = rl;
>   ntfs_attr_put_search_ctx(ctx);
>   return 0;
>  }
> }
>
> ntfs_attr_put_search_ctx(ctx);
> return -1;
>}
># 534 "attrib.c"
>int ntfs_attr_map_whole_runlist(ntfs_attr *na)
>{
> VCN next_vcn, last_vcn, highest_vcn;
> ntfs_attr_search_ctx *ctx;
> ntfs_volume *vol = na->ni->vol;
> ATTR_RECORD *a;
> int err;
>
> do {} while (0);
>
>
> ctx = ntfs_attr_get_search_ctx(na->ni, ((void *)0));
> if (!ctx)
>  return -1;
>
>
> next_vcn = last_vcn = highest_vcn = 0;
> a = ((void *)0);
> while (1) {
>  runlist_element *rl;
>
>  int not_mapped = 0;
>  if (ntfs_rl_vcn_to_lcn(na->rl, next_vcn) == LCN_RL_NOT_MAPPED)
>   not_mapped = 1;
>
>  if (ntfs_attr_lookup(na->type, na->name, na->name_len,
>    CASE_SENSITIVE, next_vcn, ((void *)0), 0, ctx))
>   break;
>
>  a = ctx->attr;
>
>  if (not_mapped) {
>
>   rl = ntfs_mapping_pairs_decompress(na->ni->vol,
>        a, na->rl);
>   if (!rl)
>    goto err_out;
>   na->rl = rl;
>  }
>
>
>  if (!next_vcn) {
>    if (a->lowest_vcn) {
>     (*__errno_location ()) = 5;
>     ntfs_log_redirect(__FUNCTION__,"attrib.c",580,(1 << 8),((void *)0),"First extent of inode %llu " "attribute has non-zero lowest_vcn", (unsigned long long)na->ni->mft_no);
>
>
>     goto err_out;
>   }
>
>   last_vcn = (s64)((s64)(a->allocated_size)) >>
>     vol->cluster_size_bits;
>  }
>
>
>  highest_vcn = (s64)((s64)(a->highest_vcn));
>  next_vcn = highest_vcn + 1;
>
>
>  if (next_vcn <= 0) {
>   (*__errno_location ()) = 2;
>   break;
>  }
>
>
>  if (next_vcn < (s64)((s64)(a->lowest_vcn))) {
>   (*__errno_location ()) = 5;
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",602,(1 << 8),((void *)0),"Inode %llu has corrupt attribute list", (unsigned long long)na->ni->mft_no);
>
>   goto err_out;
>  }
> }
> if (!a) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",607,(1 << 8),((void *)0),"Couldn't find attribute for runlist mapping");
>  goto err_out;
> }
> if (highest_vcn && highest_vcn != last_vcn - 1) {
>  (*__errno_location ()) = 5;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",615,(1 << 8),((void *)0),"Failed to load full runlist: inode: %llu " "highest_vcn: 0x%llx last_vcn: 0x%llx", (unsigned long long)na->ni->mft_no, (long long)highest_vcn, (long long)last_vcn);
>
>
>
>  goto err_out;
> }
> err = (*__errno_location ());
> ntfs_attr_put_search_ctx(ctx);
> if (err == 2)
>  return 0;
>out_now:
> (*__errno_location ()) = err;
> return -1;
>err_out:
> err = (*__errno_location ());
> ntfs_attr_put_search_ctx(ctx);
> goto out_now;
>}
># 652 "attrib.c"
>LCN ntfs_attr_vcn_to_lcn(ntfs_attr *na, const VCN vcn)
>{
> LCN lcn;
> BOOL is_retry = FALSE;
>
> if (!na || !(((na)->state) & (1 << (NA_NonResident))) || vcn < 0)
>  return (LCN)LCN_EINVAL;
>
> do {} while (0);
>
>retry:
>
> lcn = ntfs_rl_vcn_to_lcn(na->rl, vcn);
> if (lcn >= 0)
>  return lcn;
> if (!is_retry && !ntfs_attr_map_runlist(na, vcn)) {
>  is_retry = TRUE;
>  goto retry;
> }
>
>
>
>
>
> if (!is_retry || lcn == (LCN)LCN_RL_NOT_MAPPED)
>  return (LCN)LCN_EIO;
>
> return lcn;
>}
># 702 "attrib.c"
>runlist_element *ntfs_attr_find_vcn(ntfs_attr *na, const VCN vcn)
>{
> runlist_element *rl;
> BOOL is_retry = FALSE;
>
> if (!na || !(((na)->state) & (1 << (NA_NonResident))) || vcn < 0) {
>  (*__errno_location ()) = 22;
>  return ((void *)0);
> }
>
> do {} while (0);
>
>
>retry:
> rl = na->rl;
> if (!rl)
>  goto map_rl;
> if (vcn < rl[0].vcn)
>  goto map_rl;
> while (rl->length) {
>  if (vcn < rl[1].vcn) {
>   if (rl->lcn >= (LCN)LCN_HOLE)
>    return rl;
>   break;
>  }
>  rl++;
> }
> switch (rl->lcn) {
> case (LCN)LCN_RL_NOT_MAPPED:
>  goto map_rl;
> case (LCN)LCN_ENOENT:
>  (*__errno_location ()) = 2;
>  break;
> case (LCN)LCN_EINVAL:
>  (*__errno_location ()) = 22;
>  break;
> default:
>  (*__errno_location ()) = 5;
>  break;
> }
> return ((void *)0);
>map_rl:
>
> if (!is_retry && !ntfs_attr_map_runlist(na, vcn)) {
>  is_retry = TRUE;
>  goto retry;
> }
>
>
>
>
>
>
> if (is_retry || (*__errno_location ()) == 22 || (*__errno_location ()) == 2)
>  (*__errno_location ()) = 5;
> return ((void *)0);
>}
># 779 "attrib.c"
>s64 ntfs_attr_pread(ntfs_attr *na, const s64 pos, s64 count, void *b)
>{
> s64 br, to_read, ofs, total, total2;
> ntfs_volume *vol;
> runlist_element *rl;
>
> if (!na || !na->ni || !na->ni->vol || !b || pos < 0 || count < 0) {
>  (*__errno_location ()) = 22;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",789,(1 << 8),((void *)0),"%s: na=%p  b=%p  pos=%lld  count=%lld", __FUNCTION__, na, b, (long long)pos, (long long)count);
>
>
>  return -1;
> }
>
> do {} while (0);
>
>
>
>
>
>
>
> if (NAttrCompressed(na) && (((na)->state) & (1 << (NA_NonResident))))
>  return ntfs_compressed_attr_pread(na, pos, count, b);
>
>
>
>
> if (NAttrEncrypted(na) && (((na)->state) & (1 << (NA_NonResident)))) {
>  (*__errno_location ()) = 13;
>  return -1;
> }
> vol = na->ni->vol;
>
> if (!count)
>  return 0;
>
> if (pos + count > na->data_size) {
>  if (pos >= na->data_size)
>   return 0;
>  count = na->data_size - pos;
> }
>
> if (!(((na)->state) & (1 << (NA_NonResident)))) {
>  ntfs_attr_search_ctx *ctx;
>  char *val;
>
>  ctx = ntfs_attr_get_search_ctx(na->ni, ((void *)0));
>  if (!ctx)
>   return -1;
>  if (ntfs_attr_lookup(na->type, na->name, na->name_len, 0,
>    0, ((void *)0), 0, ctx)) {
>res_err_out:
>   ntfs_attr_put_search_ctx(ctx);
>   return -1;
>  }
>  val = (char*)ctx->attr + (u16)((u16)(ctx->attr->value_offset));
>  if (val < (char*)ctx->attr || val +
>    (u32)((u32)(ctx->attr->value_length)) >
>    (char*)ctx->mrec + vol->mft_record_size) {
>   (*__errno_location ()) = 5;
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",840,(1 << 8),((void *)0),"%s: Sanity check failed", __FUNCTION__);
>   goto res_err_out;
>  }
>  memcpy(b, val + pos, count);
>  ntfs_attr_put_search_ctx(ctx);
>  return count;
> }
> total = total2 = 0;
>
> if (pos + count > na->initialized_size) {
>  if (pos >= na->initialized_size) {
>   memset(b, 0, count);
>   return count;
>  }
>  total2 = pos + count - na->initialized_size;
>  count -= total2;
>  memset((u8*)b + count, 0, total2);
> }
>
> rl = ntfs_attr_find_vcn(na, pos >> vol->cluster_size_bits);
> if (!rl) {
>
>
>
>
>
>  if ((*__errno_location ()) == 2) {
>   (*__errno_location ()) = 5;
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",868,(1 << 8),((void *)0),"%s: Failed to find VCN #1", __FUNCTION__);
>  }
>  return -1;
> }
>
>
>
>
>
> ofs = pos - (rl->vcn << vol->cluster_size_bits);
> for (; count; rl++, ofs = 0) {
>  if (rl->lcn == LCN_RL_NOT_MAPPED) {
>   rl = ntfs_attr_find_vcn(na, rl->vcn);
>   if (!rl) {
>    if ((*__errno_location ()) == 2) {
>     (*__errno_location ()) = 5;
>     ntfs_log_redirect(__FUNCTION__,"attrib.c",885,(1 << 8),((void *)0),"%s: Failed to find VCN #2", __FUNCTION__);
>
>    }
>    goto rl_err_out;
>   }
>
>   ofs = pos + total - (rl->vcn << vol->cluster_size_bits);
>  }
>  if (!rl->length) {
>   (*__errno_location ()) = 5;
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",894,(1 << 8),((void *)0),"%s: Zero run length", __FUNCTION__);
>   goto rl_err_out;
>  }
>  if (rl->lcn < (LCN)0) {
>   if (rl->lcn != (LCN)LCN_HOLE) {
>    ntfs_log_redirect(__FUNCTION__,"attrib.c",901,(1 << 8),((void *)0),"%s: Bad run (%lld)", __FUNCTION__, (long long)rl->lcn);
>
>
>    goto rl_err_out;
>   }
>
>   to_read = ((count) <= ((rl->length << vol->cluster_size_bits) - ofs) ? (count) : ((rl->length << vol->cluster_size_bits) - ofs));
>
>   memset(b, 0, to_read);
>
>   total += to_read;
>   count -= to_read;
>   b = (u8*)b + to_read;
>   continue;
>  }
>
>  to_read = ((count) <= ((rl->length << vol->cluster_size_bits) - ofs) ? (count) : ((rl->length << vol->cluster_size_bits) - ofs));
>
>retry:
>  do {} while (0);
>
>  br = ntfs_pread(vol->dev, (rl->lcn << vol->cluster_size_bits) +
>    ofs, to_read, b);
>
>  if (br > 0) {
>   total += br;
>   count -= br;
>   b = (u8*)b + br;
>   continue;
>  }
>
>  if (br == (s64)-1 && (*__errno_location ()) == 4)
>   goto retry;
>  if (total)
>   return total;
>  if (!br)
>   (*__errno_location ()) = 5;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",936,(1 << 8),((void *)0),"%s: ntfs_pread failed", __FUNCTION__);
>  return -1;
> }
>
> return total + total2;
>rl_err_out:
> if (total)
>  return total;
> (*__errno_location ()) = 5;
> return -1;
>}
>
>static int ntfs_attr_fill_zero(ntfs_attr *na, s64 pos, s64 count)
>{
> char *buf;
> s64 written, size, end = pos + count;
> int ret = -1;
>
> do {} while (0);
>
>
> if (!na || pos < 0 || count < 0) {
>  (*__errno_location ()) = 22;
>  goto err_out;
> }
>
> buf = ntfs_calloc(8192);
> if (!buf)
>  goto err_out;
>
> while (pos < end) {
>  size = ((end - pos) <= (8192) ? (end - pos) : (8192));
>  written = ntfs_rl_pwrite(na->ni->vol, na->rl, pos, size, buf);
>  if (written <= 0) {
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",970,(1 << 8),((void *)0),"Failed to zero space");
>   goto err_free;
>  }
>  pos += written;
> }
>
> ret = 0;
>err_free:
> free(buf);
>err_out:
> return ret;
>}
>
>static int ntfs_attr_fill_hole(ntfs_attr *na, s64 count, s64 *ofs,
>          runlist_element **rl, VCN *update_from)
>{
> s64 to_write;
> ntfs_volume *vol = na->ni->vol;
> int eo, ret = -1;
> runlist *rlc;
> LCN lcn_seek_from = -1;
> VCN cur_vcn, from_vcn;
>
> to_write = ((count) <= (((*rl)->length << vol->cluster_size_bits) - *ofs) ? (count) : (((*rl)->length << vol->cluster_size_bits) - *ofs));
>
> cur_vcn = (*rl)->vcn;
> from_vcn = (*rl)->vcn + (*ofs >> vol->cluster_size_bits);
>
> do {} while (0);
>
>
>
> if (ntfs_attr_map_whole_runlist(na))
>  goto err_out;
>
>
> *rl = ntfs_attr_find_vcn(na, cur_vcn);
> if (!*rl) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",1009,(1 << 7),((void *)0),"Failed to find run after mapping runlist. " "Please report to %s.\n", "ntfs-3g-devel@lists.sf.net");
>
>  (*__errno_location ()) = 5;
>  goto err_out;
> }
>
>
> rlc = *rl;
> while (rlc->vcn) {
>  rlc--;
>  if (rlc->lcn >= 0) {
>   lcn_seek_from = rlc->lcn + (from_vcn - rlc->vcn);
>   break;
>  }
> }
> if (lcn_seek_from == -1) {
>
>  rlc = *rl;
>  while (rlc->length) {
>   rlc++;
>   if (rlc->lcn >= 0) {
>    lcn_seek_from = rlc->lcn - (rlc->vcn - from_vcn);
>    if (lcn_seek_from < -1)
>     lcn_seek_from = -1;
>    break;
>   }
>  }
> }
>
> rlc = ntfs_cluster_alloc(vol, from_vcn,
>    ((*ofs + to_write - 1) >> vol->cluster_size_bits)
>     + 1 + (*rl)->vcn - from_vcn,
>     lcn_seek_from, DATA_ZONE);
> if (!rlc)
>  goto err_out;
>
> *rl = ntfs_runlists_merge(na->rl, rlc);
> if (!*rl) {
>  eo = (*__errno_location ());
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",1047,(1 << 8),((void *)0),"Failed to merge runlists");
>  if (ntfs_cluster_free_from_rl(vol, rlc)) {
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",1050,(1 << 8),((void *)0),"Failed to free hot clusters. " "Please run chkdsk /f");
>
>  }
>  (*__errno_location ()) = eo;
>  goto err_out;
> }
> na->rl = *rl;
> if (*update_from == -1)
>  *update_from = from_vcn;
> *rl = ntfs_attr_find_vcn(na, cur_vcn);
> if (!*rl) {
>
>
>
>
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",1065,(1 << 7),((void *)0),"Failed to find run after hole instantiation. " "Please report to %s.\n", "ntfs-3g-devel@lists.sf.net");
>
>  (*__errno_location ()) = 5;
>  goto err_out;
> }
>
> if ((*rl)->lcn < 0)
>  (*rl)++;
>
> if ((*rl)->lcn < 0) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",1075,(1 << 7),((void *)0),"BUG! LCN is lesser than 0. " "Please report to the %s.\n", "ntfs-3g-devel@lists.sf.net");
>
>  (*__errno_location ()) = 5;
>  goto err_out;
> }
> if (*ofs) {
>
>  if (ntfs_attr_fill_zero(na, cur_vcn << vol->cluster_size_bits,
>     *ofs))
>   goto err_out;
> }
> if ((*rl)->vcn < cur_vcn) {
>
>
>
>
>  *ofs += (cur_vcn - (*rl)->vcn) << vol->cluster_size_bits;
> }
> if ((*rl)->vcn > cur_vcn) {
>
>
>
>  *ofs -= ((*rl)->vcn - cur_vcn) << vol->cluster_size_bits;
> }
>
> ret = 0;
>err_out:
> return ret;
>}
># 1123 "attrib.c"
>s64 ntfs_attr_pwrite(ntfs_attr *na, const s64 pos, s64 count, const void *b)
>{
> s64 written, to_write, ofs, old_initialized_size, old_data_size;
> s64 total = 0;
> VCN update_from = -1;
> ntfs_volume *vol;
> ntfs_attr_search_ctx *ctx = ((void *)0);
> runlist_element *rl;
> s64 eo, hole;
> struct {
>  unsigned int undo_initialized_size : 1;
>  unsigned int undo_data_size : 1;
> } need_to = { 0, 0 };
>
> do {} while (0);
>
>
> if (!na || !na->ni || !na->ni->vol || !b || pos < 0 || count < 0) {
>  (*__errno_location ()) = 22;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",1142,(1 << 8),((void *)0),"%s", __FUNCTION__);
>  goto errno_set;
> }
> vol = na->ni->vol;
>
>
>
>
> if (NAttrEncrypted(na) && (((na)->state) & (1 << (NA_NonResident)))) {
>  (*__errno_location ()) = 13;
>  goto errno_set;
> }
>
> if (NAttrCompressed(na)) {
>
>
>
>  (*__errno_location ()) = 95;
>  goto errno_set;
> }
>
> if (!count)
>  goto out;
>
> old_data_size = na->data_size;
> if (pos + count > na->data_size) {
>  if (ntfs_attr_truncate(na, pos + count)) {
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",1169,(1 << 8),((void *)0),"Failed to enlarge attribute");
>   goto errno_set;
>  }
>  need_to.undo_data_size = 1;
> }
> old_initialized_size = na->initialized_size;
>
> if (!(((na)->state) & (1 << (NA_NonResident)))) {
>  char *val;
>
>  ctx = ntfs_attr_get_search_ctx(na->ni, ((void *)0));
>  if (!ctx)
>   goto err_out;
>  if (ntfs_attr_lookup(na->type, na->name, na->name_len, 0,
>    0, ((void *)0), 0, ctx)) {
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",1184,(1 << 8),((void *)0),"%s: lookup failed", __FUNCTION__);
>   goto err_out;
>  }
>  val = (char*)ctx->attr + (u16)((u16)(ctx->attr->value_offset));
>  if (val < (char*)ctx->attr || val +
>    (u32)((u32)(ctx->attr->value_length)) >
>    (char*)ctx->mrec + vol->mft_record_size) {
>   (*__errno_location ()) = 5;
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",1192,(1 << 8),((void *)0),"%s: Sanity check failed", __FUNCTION__);
>   goto err_out;
>  }
>  memcpy(val + pos, b, count);
>  if (ntfs_mft_record_write(vol, ctx->ntfs_ino->mft_no,
>    ctx->mrec)) {
>
>
>
>
>
>
>
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",1205,(1 << 8),((void *)0),"%s: failed to write mft record", __FUNCTION__);
>   goto err_out;
>  }
>  ntfs_attr_put_search_ctx(ctx);
>  total = count;
>  goto out;
> }
>
>
> if (pos + count > na->initialized_size) {
>  if (ntfs_attr_map_whole_runlist(na))
>   goto err_out;
>
>  ctx = ntfs_attr_get_search_ctx(na->ni, ((void *)0));
>  if (!ctx)
>   goto err_out;
>  if (ntfs_attr_lookup(na->type, na->name, na->name_len, 0,
>    0, ((void *)0), 0, ctx))
>   goto err_out;
>
>
>  if (pos > na->initialized_size)
>   if (ntfs_attr_fill_zero(na, na->initialized_size,
>      pos - na->initialized_size))
>    goto err_out;
>
>  ctx->attr->initialized_size = (s64)((s64)(pos + count));
>  if (ntfs_mft_record_write(vol, ctx->ntfs_ino->mft_no,
>    ctx->mrec)) {
>
>
>
>
>   ctx->attr->initialized_size =
>     (s64)((s64)(old_initialized_size));
>   ntfs_mft_record_write(vol, ctx->ntfs_ino->mft_no,
>     ctx->mrec);
>   goto err_out;
>  }
>  na->initialized_size = pos + count;
>  ntfs_attr_put_search_ctx(ctx);
>  ctx = ((void *)0);
>
>
>
>
>
>
>  need_to.undo_initialized_size = 1;
> }
>
> rl = ntfs_attr_find_vcn(na, pos >> vol->cluster_size_bits);
> if (!rl) {
>
>
>
>
>
>  if ((*__errno_location ()) == 2) {
>   (*__errno_location ()) = 5;
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",1265,(1 << 8),((void *)0),"%s: Failed to find VCN #1", __FUNCTION__);
>  }
>  goto err_out;
> }
>
>
>
>
>
> ofs = pos - (rl->vcn << vol->cluster_size_bits);
> for (hole = 0; count; rl++, ofs = 0, hole = 0) {
>  if (rl->lcn == LCN_RL_NOT_MAPPED) {
>   rl = ntfs_attr_find_vcn(na, rl->vcn);
>   if (!rl) {
>    if ((*__errno_location ()) == 2) {
>     (*__errno_location ()) = 5;
>     ntfs_log_redirect(__FUNCTION__,"attrib.c",1282,(1 << 8),((void *)0),"%s: Failed to find VCN" " #2", __FUNCTION__);
>
>    }
>    goto rl_err_out;
>   }
>
>   ofs = pos + total - (rl->vcn << vol->cluster_size_bits);
>  }
>  if (!rl->length) {
>   (*__errno_location ()) = 5;
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",1291,(1 << 8),((void *)0),"%s: Zero run length", __FUNCTION__);
>   goto rl_err_out;
>  }
>  if (rl->lcn < (LCN)0) {
>
>   hole = rl->vcn + rl->length;
>
>   if (rl->lcn != (LCN)LCN_HOLE) {
>    (*__errno_location ()) = 5;
>    ntfs_log_redirect(__FUNCTION__,"attrib.c",1302,(1 << 8),((void *)0),"%s: Unexpected LCN (%lld)", __FUNCTION__, (long long)rl->lcn);
>
>
>    goto rl_err_out;
>   }
>
>   if (ntfs_attr_fill_hole(na, count, &ofs, &rl, &update_from))
>    goto err_out;
>  }
>
>  to_write = ((count) <= ((rl->length << vol->cluster_size_bits) - ofs) ? (count) : ((rl->length << vol->cluster_size_bits) - ofs));
>retry:
>  do {} while (0);
>
>  if (!(((vol)->state) & (1 << (NV_ReadOnly)))) {
>
>   s64 wpos = (rl->lcn << vol->cluster_size_bits) + ofs;
>   s64 wend = (rl->vcn << vol->cluster_size_bits) + ofs + to_write;
>   u32 bsize = vol->cluster_size;
>   s64 rounded = ((wend + bsize - 1) & ~(s64)(bsize - 1)) - wend;
># 1328 "attrib.c"
>   if ((rounded && (wend < (hole << vol->cluster_size_bits))) ||
>       (((to_write % bsize) &&
>         (ofs + to_write == na->initialized_size)))) {
>
>    char *cb;
>
>    rounded += to_write;
>
>    cb = ntfs_malloc(rounded);
>    if (!cb)
>     goto err_out;
>
>    memcpy(cb, b, to_write);
>    memset(cb + to_write, 0, rounded - to_write);
>
>    written = ntfs_pwrite(vol->dev, wpos, rounded, cb);
>    if (written == rounded)
>     written = to_write;
>
>    free(cb);
>   } else
>    written = ntfs_pwrite(vol->dev, wpos, to_write, b);
>  } else
>   written = to_write;
>
>  if (written > 0) {
>   total += written;
>   count -= written;
>   b = (const u8*)b + written;
>   continue;
>  }
>
>  if (written == (s64)-1 && (*__errno_location ()) == 4)
>   goto retry;
>  if (!written)
>   (*__errno_location ()) = 5;
>  goto rl_err_out;
> }
>done:
> if (ctx)
>  ntfs_attr_put_search_ctx(ctx);
>
> if (update_from != -1)
>  if (ntfs_attr_update_mapping_pairs(na, 0 )) {
>
>
>
>
>   return -1;
>  }
>out:
> return total;
>rl_err_out:
> eo = (*__errno_location ());
> if (total) {
>  if (need_to.undo_initialized_size) {
>   if (pos + total > na->initialized_size)
>    goto done;
>
>
>
>
>   (*__errno_location ()) = 95;
>   goto err_out;
>  }
>  goto done;
> }
> (*__errno_location ()) = eo;
>err_out:
> eo = (*__errno_location ());
> if (need_to.undo_initialized_size) {
>  int err;
>
>  err = 0;
>  if (!ctx) {
>   ctx = ntfs_attr_get_search_ctx(na->ni, ((void *)0));
>   if (!ctx)
>    err = 1;
>  } else
>   ntfs_attr_reinit_search_ctx(ctx);
>  if (!err) {
>   err = ntfs_attr_lookup(na->type, na->name,
>     na->name_len, 0, 0, ((void *)0), 0, ctx);
>   if (!err) {
>    na->initialized_size = old_initialized_size;
>    ctx->attr->initialized_size = (s64)((s64)(old_initialized_size));
>
>    err = ntfs_mft_record_write(vol,
>      ctx->ntfs_ino->mft_no,
>      ctx->mrec);
>   }
>  }
>  if (err) {
>
>
>
>
>
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",1428,(1 << 7),((void *)0),"Eeek! Failed to recover from error. " "Leaving metadata in inconsistent " "state! Run chkdsk!\n");
>
>
>  }
> }
> if (ctx)
>  ntfs_attr_put_search_ctx(ctx);
>
> if (update_from != -1)
>  ntfs_attr_update_mapping_pairs(na, 0 );
>
> if (need_to.undo_data_size && ntfs_attr_truncate(na, old_data_size))
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",1438,(1 << 8),((void *)0),"Failed to restore data_size");
> (*__errno_location ()) = eo;
>errno_set:
> total = -1;
> goto out;
>}
># 1474 "attrib.c"
>s64 ntfs_attr_mst_pread(ntfs_attr *na, const s64 pos, const s64 bk_cnt,
>  const u32 bk_size, void *dst)
>{
> s64 br;
> u8 *end;
>
> do {} while (0);
>
>
> if (bk_cnt < 0 || bk_size % 512) {
>  (*__errno_location ()) = 22;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",1485,(1 << 8),((void *)0),"%s", __FUNCTION__);
>  return -1;
> }
> br = ntfs_attr_pread(na, pos, bk_cnt * bk_size, dst);
> if (br <= 0)
>  return br;
> br /= bk_size;
> for (end = (u8*)dst + br * bk_size; (u8*)dst < end; dst = (u8*)dst +
>   bk_size)
>  ntfs_mst_post_read_fixup((NTFS_RECORD*)dst, bk_size);
>
> return br;
>}
># 1529 "attrib.c"
>s64 ntfs_attr_mst_pwrite(ntfs_attr *na, const s64 pos, s64 bk_cnt,
>  const u32 bk_size, void *src)
>{
> s64 written, i;
>
> do {} while (0);
>
>
> if (bk_cnt < 0 || bk_size % 512) {
>  (*__errno_location ()) = 22;
>  return -1;
> }
> if (!bk_cnt)
>  return 0;
>
> for (i = 0; i < bk_cnt; ++i) {
>  int err;
>
>  err = ntfs_mst_pre_write_fixup((NTFS_RECORD*)
>    ((u8*)src + i * bk_size), bk_size);
>  if (err < 0) {
>
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",1551,(1 << 8),((void *)0),"%s #1", __FUNCTION__);
>   if (!i)
>    return err;
>   bk_cnt = i;
>   break;
>  }
> }
>
> written = ntfs_attr_pwrite(na, pos, bk_cnt * bk_size, src);
> if (written <= 0) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",1562,(1 << 8),((void *)0),"%s: written=%lld", __FUNCTION__, (long long)written);
>
> }
>
> for (i = 0; i < bk_cnt; ++i)
>  ntfs_mst_post_write_fixup((NTFS_RECORD*)((u8*)src + i *
>    bk_size));
> if (written <= 0)
>  return written;
>
> return written / bk_size;
>}
># 1644 "attrib.c"
>static int ntfs_attr_find(const ATTR_TYPES type, const ntfschar *name,
>  const u32 name_len, const IGNORE_CASE_BOOL ic,
>  const u8 *val, const u32 val_len, ntfs_attr_search_ctx *ctx)
>{
> ATTR_RECORD *a;
> ntfs_volume *vol;
> ntfschar *upcase;
> u32 upcase_len;
>
> do {} while (0);
>
> if (ctx->ntfs_ino) {
>  vol = ctx->ntfs_ino->vol;
>  upcase = vol->upcase;
>  upcase_len = vol->upcase_len;
> } else {
>  if (name && name != AT_UNNAMED) {
>   (*__errno_location ()) = 22;
>   return -1;
>  }
>  vol = ((void *)0);
>  upcase = ((void *)0);
>  upcase_len = 0;
> }
>
>
>
>
> if (ctx->is_first) {
>  a = ctx->attr;
>  ctx->is_first = FALSE;
> } else
>  a = (ATTR_RECORD*)((char*)ctx->attr +
>    (u32)((u32)(ctx->attr->length)));
> for (;; a = (ATTR_RECORD*)((char*)a + (u32)((u32)(a->length)))) {
>  if (((ptrdiff_t)((ptrdiff_t*)(a))) < ((ptrdiff_t)((ptrdiff_t*)(ctx->mrec))) || (char*)a > (char*)ctx->mrec +
>    (u32)((u32)(ctx->mrec->bytes_allocated)))
>   break;
>  ctx->attr = a;
>  if (((type != AT_UNUSED) && ((u32)((u32)(a->type)) >
>    (u32)((u32)(type)))) ||
>    (a->type == AT_END)) {
>   (*__errno_location ()) = 2;
>   return -1;
>  }
>  if (!a->length)
>   break;
>
>  if (type == AT_UNUSED)
>   return 0;
>  if (a->type != type)
>   continue;
>
>
>
>
>
>  if (name == AT_UNNAMED) {
>
>   if (a->name_length) {
>    (*__errno_location ()) = 2;
>    return -1;
>   }
>  } else if (name && !ntfs_names_are_equal(name, name_len,
>       (ntfschar*)((char*)a + (u16)((u16)(a->name_offset))),
>       a->name_length, ic, upcase, upcase_len)) {
>   register int rc;
>
>   rc = ntfs_names_collate(name, name_len,
>     (ntfschar*)((char*)a +
>     (u16)((u16)(a->name_offset))),
>     a->name_length, 1, IGNORE_CASE,
>     upcase, upcase_len);
>
>
>
>
>   if (rc == -1) {
>    (*__errno_location ()) = 2;
>    return -1;
>   }
>
>   if (rc)
>    continue;
>   rc = ntfs_names_collate(name, name_len,
>     (ntfschar*)((char*)a +
>     (u16)((u16)(a->name_offset))),
>     a->name_length, 1, CASE_SENSITIVE,
>     upcase, upcase_len);
>   if (rc == -1) {
>    (*__errno_location ()) = 2;
>    return -1;
>   }
>   if (rc)
>    continue;
>  }
>
>
>
>
>
>  if (!val)
>   return 0;
>
>  else {
>   register int rc;
>
>   rc = memcmp(val, (char*)a +(u16)((u16)(a->value_offset)),
>     ((val_len) <= ((u32)((u32)(a->value_length))) ? (val_len) : ((u32)((u32)(a->value_length)))));
>
>
>
>
>
>   if (!rc) {
>    register u32 avl;
>    avl = (u32)((u32)(a->value_length));
>    if (val_len == avl)
>     return 0;
>    if (val_len < avl) {
>     (*__errno_location ()) = 2;
>     return -1;
>    }
>   } else if (rc < 0) {
>    (*__errno_location ()) = 2;
>    return -1;
>   }
>  }
> }
> do {} while (0);
> (*__errno_location ()) = 5;
> return -1;
>}
>
>void ntfs_attr_name_free(char **name)
>{
> if (*name) {
>  free(*name);
>  *name = ((void *)0);
> }
>}
>
>char *ntfs_attr_name_get(const ntfschar *uname, const int uname_len)
>{
> char *name = ((void *)0);
> int name_len;
>
> name_len = ntfs_ucstombs(uname, uname_len, &name, 0);
> if (name_len < 0) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",1793,(1 << 8),((void *)0),"ntfs_ucstombs");
>  return ((void *)0);
>
> } else if (name_len > 0)
>  return name;
>
> ntfs_attr_name_free(&name);
> return ((void *)0);
>}
># 1873 "attrib.c"
>static int ntfs_external_attr_find(ATTR_TYPES type, const ntfschar *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_inode *base_ni, *ni;
> ntfs_volume *vol;
> ATTR_LIST_ENTRY *al_entry, *next_al_entry;
> u8 *al_start, *al_end;
> ATTR_RECORD *a;
> ntfschar *al_name;
> u32 al_name_len;
> BOOL is_first_search = FALSE;
>
> ni = ctx->ntfs_ino;
> base_ni = ctx->base_ntfs_ino;
> do {} while (0);
>
> if (!base_ni) {
>
>  base_ni = ctx->base_ntfs_ino = ctx->ntfs_ino;
>  ctx->base_mrec = ctx->mrec;
> }
> if (ni == base_ni)
>  ctx->base_attr = ctx->attr;
> if (type == AT_END)
>  goto not_found;
> vol = base_ni->vol;
> al_start = base_ni->attr_list;
> al_end = al_start + base_ni->attr_list_size;
> if (!ctx->al_entry) {
>  ctx->al_entry = (ATTR_LIST_ENTRY*)al_start;
>  is_first_search = TRUE;
> }
>
>
>
>
> if (ctx->is_first) {
>  al_entry = ctx->al_entry;
>  ctx->is_first = FALSE;
>
>
>
>
>
>  if ((type == AT_UNUSED) && is_first_search &&
>    (u32)((u32)(al_entry->type)) >
>    (u32)((u32)(AT_ATTRIBUTE_LIST)))
>   goto find_attr_list_attr;
> } else {
>  al_entry = (ATTR_LIST_ENTRY*)((char*)ctx->al_entry +
>    (u16)((u16)(ctx->al_entry->length)));
>
>
>
>
>
>
>  if ((type == AT_UNUSED) && (u32)((u32)(ctx->al_entry->type)) <
>    (u32)((u32)(AT_ATTRIBUTE_LIST)) &&
>    (u32)((u32)(al_entry->type)) >
>    (u32)((u32)(AT_ATTRIBUTE_LIST))) {
>   int rc;
>find_attr_list_attr:
>
>
>   if (name || name_len || val || val_len || lowest_vcn) {
>    (*__errno_location ()) = 22;
>    return -1;
>   }
>
>
>   ctx->ntfs_ino = base_ni;
>   ctx->mrec = ctx->base_mrec;
>   ctx->is_first = TRUE;
>
>   ctx->attr = (ATTR_RECORD*)((u8*)ctx->mrec +
>     (u16)((u16)(ctx->mrec->attrs_offset)));
>
>
>   rc = ntfs_attr_find(AT_ATTRIBUTE_LIST, ((void *)0), 0,
>     IGNORE_CASE, ((void *)0), 0, ctx);
>
>
>
>
>
>   ctx->al_entry = al_entry;
>   ctx->is_first = TRUE;
>
>
>   if (!rc)
>    return 0;
>
>
>   if ((*__errno_location ()) != 2)
>    return rc;
>
>
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",1973,(1 << 7),((void *)0),"Extant attribute list wasn't found\n");
>   (*__errno_location ()) = 22;
>   return -1;
>  }
> }
> for (;; al_entry = next_al_entry) {
>
>  if ((u8*)al_entry < base_ni->attr_list ||
>    (u8*)al_entry > al_end)
>   break;
>  ctx->al_entry = al_entry;
>
>  if ((u8*)al_entry == al_end)
>   goto not_found;
>  if (!al_entry->length)
>   break;
>  if ((u8*)al_entry + 6 > al_end || (u8*)al_entry +
>    (u16)((u16)(al_entry->length)) > al_end)
>   break;
>  next_al_entry = (ATTR_LIST_ENTRY*)((u8*)al_entry +
>    (u16)((u16)(al_entry->length)));
>  if (type != AT_UNUSED) {
>   if ((u32)((u32)(al_entry->type)) > (u32)((u32)(type)))
>    goto not_found;
>   if (type != al_entry->type)
>    continue;
>  }
>  al_name_len = al_entry->name_length;
>  al_name = (ntfschar*)((u8*)al_entry + al_entry->name_offset);
>
>
>
>
>  if (type == AT_UNUSED)
>   goto is_enumeration;
>
>
>
>
>
>  if (name == AT_UNNAMED) {
>   if (al_name_len)
>    goto not_found;
>  } else if (name && !ntfs_names_are_equal(al_name, al_name_len,
>    name, name_len, ic, vol->upcase,
>    vol->upcase_len)) {
>   register int rc;
>
>   rc = ntfs_names_collate(name, name_len, al_name,
>     al_name_len, 1, IGNORE_CASE,
>     vol->upcase, vol->upcase_len);
>
>
>
>
>   if (rc == -1)
>    goto not_found;
>
>   if (rc)
>    continue;
># 2041 "attrib.c"
>   rc = ntfs_names_collate(name, name_len, al_name,
>     al_name_len, 1, CASE_SENSITIVE,
>     vol->upcase, vol->upcase_len);
>   if (rc == -1)
>    goto not_found;
>   if (rc)
>    continue;
>  }
>
>
>
>
>
>
>  if (lowest_vcn && (u8*)next_al_entry >= al_start &&
>    (u8*)next_al_entry + 6 < al_end &&
>    (u8*)next_al_entry + (u16)((u16)(next_al_entry->length)) <= al_end &&
>
>    (s64)((s64)(next_al_entry->lowest_vcn)) <=
>     lowest_vcn &&
>    next_al_entry->type == al_entry->type &&
>    next_al_entry->name_length == al_name_len &&
>    ntfs_names_are_equal((ntfschar*)((char*)
>     next_al_entry +
>     next_al_entry->name_offset),
>     next_al_entry->name_length,
>     al_name, al_name_len, CASE_SENSITIVE,
>     vol->upcase, vol->upcase_len))
>   continue;
>is_enumeration:
>  if (((u64)((al_entry->mft_reference) & 0x0000ffffffffffffULL)) == ni->mft_no) {
>   if (((u16)(((al_entry->mft_reference) >> 48) & 0xffff)) !=
>     (u16)((u16)(ni->mrec->sequence_number))) {
>
>    do {} while (0);
>
>    break;
>   }
>  } else {
>
>   if (((u64)((al_entry->mft_reference) & 0x0000ffffffffffffULL)) ==
>     base_ni->mft_no) {
>    ni = ctx->ntfs_ino = base_ni;
>    ctx->mrec = ctx->base_mrec;
>   } else {
>
>    ni = ntfs_extent_inode_open(base_ni,
>      al_entry->mft_reference);
>    if (!ni) {
>     ntfs_log_redirect(__FUNCTION__,"attrib.c",2090,(1 << 8),((void *)0),"Failed to map extent inode");
>     break;
>    }
>    ctx->ntfs_ino = ni;
>    ctx->mrec = ni->mrec;
>   }
>  }
>  a = ctx->attr = (ATTR_RECORD*)((char*)ctx->mrec +
>    (u16)((u16)(ctx->mrec->attrs_offset)));
># 2116 "attrib.c"
>do_next_attr_loop:
>  if ((char*)a < (char*)ctx->mrec || (char*)a > (char*)ctx->mrec +
>    (u32)((u32)(ctx->mrec->bytes_allocated)))
>   break;
>  if (a->type == AT_END)
>   continue;
>  if (!a->length)
>   break;
>  if (al_entry->instance != a->instance)
>   goto do_next_attr;
>
>
>
>
>
>  if (al_entry->type != a->type)
>   break;
>  if (!ntfs_names_are_equal((ntfschar*)((char*)a +
>    (u16)((u16)(a->name_offset))),
>    a->name_length, al_name,
>    al_name_len, CASE_SENSITIVE,
>    vol->upcase, vol->upcase_len))
>   break;
>  ctx->attr = a;
>
>
>
>
>
>  if ((type == AT_UNUSED) || !val || (!a->non_resident &&
>    (u32)((u32)(a->value_length)) == val_len &&
>    !memcmp((char*)a + (u16)((u16)(a->value_offset)),
>    val, val_len))) {
>   return 0;
>  }
>do_next_attr:
>
>  a = (ATTR_RECORD*)((char*)a + (u32)((u32)(a->length)));
>  goto do_next_attr_loop;
> }
> if (ni != base_ni) {
>  ctx->ntfs_ino = base_ni;
>  ctx->mrec = ctx->base_mrec;
>  ctx->attr = ctx->base_attr;
> }
> do {} while (0);
> (*__errno_location ()) = 5;
> return -1;
>not_found:
>
>
>
>
>
> if (type == AT_UNUSED || type == AT_END) {
>  ntfs_attr_reinit_search_ctx(ctx);
>  return ntfs_attr_find(AT_END, name, name_len, ic, val, val_len,
>    ctx);
> }
># 2188 "attrib.c"
> ctx->mrec = ctx->base_mrec;
> ctx->attr = (ATTR_RECORD*)((u8*)ctx->mrec +
>   (u16)((u16)(ctx->mrec->attrs_offset)));
> ctx->is_first = TRUE;
> ctx->ntfs_ino = ctx->base_ntfs_ino;
> ctx->base_ntfs_ino = ((void *)0);
> ctx->base_mrec = ((void *)0);
> ctx->base_attr = ((void *)0);
>
>
>
>
>
>
>
> {
>  int ret;
>
>  do {
>   ret = ntfs_attr_find(type, name, name_len, ic, val,
>     val_len, ctx);
>  } while (!ret);
>  return ret;
> }
>}
># 2281 "attrib.c"
>int ntfs_attr_lookup(const ATTR_TYPES type, const ntfschar *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_volume *vol;
> ntfs_inode *base_ni;
>
> if (!ctx || !ctx->mrec || !ctx->attr || (name && name != AT_UNNAMED &&
>   (!ctx->ntfs_ino || !(vol = ctx->ntfs_ino->vol) ||
>   !vol->upcase || !vol->upcase_len))) {
>  (*__errno_location ()) = 22;
>  return -1;
> }
> if (ctx->base_ntfs_ino)
>  base_ni = ctx->base_ntfs_ino;
> else
>  base_ni = ctx->ntfs_ino;
> if (!base_ni || !(((base_ni)->state) & (1 << (NI_AttrList))) || type == AT_ATTRIBUTE_LIST)
>  return ntfs_attr_find(type, name, name_len, ic, val, val_len,
>    ctx);
> return ntfs_external_attr_find(type, name, name_len, ic, lowest_vcn,
>   val, val_len, ctx);
>}
># 2314 "attrib.c"
>static void ntfs_attr_init_search_ctx(ntfs_attr_search_ctx *ctx,
>  ntfs_inode *ni, MFT_RECORD *mrec)
>{
> if (!mrec)
>  mrec = ni->mrec;
> ctx->mrec = mrec;
>
> ctx->attr = (ATTR_RECORD*)((u8*)mrec + (u16)((u16)(mrec->attrs_offset)));
> ctx->is_first = TRUE;
> ctx->ntfs_ino = ni;
> ctx->al_entry = ((void *)0);
> ctx->base_ntfs_ino = ((void *)0);
> ctx->base_mrec = ((void *)0);
> ctx->base_attr = ((void *)0);
>}
># 2339 "attrib.c"
>void ntfs_attr_reinit_search_ctx(ntfs_attr_search_ctx *ctx)
>{
> if (!ctx->base_ntfs_ino) {
>
>  ctx->is_first = TRUE;
>
>  ctx->attr = (ATTR_RECORD*)((u8*)ctx->mrec +
>    (u16)((u16)(ctx->mrec->attrs_offset)));
>
>
>
>
>  ctx->al_entry = ((void *)0);
>  return;
> }
> ntfs_attr_init_search_ctx(ctx, ctx->base_ntfs_ino, ctx->base_mrec);
> return;
>}
># 2372 "attrib.c"
>ntfs_attr_search_ctx *ntfs_attr_get_search_ctx(ntfs_inode *ni, MFT_RECORD *mrec)
>{
> ntfs_attr_search_ctx *ctx;
>
> if (!ni && !mrec) {
>  (*__errno_location ()) = 22;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",2378,(1 << 8),((void *)0),"NULL arguments");
>  return ((void *)0);
> }
> ctx = ntfs_malloc(sizeof(ntfs_attr_search_ctx));
> if (ctx)
>  ntfs_attr_init_search_ctx(ctx, ni, mrec);
> return ctx;
>}
>
>
>
>
>
>
>
>void ntfs_attr_put_search_ctx(ntfs_attr_search_ctx *ctx)
>{
>
> free(ctx);
>}
># 2413 "attrib.c"
>ATTR_DEF *ntfs_attr_find_in_attrdef(const ntfs_volume *vol,
>  const ATTR_TYPES type)
>{
> ATTR_DEF *ad;
>
> if (!vol || !vol->attrdef || !type) {
>  (*__errno_location ()) = 22;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",2420,(1 << 8),((void *)0),"%s: type=%d", __FUNCTION__, type);
>  return ((void *)0);
> }
> for (ad = vol->attrdef; (u8*)ad - (u8*)vol->attrdef <
>   vol->attrdef_len && ad->type; ++ad) {
>
>  if ((u32)((u32)(ad->type)) < (u32)((u32)(type)))
>   continue;
>
>  if (ad->type == type)
>   return ad;
>
>  break;
> }
> (*__errno_location ()) = 2;
> ntfs_log_redirect(__FUNCTION__,"attrib.c",2435,(1 << 8),((void *)0),"%s: type=%d", __FUNCTION__, type);
> return ((void *)0);
>}
># 2454 "attrib.c"
>int ntfs_attr_size_bounds_check(const ntfs_volume *vol, const ATTR_TYPES type,
>  const s64 size)
>{
> ATTR_DEF *ad;
> s64 min_size, max_size;
>
> if (size < 0) {
>  (*__errno_location ()) = 22;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",2463,(1 << 8),((void *)0),"%s: size=%lld", __FUNCTION__, (long long)size);
>
>  return -1;
> }
>
>
>
>
>
> if (type == AT_ATTRIBUTE_LIST && size > 0x40000) {
>  (*__errno_location ()) = 34;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",2473,(1 << 8),((void *)0),"Too large attrlist (%lld)", (long long)size);
>  return -1;
> }
>
> ad = ntfs_attr_find_in_attrdef(vol, type);
> if (!ad)
>  return -1;
>
> min_size = (s64)((s64)(ad->min_size));
> max_size = (s64)((s64)(ad->max_size));
>
> if ((min_size && (size < min_size)) ||
>     ((max_size > 0) && (size > max_size))) {
>  (*__errno_location ()) = 34;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",2489,(1 << 8),((void *)0),"Attr type %d size check failed (min,size,max=" "%lld,%lld,%lld)", type, (long long)min_size, (long long)size, (long long)max_size);
>
>
>  return -1;
> }
> return 0;
>}
># 2510 "attrib.c"
>int ntfs_attr_can_be_non_resident(const ntfs_volume *vol, const ATTR_TYPES type)
>{
> ATTR_DEF *ad;
>
>
> ad = ntfs_attr_find_in_attrdef(vol, type);
> if (!ad)
>  return -1;
>
> if (ad->flags & ATTR_DEF_RESIDENT) {
>  (*__errno_location ()) = 1;
>  do {} while (0);
>  return -1;
> }
> return 0;
>}
># 2549 "attrib.c"
>int ntfs_attr_can_be_resident(const ntfs_volume *vol, const ATTR_TYPES type)
>{
> if (!vol || !vol->attrdef || !type) {
>  (*__errno_location ()) = 22;
>  return -1;
> }
> if (type != AT_INDEX_ALLOCATION)
>  return 0;
>
> do {} while (0);
> (*__errno_location ()) = 1;
> return -1;
>}
># 2577 "attrib.c"
>int ntfs_make_room_for_attr(MFT_RECORD *m, u8 *pos, u32 size)
>{
> u32 biu;
>
> do {} while (0);
>
>
>
> size = (size + 7) & ~7;
>
>
> if (!m || !pos || pos < (u8*)m || pos + size >
>   (u8*)m + (u32)((u32)(m->bytes_allocated))) {
>  (*__errno_location ()) = 22;
>  return -1;
> }
>
> if (pos - (u8*)m > (int)(u32)((u32)(m->bytes_in_use)) - 8) {
>  (*__errno_location ()) = 22;
>  return -1;
> }
>
> if (!size)
>  return 0;
>
> biu = (u32)((u32)(m->bytes_in_use));
>
> if (biu + size > (u32)((u32)(m->bytes_allocated))) {
>  (*__errno_location ()) = 28;
>  do {} while (0);
>  return -1;
> }
>
> memmove(pos + size, pos, biu - (pos - (u8*)m));
>
> m->bytes_in_use = (u32)((u32)(biu + size));
> return 0;
>}
># 2633 "attrib.c"
>int ntfs_resident_attr_record_add(ntfs_inode *ni, ATTR_TYPES type,
>   ntfschar *name, u8 name_len, u8 *val, u32 size,
>   ATTR_FLAGS flags)
>{
> ntfs_attr_search_ctx *ctx;
> u32 length;
> ATTR_RECORD *a;
> MFT_RECORD *m;
> int err, offset;
> ntfs_inode *base_ni;
>
> do {} while (0);
>
>
> if (!ni || (!name && name_len)) {
>  (*__errno_location ()) = 22;
>  return -1;
> }
>
> if (ntfs_attr_can_be_resident(ni->vol, type)) {
>  if ((*__errno_location ()) == 1)
>   do {} while (0);
>  else
>   do {} while (0);
>  return -1;
> }
>
>
> ctx = ntfs_attr_get_search_ctx(ni, ((void *)0));
> if (!ctx)
>  return -1;
>
>
>
>
>
> if (!ntfs_attr_find(type, name, name_len, CASE_SENSITIVE, val, size,
>   ctx)) {
>  err = 17;
>  do {} while (0);
>  goto put_err_out;
> }
> if ((*__errno_location ()) != 2) {
>  err = 5;
>  goto put_err_out;
> }
> a = ctx->attr;
> m = ctx->mrec;
>
>
> length = __builtin_offsetof (ATTR_RECORD, resident_end) +
>    ((name_len * sizeof(ntfschar) + 7) & ~7) +
>    ((size + 7) & ~7);
> if (ntfs_make_room_for_attr(ctx->mrec, (u8*) ctx->attr, length)) {
>  err = (*__errno_location ());
>  do {} while (0);
>  goto put_err_out;
> }
>
>
> offset = ((u8*)a - (u8*)m);
> a->type = type;
> a->length = (u32)((u32)(length));
> a->non_resident = 0;
> a->name_length = name_len;
> a->name_offset = (u16)((u16)(__builtin_offsetof (ATTR_RECORD, resident_end)));
> a->flags = flags;
> a->instance = m->next_attr_instance;
> a->value_length = (u32)((u32)(size));
> a->value_offset = (u16)((u16)(length - ((size + 7) & ~7)));
> if (val)
>  memcpy((u8*)a + (u16)((u16)(a->value_offset)), val, size);
> else
>  memset((u8*)a + (u16)((u16)(a->value_offset)), 0, size);
> if (type == AT_FILE_NAME)
>  a->resident_flags = RESIDENT_ATTR_IS_INDEXED;
> else
>  a->resident_flags = 0;
> if (name_len)
>  memcpy((u8*)a + (u16)((u16)(a->name_offset)),
>   name, sizeof(ntfschar) * name_len);
> m->next_attr_instance =
>  (u16)((u16)(((u16)((u16)(m->next_attr_instance)) + 1) & 0xffff));
> if (ni->nr_extents == -1)
>  base_ni = ni->base_ni;
> else
>  base_ni = ni;
> if (type != AT_ATTRIBUTE_LIST && (((base_ni)->state) & (1 << (NI_AttrList)))) {
>  if (ntfs_attrlist_entry_add(ni, a)) {
>   err = (*__errno_location ());
>   ntfs_attr_record_resize(m, a, 0);
>   do {} while (0);
>
>   goto put_err_out;
>  }
> }
> ntfs_inode_mark_dirty(ni);
> ntfs_attr_put_search_ctx(ctx);
> return offset;
>put_err_out:
> ntfs_attr_put_search_ctx(ctx);
> (*__errno_location ()) = err;
> return -1;
>}
># 2756 "attrib.c"
>int ntfs_non_resident_attr_record_add(ntfs_inode *ni, ATTR_TYPES type,
>  ntfschar *name, u8 name_len, VCN lowest_vcn, int dataruns_size,
>  ATTR_FLAGS flags)
>{
> ntfs_attr_search_ctx *ctx;
> u32 length;
> ATTR_RECORD *a;
> MFT_RECORD *m;
> ntfs_inode *base_ni;
> int err, offset;
>
> do {} while (0);
>
>
>
>
> if (!ni || dataruns_size <= 0 || (!name && name_len)) {
>  (*__errno_location ()) = 22;
>  return -1;
> }
>
> if (ntfs_attr_can_be_non_resident(ni->vol, type)) {
>  if ((*__errno_location ()) == 1)
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",2779,(1 << 8),((void *)0),"Attribute can't be non resident");
>  else
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",2781,(1 << 8),((void *)0),"ntfs_attr_can_be_non_resident failed");
>  return -1;
> }
>
>
> ctx = ntfs_attr_get_search_ctx(ni, ((void *)0));
> if (!ctx)
>  return -1;
>
>
>
>
>
> if (!ntfs_attr_find(type, name, name_len, CASE_SENSITIVE, ((void *)0), 0,
>   ctx)) {
>  err = 17;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",2797,(1 << 8),((void *)0),"Attribute 0x%x already present", type);
>  goto put_err_out;
> }
> if ((*__errno_location ()) != 2) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",2801,(1 << 8),((void *)0),"ntfs_attr_find failed");
>  err = 5;
>  goto put_err_out;
> }
> a = ctx->attr;
> m = ctx->mrec;
>
>
> dataruns_size = (dataruns_size + 7) & ~7;
> length = __builtin_offsetof (ATTR_RECORD, compressed_size) + ((sizeof(ntfschar) *
>   name_len + 7) & ~7) + dataruns_size +
>   ((flags & (ATTR_IS_COMPRESSED | ATTR_IS_SPARSE)) ?
>   sizeof(a->compressed_size) : 0);
> if (ntfs_make_room_for_attr(ctx->mrec, (u8*) ctx->attr, length)) {
>  err = (*__errno_location ());
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",2816,(1 << 8),((void *)0),"Failed to make room for attribute");
>  goto put_err_out;
> }
>
>
> a->type = type;
> a->length = (u32)((u32)(length));
> a->non_resident = 1;
> a->name_length = name_len;
> a->name_offset = (u16)((u16)(__builtin_offsetof (ATTR_RECORD, compressed_size) + ((flags & (ATTR_IS_COMPRESSED | ATTR_IS_SPARSE)) ? sizeof(a->compressed_size) : 0)));
>
>
> a->flags = flags;
> a->instance = m->next_attr_instance;
> a->lowest_vcn = (s64)((s64)(lowest_vcn));
> a->mapping_pairs_offset = (u16)((u16)(length - dataruns_size));
> a->compression_unit = (flags & ATTR_IS_COMPRESSED) ? 4 : 0;
>
> if (!lowest_vcn) {
>  a->highest_vcn = (s64)((s64)(-1));
>  a->allocated_size = 0;
>  a->data_size = 0;
>  a->initialized_size = 0;
>
>  *((u8*)a + (u16)((u16)(a->mapping_pairs_offset))) = 0;
> }
> if (name_len)
>  memcpy((u8*)a + (u16)((u16)(a->name_offset)),
>   name, sizeof(ntfschar) * name_len);
> m->next_attr_instance =
>  (u16)((u16)(((u16)((u16)(m->next_attr_instance)) + 1) & 0xffff));
> if (ni->nr_extents == -1)
>  base_ni = ni->base_ni;
> else
>  base_ni = ni;
> if (type != AT_ATTRIBUTE_LIST && (((base_ni)->state) & (1 << (NI_AttrList)))) {
>  if (ntfs_attrlist_entry_add(ni, a)) {
>   err = (*__errno_location ());
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",2854,(1 << 8),((void *)0),"Failed add attr entry to attrlist");
>   ntfs_attr_record_resize(m, a, 0);
>   goto put_err_out;
>  }
> }
> ntfs_inode_mark_dirty(ni);
>
>
>
>
>
> ntfs_attr_reinit_search_ctx(ctx);
> if (ntfs_attr_lookup(type, name, name_len, CASE_SENSITIVE,
>     lowest_vcn, ((void *)0), 0, ctx)) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",2868,(1 << 8),((void *)0),"%s: attribute lookup failed", __FUNCTION__);
>  ntfs_attr_put_search_ctx(ctx);
>  return -1;
>
> }
> offset = (u8*)ctx->attr - (u8*)ctx->mrec;
> ntfs_attr_put_search_ctx(ctx);
> return offset;
>put_err_out:
> ntfs_attr_put_search_ctx(ctx);
> (*__errno_location ()) = err;
> return -1;
>}
># 2894 "attrib.c"
>int ntfs_attr_record_rm(ntfs_attr_search_ctx *ctx)
>{
> ntfs_inode *base_ni, *ni;
> ATTR_TYPES type;
> int err;
>
> if (!ctx || !ctx->ntfs_ino || !ctx->mrec || !ctx->attr) {
>  (*__errno_location ()) = 22;
>  return -1;
> }
>
> do {} while (0);
>
>
> type = ctx->attr->type;
> ni = ctx->ntfs_ino;
> if (ctx->base_ntfs_ino)
>  base_ni = ctx->base_ntfs_ino;
> else
>  base_ni = ctx->ntfs_ino;
>
>
> if (ntfs_attr_record_resize(ctx->mrec, ctx->attr, 0)) {
>  do {} while (0);
>
>  if ((((base_ni)->state) & (1 << (NI_AttrList))) && type != AT_ATTRIBUTE_LIST)
>   if (ntfs_attrlist_entry_add(ni, ctx->attr))
>    do {} while (0);
>
>  err = 5;
>  return -1;
> }
> ntfs_inode_mark_dirty(ni);
>
>
>
>
>
> if ((((base_ni)->state) & (1 << (NI_AttrList))) && type != AT_ATTRIBUTE_LIST) {
>  if (ntfs_attrlist_entry_rm(ctx)) {
>   do {} while (0);
>
>   return -1;
>  }
> }
>
>
> if (type == AT_ATTRIBUTE_LIST) {
>  if ((((base_ni)->state) & (1 << (NI_AttrList))) && base_ni->attr_list)
>   free(base_ni->attr_list);
>  base_ni->attr_list = ((void *)0);
>  ((base_ni)->state) &= ~(1 << (NI_AttrList));
>  ((base_ni)->state) &= ~(1 << (NI_AttrListDirty));
> }
>
>
> if ((u32)((u32)(ctx->mrec->bytes_in_use)) -
>   (u16)((u16)(ctx->mrec->attrs_offset)) == 8) {
>  if (ntfs_mft_record_free(ni->vol, ni)) {
>
>   do {} while (0);
>   (*__errno_location ()) = 5;
>   return -1;
>  }
>
>  if (ni == base_ni)
>   return 0;
> }
>
> if (type == AT_ATTRIBUTE_LIST || !(((base_ni)->state) & (1 << (NI_AttrList))))
>  return 0;
>
>
> if (!ntfs_attrlist_need(base_ni)) {
>  ntfs_attr_reinit_search_ctx(ctx);
>  if (ntfs_attr_lookup(AT_ATTRIBUTE_LIST, ((void *)0), 0, CASE_SENSITIVE,
>    0, ((void *)0), 0, ctx)) {
>
>
>
>
>
>   do {} while (0);
>
>   return 0;
>  }
>
>  if (ctx->attr->non_resident) {
>   runlist *al_rl;
>
>   al_rl = ntfs_mapping_pairs_decompress(base_ni->vol,
>     ctx->attr, ((void *)0));
>   if (!al_rl) {
>    do {} while (0);
>
>    return 0;
>   }
>   if (ntfs_cluster_free_from_rl(base_ni->vol, al_rl)) {
>    do {} while (0);
>
>
>   }
>   free(al_rl);
>  }
>
>  if (ntfs_attr_record_rm(ctx)) {
>
>
>
>
>
>   do {} while (0);
>
>   return 0;
>  }
> }
> return 0;
>}
># 3039 "attrib.c"
>int ntfs_attr_add(ntfs_inode *ni, ATTR_TYPES type,
>  ntfschar *name, u8 name_len, u8 *val, s64 size)
>{
> u32 attr_rec_size;
> int err, i, offset;
> BOOL is_resident;
> ntfs_inode *attr_ni;
> ntfs_attr *na;
>
> if (!ni || size < 0 || type == AT_ATTRIBUTE_LIST) {
>  (*__errno_location ()) = 22;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3051,(1 << 8),((void *)0),"%s: ni=%p  size=%lld", __FUNCTION__, ni, (long long)size);
>
>  return -1;
> }
>
> do {} while (0);
>
>
> if (ni->nr_extents == -1)
>  ni = ni->base_ni;
>
>
> if (ntfs_attr_size_bounds_check(ni->vol, type, size)) {
>  if ((*__errno_location ()) == 2)
>   (*__errno_location ()) = 5;
>  return -1;
> }
>
>
> if (ntfs_attr_can_be_non_resident(ni->vol, type)) {
>  if ((*__errno_location ()) != 1) {
>   err = (*__errno_location ());
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",3072,(1 << 8),((void *)0),"ntfs_attr_can_be_non_resident failed");
>   goto err_out;
>  }
>
>  if (!val) {
>   (*__errno_location ()) = 22;
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",3079,(1 << 8),((void *)0),"val is mandatory for always resident " "attributes");
>
>   return -1;
>  }
>  if (size > ni->vol->mft_record_size) {
>   (*__errno_location ()) = 34;
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",3084,(1 << 8),((void *)0),"Attribute is too big");
>   return -1;
>  }
> }
>
>
>
>
>
> if (!ntfs_attr_can_be_resident(ni->vol, type)) {
>  is_resident = TRUE;
> } else {
>  if ((*__errno_location ()) != 1) {
>   err = (*__errno_location ());
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",3098,(1 << 8),((void *)0),"ntfs_attr_can_be_resident failed");
>   goto err_out;
>  }
>  is_resident = FALSE;
> }
>
> if (is_resident)
>  attr_rec_size = __builtin_offsetof (ATTR_RECORD, resident_end) +
>    ((name_len * sizeof(ntfschar) + 7) & ~7) +
>    ((size + 7) & ~7);
> else
>  attr_rec_size = __builtin_offsetof (ATTR_RECORD, non_resident_end) +
>    ((name_len * sizeof(ntfschar) + 7) & ~7) + 8;
>
>
>
>
>
> if ((u32)((u32)(ni->mrec->bytes_allocated)) -
>   (u32)((u32)(ni->mrec->bytes_in_use)) >= attr_rec_size) {
>  attr_ni = ni;
>  goto add_attr_record;
> }
>
>
> if (ntfs_inode_attach_all_extents(ni)) {
>  err = (*__errno_location ());
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3125,(1 << 8),((void *)0),"Failed to attach all extents to inode");
>  goto err_out;
> }
> for (i = 0; i < ni->nr_extents; i++) {
>  attr_ni = ni->extent_nis[i];
>  if ((u32)((u32)(attr_ni->mrec->bytes_allocated)) -
>    (u32)((u32)(attr_ni->mrec->bytes_in_use)) >=
>    attr_rec_size)
>   goto add_attr_record;
> }
>
>
> if (!(((ni)->state) & (1 << (NI_AttrList)))) {
>
>  if (ntfs_inode_add_attrlist(ni)) {
>   err = (*__errno_location ());
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",3141,(1 << 8),((void *)0),"Failed to add attribute list");
>   goto err_out;
>  }
>  return ntfs_attr_add(ni, type, name, name_len, val, size);
> }
>
> attr_ni = ntfs_mft_record_alloc(ni->vol, ni);
> if (!attr_ni) {
>  err = (*__errno_location ());
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3150,(1 << 8),((void *)0),"Failed to allocate extent record");
>  goto err_out;
> }
>
>add_attr_record:
> if (is_resident) {
>
>  offset = ntfs_resident_attr_record_add(attr_ni, type, name,
>    name_len, val, size, 0);
>  if (offset < 0) {
>   err = (*__errno_location ());
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",3161,(1 << 8),((void *)0),"Failed to add resident attribute");
>   goto free_err_out;
>  }
>  return 0;
> }
>
>
> offset = ntfs_non_resident_attr_record_add(attr_ni, type, name,
>    name_len, 0, 8, 0);
> if (offset < 0) {
>  err = (*__errno_location ());
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3172,(1 << 8),((void *)0),"Failed to add non resident attribute");
>  goto free_err_out;
> }
>
>
> if (!size)
>  return 0;
>
>
> na = ntfs_attr_open(ni, type, name, name_len);
> if (!na) {
>  err = (*__errno_location ());
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3184,(1 << 8),((void *)0),"Failed to open just added attribute");
>  goto rm_attr_err_out;
> }
>
> if (ntfs_attr_truncate(na, size) ||
>   (val && (ntfs_attr_pwrite(na, 0, size, val) != size))) {
>  err = (*__errno_location ());
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3191,(1 << 8),((void *)0),"Failed to initialize just added attribute");
>  if (ntfs_attr_rm(na))
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",3193,(1 << 8),((void *)0),"Failed to remove just added attribute");
>  ntfs_attr_close(na);
>  goto err_out;
> }
> ntfs_attr_close(na);
> return 0;
>
>rm_attr_err_out:
>
> if (ntfs_attr_record_resize(attr_ni->mrec,
>   (ATTR_RECORD*)((u8*)attr_ni->mrec + offset), 0))
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3204,(1 << 8),((void *)0),"Failed to remove just added attribute #2");
>free_err_out:
>
> if ((u32)((u32)(attr_ni->mrec->bytes_in_use)) -
>   (u32)((u32)(attr_ni->mrec->attrs_offset)) == 8)
>  if (ntfs_mft_record_free(attr_ni->vol, attr_ni))
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",3210,(1 << 8),((void *)0),"Failed to free MFT record");
>err_out:
> (*__errno_location ()) = err;
> return -1;
>}
># 3225 "attrib.c"
>int ntfs_attr_rm(ntfs_attr *na)
>{
> ntfs_attr_search_ctx *ctx;
> int ret = 0;
>
> if (!na) {
>  do {} while (0);
>  (*__errno_location ()) = 22;
>  return -1;
> }
>
> do {} while (0);
>
>
>
> if ((((na)->state) & (1 << (NA_NonResident)))) {
>  if (ntfs_attr_map_whole_runlist(na))
>   return -1;
>  if (ntfs_cluster_free(na->ni->vol, na, 0, -1) < 0) {
>   do {} while (0);
>
>   ret = -1;
>  }
> }
>
>
> ctx = ntfs_attr_get_search_ctx(na->ni, ((void *)0));
> if (!ctx)
>  return -1;
> while (!ntfs_attr_lookup(na->type, na->name, na->name_len,
>    CASE_SENSITIVE, 0, ((void *)0), 0, ctx)) {
>  if (ntfs_attr_record_rm(ctx)) {
>   do {} while (0);
>
>   ret = -1;
>  }
>  ntfs_attr_reinit_search_ctx(ctx);
> }
> if ((*__errno_location ()) != 2) {
>  do {} while (0);
>
>  ret = -1;
> }
>
> return ret;
>}
># 3289 "attrib.c"
>int ntfs_attr_record_resize(MFT_RECORD *m, ATTR_RECORD *a, u32 new_size)
>{
> u32 old_size, alloc_size, attr_size;
>
> old_size = (u32)((u32)(m->bytes_in_use));
> alloc_size = (u32)((u32)(m->bytes_allocated));
> attr_size = (u32)((u32)(a->length));
>
> do {} while (0);
>
>
>
>
> new_size = (new_size + 7) & ~7;
>
>
> if (new_size != attr_size) {
>
>  u32 new_muse = old_size - attr_size + new_size;
>
>
>  if (new_muse > alloc_size) {
>   (*__errno_location ()) = 28;
>   do {} while (0);
>
>   return -1;
>  }
>
>
>  memmove((u8 *)a + new_size, (u8 *)a + attr_size,
>   old_size - ((u8 *)a - (u8 *)m) - attr_size);
>
>
>  m->bytes_in_use = (u32)((u32)(new_muse));
>
>
>  if (new_size >= __builtin_offsetof (ATTR_REC, length) + sizeof(a->length))
>   a->length = (u32)((u32)(new_size));
> }
> return 0;
>}
># 3345 "attrib.c"
>int ntfs_resident_attr_value_resize(MFT_RECORD *m, ATTR_RECORD *a,
>  const u32 new_size)
>{
> do {} while (0);
>
>
> if (ntfs_attr_record_resize(m, a, ((u16)((u16)(a->value_offset)) +
>   new_size + 7) & ~7) < 0)
>  return -1;
>
>
>
>
> if (new_size > (u32)((u32)(a->value_length)))
>  memset((u8*)a + (u16)((u16)(a->value_offset)) +
>    (u32)((u32)(a->value_length)), 0, new_size -
>    (u32)((u32)(a->value_length)));
>
> a->value_length = (u32)((u32)(new_size));
> return 0;
>}
># 3377 "attrib.c"
>int ntfs_attr_record_move_to(ntfs_attr_search_ctx *ctx, ntfs_inode *ni)
>{
> ntfs_attr_search_ctx *nctx;
> ATTR_RECORD *a;
> int err;
>
> if (!ctx || !ctx->attr || !ctx->ntfs_ino || !ni) {
>  do {} while (0);
>  (*__errno_location ()) = 22;
>  return -1;
> }
>
> do {} while (0);
>
>
>
>
>
> if (ctx->ntfs_ino == ni)
>  return 0;
>
> if (!ctx->al_entry) {
>  do {} while (0);
>
>  (*__errno_location ()) = 22;
>  return -1;
> }
>
>
> a = ctx->attr;
> nctx = ntfs_attr_get_search_ctx(ni, ((void *)0));
> if (!nctx)
>  return -1;
>
>
>
>
>
>
> if (!ntfs_attr_find(a->type, (ntfschar*)((u8*)a + (u16)((u16)(a->name_offset))), a->name_length, CASE_SENSITIVE, ((void *)0),
>
>   0, nctx)) {
>  do {} while (0);
>
>  err = 17;
>  goto put_err_out;
> }
> if ((*__errno_location ()) != 2) {
>  err = (*__errno_location ());
>  do {} while (0);
>  goto put_err_out;
> }
>
>
> if (ntfs_make_room_for_attr(ni->mrec, (u8*) nctx->attr,
>     (u32)((u32)(a->length)))) {
>  err = (*__errno_location ());
>  do {} while (0);
>  goto put_err_out;
> }
> memcpy(nctx->attr, a, (u32)((u32)(a->length)));
> nctx->attr->instance = nctx->mrec->next_attr_instance;
> nctx->mrec->next_attr_instance = (u16)((u16)(((u16)((u16)(nctx->mrec->next_attr_instance)) + 1) & 0xffff));
>
> ntfs_attr_record_resize(ctx->mrec, a, 0);
> ntfs_inode_mark_dirty(ctx->ntfs_ino);
> ntfs_inode_mark_dirty(ni);
>
>
> ctx->al_entry->mft_reference =
>  (((MFT_REF)(((MFT_REF)((u16)((u16)(ni->mrec->sequence_number))) << 48) | ((MFT_REF)(ni->mft_no) & 0x0000ffffffffffffULL))));
> ctx->al_entry->instance = nctx->attr->instance;
> ntfs_attrlist_mark_dirty(ni);
>
> ntfs_attr_put_search_ctx(nctx);
> return 0;
>put_err_out:
> ntfs_attr_put_search_ctx(nctx);
> (*__errno_location ()) = err;
> return -1;
>}
># 3472 "attrib.c"
>int ntfs_attr_record_move_away(ntfs_attr_search_ctx *ctx, int extra)
>{
> ntfs_inode *base_ni, *ni;
> MFT_RECORD *m;
> int i;
>
> if (!ctx || !ctx->attr || !ctx->ntfs_ino || extra < 0) {
>  (*__errno_location ()) = 22;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3481,(1 << 8),((void *)0),"%s: ctx=%p ctx->attr=%p extra=%d", __FUNCTION__, ctx, ctx ? ctx->attr : ((void *)0), extra);
>
>  return -1;
> }
>
> do {} while (0);
>
>
>
> if (ctx->ntfs_ino->nr_extents == -1)
>  base_ni = ctx->base_ntfs_ino;
> else
>  base_ni = ctx->ntfs_ino;
>
> if (!(((base_ni)->state) & (1 << (NI_AttrList)))) {
>  (*__errno_location ()) = 22;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3497,(1 << 8),((void *)0),"Inode %llu has no attrlist", (unsigned long long)base_ni->mft_no);
>
>  return -1;
> }
>
> if (ntfs_inode_attach_all_extents(ctx->ntfs_ino)) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3503,(1 << 8),((void *)0),"Couldn't attach extents, inode=%llu", (unsigned long long)base_ni->mft_no);
>
>  return -1;
> }
>
>
> for (i = 0; i < base_ni->nr_extents; i++) {
>  ni = base_ni->extent_nis[i];
>  m = ni->mrec;
>
>  if (ctx->ntfs_ino->mft_no == ni->mft_no)
>   continue;
>
>  if ((u32)((u32)(m->bytes_allocated)) -
>    (u32)((u32)(m->bytes_in_use)) <
>    (u32)((u32)(ctx->attr->length)) + extra)
>   continue;
>
>
>
>
>
>
>  if (!ntfs_attr_record_move_to(ctx, ni))
>   return 0;
> }
>
>
>
>
>
> ni = ntfs_mft_record_alloc(base_ni->vol, base_ni);
> if (!ni) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3535,(1 << 8),((void *)0),"Couldn't allocate MFT record");
>  return -1;
> }
> if (ntfs_attr_record_move_to(ctx, ni)) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3539,(1 << 8),((void *)0),"Couldn't move attribute to MFT record");
>  return -1;
> }
> return 0;
>}
># 3564 "attrib.c"
>static int ntfs_attr_make_non_resident(ntfs_attr *na,
>  ntfs_attr_search_ctx *ctx)
>{
> s64 new_allocated_size, bw;
> ntfs_volume *vol = na->ni->vol;
> ATTR_REC *a = ctx->attr;
> runlist *rl;
> int mp_size, mp_ofs, name_ofs, arec_size, err;
>
> do {} while (0);
>
>
>
> if ((((na)->state) & (1 << (NA_NonResident)))) {
>  do {} while (0);
>
>  (*__errno_location ()) = 22;
>  return -1;
> }
>
>
> if (ntfs_attr_can_be_non_resident(vol, na->type))
>  return -1;
>
> new_allocated_size = ((u32)((u32)(a->value_length)) + vol->cluster_size
>   - 1) & ~(vol->cluster_size - 1);
>
> if (new_allocated_size > 0) {
>
>  rl = ntfs_cluster_alloc(vol, 0, new_allocated_size >>
>    vol->cluster_size_bits, -1, DATA_ZONE);
>  if (!rl) {
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",3596,(1 << 8),((void *)0),"Failed to allocate clusters");
>   return -1;
>  }
> } else
>  rl = ((void *)0);
>
>
>
>
> ((na)->state) |= 1 << (NA_NonResident);
> na->rl = rl;
> na->allocated_size = new_allocated_size;
> na->data_size = na->initialized_size = (u32)((u32)(a->value_length));
>
>
>
>
> NAttrClearCompressed(na);
> NAttrClearSparse(na);
> NAttrClearEncrypted(na);
>
> if (rl) {
>
>  bw = ntfs_attr_pwrite(na, 0, (u32)((u32)(a->value_length)),
>    (u8*)a + (u16)((u16)(a->value_offset)));
>  if (bw != (u32)((u32)(a->value_length))) {
>   err = (*__errno_location ());
>   do {} while (0);
>
>
>   if (bw >= 0)
>    err = 5;
>   goto cluster_free_err_out;
>  }
> }
>
> mp_size = ntfs_get_size_for_mapping_pairs(vol, rl, 0);
> if (mp_size < 0) {
>  err = (*__errno_location ());
>  do {} while (0);
>
>  goto cluster_free_err_out;
> }
>
> name_ofs = (sizeof(ATTR_REC) - sizeof(a->compressed_size) + 7) & ~7;
> mp_ofs = (name_ofs + a->name_length * sizeof(ntfschar) + 7) & ~7;
>
>
>
>
>
> arec_size = (mp_ofs + mp_size + 7) & ~7;
>
>
> if (ntfs_attr_record_resize(ctx->mrec, a, arec_size) < 0) {
>  err = (*__errno_location ());
>  goto cluster_free_err_out;
> }
>
>
>
>
>
> a->non_resident = 1;
>
>
> if (a->name_length)
>  memmove((u8*)a + name_ofs, (u8*)a + (u16)((u16)(a->name_offset)),
>    a->name_length * sizeof(ntfschar));
> a->name_offset = (u16)((u16)(name_ofs));
>
>
> a->flags &= ~(ATTR_IS_SPARSE | ATTR_IS_ENCRYPTED |
>   ATTR_COMPRESSION_MASK);
>
>
> a->lowest_vcn = (s64)((s64)(0));
> a->highest_vcn = (s64)((s64)((new_allocated_size - 1) >> vol->cluster_size_bits));
>
>
> a->mapping_pairs_offset = (u16)((u16)(mp_ofs));
>
> a->compression_unit = 0;
>
> memset(&a->reserved1, 0, sizeof(a->reserved1));
>
> a->allocated_size = (s64)((s64)(new_allocated_size));
> a->data_size = a->initialized_size = (s64)((s64)(na->data_size));
>
>
> if (ntfs_mapping_pairs_build(vol, (u8*)a + mp_ofs, arec_size - mp_ofs,
>   rl, 0, ((void *)0)) < 0) {
>
>  do {} while (0);
>
>
>
>  return -1;
> }
>
>
> return 0;
>
>cluster_free_err_out:
> if (rl && ntfs_cluster_free(vol, na, 0, -1) < 0)
>  do {} while (0);
>
> ((na)->state) &= ~(1 << (NA_NonResident));
> na->allocated_size = na->data_size;
> na->rl = ((void *)0);
> free(rl);
> (*__errno_location ()) = err;
> return -1;
>}
># 3727 "attrib.c"
>static int ntfs_resident_attr_resize(ntfs_attr *na, const s64 newsize)
>{
> ntfs_attr_search_ctx *ctx;
> ntfs_volume *vol;
> ntfs_inode *ni;
> int err, ret = (-1);
>
> do {} while (0);
>
>
>
>
> ctx = ntfs_attr_get_search_ctx(na->ni, ((void *)0));
> if (!ctx)
>  return -1;
> if (ntfs_attr_lookup(na->type, na->name, na->name_len, 0, 0, ((void *)0), 0,
>   ctx)) {
>  err = (*__errno_location ());
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3745,(1 << 8),((void *)0),"ntfs_attr_lookup failed");
>  goto put_err_out;
> }
> vol = na->ni->vol;
>
>
>
>
> if (ntfs_attr_size_bounds_check(vol, na->type, newsize) < 0) {
>  err = (*__errno_location ());
>  if (err == 2)
>   err = 5;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3757,(1 << 8),((void *)0),"%s: bounds check failed", __FUNCTION__);
>  goto put_err_out;
> }
>
>
>
>
>
> if (newsize < vol->mft_record_size) {
>
>  if (!ntfs_resident_attr_value_resize(ctx->mrec, ctx->attr,
>    newsize)) {
>
>   na->data_size = na->initialized_size = newsize;
>   na->allocated_size = (newsize + 7) & ~7;
>   if (NAttrCompressed(na) || NAttrSparse(na))
>    na->compressed_size = na->allocated_size;
>   if (na->type == AT_DATA && na->name == AT_UNNAMED) {
>    na->ni->data_size = na->data_size;
>    na->ni->allocated_size = na->allocated_size;
>    ((na->ni)->state) |= 1 << (NI_FileNameDirty);
>   }
>   goto resize_done;
>  }
> }
>
>
>
> if (!ntfs_attr_make_non_resident(na, ctx)) {
>  ntfs_inode_mark_dirty(ctx->ntfs_ino);
>  ntfs_attr_put_search_ctx(ctx);
>
>  return ntfs_attr_truncate(na, newsize);
> } else if ((*__errno_location ()) != 28 && (*__errno_location ()) != 1) {
>  err = (*__errno_location ());
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3792,(1 << 8),((void *)0),"Failed to make attribute non-resident");
>  goto put_err_out;
> }
>
>
> ntfs_attr_init_search_ctx(ctx, ((void *)0), na->ni->mrec);
> while (!ntfs_attr_lookup(AT_UNUSED, ((void *)0), 0, 0, 0, ((void *)0), 0, ctx)) {
>  ntfs_attr *tna;
>  ATTR_RECORD *a;
>
>  a = ctx->attr;
>  if (a->non_resident)
>   continue;
>
>
>
>
>
>  if ((u32)((u32)(a->length)) <= __builtin_offsetof (ATTR_RECORD, compressed_size) + ((a->name_length *
>
>    sizeof(ntfschar) + 7) & ~7) + 8)
>   continue;
>
>  tna = ntfs_attr_open(na->ni, a->type, (ntfschar*)((u8*)a +
>    (u16)((u16)(a->name_offset))), a->name_length);
>  if (!tna) {
>   err = (*__errno_location ());
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",3819,(1 << 8),((void *)0),"Couldn't open attribute");
>   goto put_err_out;
>  }
>  if (ntfs_attr_make_non_resident(tna, ctx)) {
>   ntfs_attr_close(tna);
>   continue;
>  }
>  ntfs_inode_mark_dirty(tna->ni);
>  ntfs_attr_close(tna);
>  ntfs_attr_put_search_ctx(ctx);
>  return ntfs_resident_attr_resize(na, newsize);
> }
>
> if ((*__errno_location ()) != 2) {
>  err = (*__errno_location ());
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3834,(1 << 8),((void *)0),"%s: Attribute lookup failed 1", __FUNCTION__);
>  goto put_err_out;
> }
>
>
> if (na->type == AT_ATTRIBUTE_LIST) {
>  ntfs_attr_put_search_ctx(ctx);
>  if (ntfs_inode_free_space(na->ni, __builtin_offsetof (ATTR_RECORD, non_resident_end) + 8)) {
>
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",3844,(1 << 8),((void *)0),"Couldn't free space in the MFT record to " "make attribute list non resident");
>
>   return -1;
>  }
>  return ntfs_resident_attr_resize(na, newsize);
> }
>
>
>
>
>
>
>
> ntfs_attr_init_search_ctx(ctx, na->ni, ((void *)0));
> if (ntfs_attr_lookup(na->type, na->name, na->name_len, CASE_SENSITIVE,
>   0, ((void *)0), 0, ctx)) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3859,(1 << 8),((void *)0),"%s: Attribute lookup failed 2", __FUNCTION__);
>  err = (*__errno_location ());
>  goto put_err_out;
> }
>
>
>
>
>
> if ((u32)((u32)(ctx->mrec->bytes_in_use)) ==
>   (u16)((u16)(ctx->mrec->attrs_offset)) +
>   (u32)((u32)(ctx->attr->length)) + 8) {
>  err = 28;
>  do {} while (0);
>  ret = (-2);
>  goto put_err_out;
> }
>
>
> if (na->ni->nr_extents == -1)
>  ni = na->ni->base_ni;
> else
>  ni = na->ni;
> if (!(((ni)->state) & (1 << (NI_AttrList)))) {
>  ntfs_attr_put_search_ctx(ctx);
>  if (ntfs_inode_add_attrlist(ni))
>   return -1;
>  return ntfs_resident_attr_resize(na, newsize);
> }
>
> ni = ntfs_mft_record_alloc(vol, ni);
> if (!ni) {
>  err = (*__errno_location ());
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3892,(1 << 8),((void *)0),"Couldn't allocate new MFT record");
>  goto put_err_out;
> }
>
> if (ntfs_attr_record_move_to(ctx, ni)) {
>  err = (*__errno_location ());
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",3898,(1 << 8),((void *)0),"Couldn't move attribute to new MFT record");
>  goto put_err_out;
> }
>
> if (na->ni->nr_extents == -1)
>  na->ni = ni;
>
> ntfs_attr_put_search_ctx(ctx);
>
> return ntfs_resident_attr_resize(na, newsize);
>
>resize_done:
>
>
>
>
> ntfs_inode_mark_dirty(ctx->ntfs_ino);
> ntfs_attr_put_search_ctx(ctx);
> return 0;
>put_err_out:
> ntfs_attr_put_search_ctx(ctx);
> (*__errno_location ()) = err;
> return ret;
>}
># 3942 "attrib.c"
>static int ntfs_attr_make_resident(ntfs_attr *na, ntfs_attr_search_ctx *ctx)
>{
> ntfs_volume *vol = na->ni->vol;
> ATTR_REC *a = ctx->attr;
> int name_ofs, val_ofs, err = 5;
> s64 arec_size, bytes_read;
>
> do {} while (0);
>
>
>
> if ((s64)((s64)(a->lowest_vcn))) {
>  do {} while (0);
>
>  err = 22;
>  return -1;
> }
>
>
> if (!(((na)->state) & (1 << (NA_NonResident)))) {
>  do {} while (0);
>
>  (*__errno_location ()) = 22;
>  return -1;
> }
>
>
> if (na->type == AT_BITMAP && na->ni->mft_no == FILE_MFT) {
>  (*__errno_location ()) = 1;
>  return -1;
> }
>
>
> if (ntfs_attr_can_be_resident(vol, na->type))
>  return -1;
>
> if (NAttrCompressed(na) || NAttrEncrypted(na)) {
>  do {} while (0);
>
>  (*__errno_location ()) = 95;
>  return -1;
> }
>
>
> name_ofs = 24;
> val_ofs = (name_ofs + a->name_length * sizeof(ntfschar) + 7) & ~7;
> arec_size = (val_ofs + na->data_size + 7) & ~7;
>
>
> if ((u32)((u32)(ctx->mrec->bytes_in_use)) - (u32)((u32)(a->length)) +
>   arec_size > (u32)((u32)(ctx->mrec->bytes_allocated))) {
>  (*__errno_location ()) = 28;
>  do {} while (0);
>  return -1;
> }
>
>
> if (ntfs_attr_map_whole_runlist(na))
>  return -1;
>
>
> if (a->name_length) {
>  memmove((u8*)a + name_ofs, (u8*)a + (u16)((u16)(a->name_offset)),
>    a->name_length * sizeof(ntfschar));
> }
> a->name_offset = (u16)((u16)(name_ofs));
>
>
> if (ntfs_attr_record_resize(ctx->mrec, a, arec_size) < 0) {
>
>
>
>
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",4017,(1 << 7),((void *)0),"BUG! Failed to resize attribute record. " "Please report to the %s.  Aborting...\n", "ntfs-3g-devel@lists.sf.net");
>
>
>  (*__errno_location ()) = 5;
>  return -1;
> }
>
>
> a->non_resident = 0;
> a->flags = 0;
> a->value_length = (u32)((u32)(na->data_size));
> a->value_offset = (u16)((u16)(val_ofs));
>
>
>
>
>
> if (a->type == AT_FILE_NAME)
>  a->resident_flags = RESIDENT_ATTR_IS_INDEXED;
> else
>  a->resident_flags = 0;
> a->reservedR = 0;
>
>
> if (na->initialized_size > na->data_size)
>  na->initialized_size = na->data_size;
>
>
> bytes_read = ntfs_rl_pread(vol, na->rl, 0, na->initialized_size,
>   (u8*)a + val_ofs);
> if (bytes_read != na->initialized_size) {
>  if (bytes_read < 0)
>   err = (*__errno_location ());
>  do {} while (0);
>
>
>  (*__errno_location ()) = err;
>  return -1;
> }
>
>
> if (na->initialized_size < na->data_size)
>  memset((u8*)a + val_ofs + na->initialized_size, 0,
>    na->data_size - na->initialized_size);
># 4067 "attrib.c"
> if (ntfs_cluster_free(vol, na, 0, -1) < 0) {
>  err = (*__errno_location ());
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",4069,(1 << 8),((void *)0),"Eeek! Failed to release allocated clusters");
>  do {} while (0);
>
> }
>
>
> free(na->rl);
> na->rl = ((void *)0);
>
>
> ((na)->state) &= ~(1 << (NA_NonResident));
> NAttrClearCompressed(na);
> NAttrClearSparse(na);
> NAttrClearEncrypted(na);
> na->initialized_size = na->data_size;
> na->allocated_size = na->compressed_size = (na->data_size + 7) & ~7;
> na->compression_block_size = 0;
> na->compression_block_size_bits = na->compression_block_clusters = 0;
> return 0;
>}
>
>
>
>
>
>static int ntfs_attr_update_meta(ATTR_RECORD *a, ntfs_attr *na, MFT_RECORD *m,
>     ntfs_attr_search_ctx *ctx)
>{
> int sparse, ret = 0;
>
> do {} while (0);
>
>
> if (a->lowest_vcn)
>  goto out;
>
> a->allocated_size = (s64)((s64)(na->allocated_size));
>
>
> sparse = ntfs_rl_sparse(na->rl);
> if (sparse == -1) {
>  (*__errno_location ()) = 5;
>  goto error;
> }
>
>
> if (sparse && !(a->flags & (ATTR_IS_SPARSE | ATTR_IS_COMPRESSED))) {
>
>
>
>
>
>  if (((u32)((u32)(a->length)) -
>    (u16)((u16)(a->mapping_pairs_offset)) == 8)
>      && !((u32)((u32)(m->bytes_allocated)) -
>    (u32)((u32)(m->bytes_in_use)))) {
>
>   if (!(((na->ni)->state) & (1 << (NI_AttrList)))) {
>    ntfs_attr_put_search_ctx(ctx);
>    if (ntfs_inode_add_attrlist(na->ni))
>     goto leave;
>    goto retry;
>   }
>   if (ntfs_attr_record_move_away(ctx, 8)) {
>    ntfs_log_redirect(__FUNCTION__,"attrib.c",4133,(1 << 8),((void *)0),"Failed to move attribute");
>    goto error;
>   }
>   ntfs_attr_put_search_ctx(ctx);
>   goto retry;
>  }
>  if (!((u32)((u32)(a->length)) - (u16)((u16)(a->mapping_pairs_offset)))) {
>
>   (*__errno_location ()) = 5;
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",4142,(1 << 8),((void *)0),"Mapping pairs space is 0");
>   goto error;
>  }
>
>  NAttrSetSparse(na);
>  a->flags |= ATTR_IS_SPARSE;
>  a->compression_unit = 4;
>
>
>  memmove((u8*)a + (u16)((u16)(a->name_offset)) + 8,
>   (u8*)a + (u16)((u16)(a->name_offset)),
>   a->name_length * sizeof(ntfschar));
>
>  a->name_offset = (u16)((u16)((u16)((u16)(a->name_offset)) + 8));
>
>  a->mapping_pairs_offset =
>   (u16)((u16)((u16)((u16)(a->mapping_pairs_offset)) + 8));
> }
>
>
> if (!sparse && (a->flags & ATTR_IS_SPARSE) &&
>     !(a->flags & ATTR_IS_COMPRESSED)) {
>
>  NAttrClearSparse(na);
>  a->flags &= ~ATTR_IS_SPARSE;
>  a->compression_unit = 0;
>
>  memmove((u8*)a + (u16)((u16)(a->name_offset)) - 8,
>   (u8*)a + (u16)((u16)(a->name_offset)),
>   a->name_length * sizeof(ntfschar));
>
>  if ((u16)((u16)(a->name_offset)) >= 8)
>   a->name_offset = (u16)((u16)((u16)((u16)(a->name_offset)) - 8));
>
>  a->mapping_pairs_offset =
>   (u16)((u16)((u16)((u16)(a->mapping_pairs_offset)) - 8));
> }
>
>
> if (sparse) {
>  s64 new_compr_size;
>
>  new_compr_size = ntfs_rl_get_compressed_size(na->ni->vol, na->rl);
>  if (new_compr_size == -1)
>   goto error;
>
>  na->compressed_size = new_compr_size;
>  a->compressed_size = (s64)((s64)(new_compr_size));
> }
>
>
>
>
> if (na->type == AT_DATA && na->name == AT_UNNAMED) {
>  if (sparse)
>   na->ni->allocated_size = na->compressed_size;
>  else
>   na->ni->allocated_size = na->allocated_size;
>  ((na->ni)->state) |= 1 << (NI_FileNameDirty);
> }
>out:
> return ret;
>leave: ret = -1; goto out;
>retry: ret = -2; goto out;
>error: ret = -3; goto out;
>}
># 4235 "attrib.c"
>int ntfs_attr_update_mapping_pairs(ntfs_attr *na, VCN from_vcn)
>{
> ntfs_attr_search_ctx *ctx;
> ntfs_inode *ni, *base_ni;
> MFT_RECORD *m;
> ATTR_RECORD *a;
> VCN stop_vcn;
> int err, mp_size, cur_max_mp_size, exp_max_mp_size, ret = -1;
> BOOL finished_build;
>retry:
> if (!na || !na->rl || from_vcn) {
>  (*__errno_location ()) = 22;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",4247,(1 << 8),((void *)0),"%s: na=%p", __FUNCTION__, na);
>  return -1;
> }
>
> do {} while (0);
>
>
> if (!(((na)->state) & (1 << (NA_NonResident)))) {
>  (*__errno_location ()) = 22;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",4256,(1 << 8),((void *)0),"%s: resident attribute", __FUNCTION__);
>  return -1;
> }
>
> if (na->ni->nr_extents == -1)
>  base_ni = na->ni->base_ni;
> else
>  base_ni = na->ni;
>
> ctx = ntfs_attr_get_search_ctx(base_ni, ((void *)0));
> if (!ctx)
>  return -1;
>
>
> stop_vcn = 0;
> finished_build = FALSE;
> while (!ntfs_attr_lookup(na->type, na->name, na->name_len,
>    CASE_SENSITIVE, from_vcn, ((void *)0), 0, ctx)) {
>  a = ctx->attr;
>  m = ctx->mrec;
>
>
>
>
>
>
>  if (from_vcn) {
>   LCN first_lcn;
>
>   stop_vcn = (s64)((s64)(a->lowest_vcn));
>   from_vcn = 0;
>
>
>
>
>
>   first_lcn = ntfs_rl_vcn_to_lcn(na->rl, stop_vcn);
>   if (first_lcn == LCN_EINVAL) {
>    err = 5;
>    ntfs_log_redirect(__FUNCTION__,"attrib.c",4295,(1 << 8),((void *)0),"Bad runlist");
>    goto put_err_out;
>   }
>   if (first_lcn == LCN_ENOENT ||
>     first_lcn == LCN_RL_NOT_MAPPED)
>    finished_build = TRUE;
>  }
>
>
>
>
>
>
>
>  if (finished_build) {
>   do {} while (0);
>
>
>   a->highest_vcn = (s64)((s64)(-2));
>   ntfs_inode_mark_dirty(ctx->ntfs_ino);
>   continue;
>  }
>
>  err = ntfs_attr_update_meta(a, na, m, ctx);
>  switch (err) {
>   case -1: return -1;
>   case -2: goto retry;
>   case -3: goto put_err_out;
>  }
>
>
>  mp_size = ntfs_get_size_for_mapping_pairs(na->ni->vol, na->rl,
>        stop_vcn);
>  if (mp_size <= 0) {
>   err = (*__errno_location ());
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",4330,(1 << 8),((void *)0),"%s: get MP size failed", __FUNCTION__);
>   goto put_err_out;
>  }
>
>
>
>
>  cur_max_mp_size = (u32)((u32)(a->length)) -
>    (u16)((u16)(a->mapping_pairs_offset));
>
>
>
>
>
>  exp_max_mp_size = (u32)((u32)(m->bytes_allocated)) -
>    (u32)((u32)(m->bytes_in_use)) + cur_max_mp_size;
>
>  if (mp_size > exp_max_mp_size) {
>
>
>
>
>
>   if (na->type == AT_ATTRIBUTE_LIST) {
>    ntfs_attr_put_search_ctx(ctx);
>    if (ntfs_inode_free_space(na->ni, mp_size -
>       cur_max_mp_size)) {
>     ntfs_log_redirect(__FUNCTION__,"attrib.c",4359,(1 << 8),((void *)0),"Attribute list is too " "big. Defragment the " "volume\n");
>
>
>     return -1;
>    }
>    goto retry;
>   }
>
>
>   if (!(((base_ni)->state) & (1 << (NI_AttrList)))) {
>    ntfs_attr_put_search_ctx(ctx);
>    if (ntfs_inode_add_attrlist(base_ni)) {
>     ntfs_log_redirect(__FUNCTION__,"attrib.c",4369,(1 << 8),((void *)0),"Can not add attrlist");
>     return -1;
>    }
>    goto retry;
>   }
>
>
>
>
>
>
>   mp_size = exp_max_mp_size;
>  }
>
>
>  if (((mp_size + 7) & ~7) != cur_max_mp_size) {
>   if (ntfs_attr_record_resize(m, a,
>     (u16)((u16)(a->mapping_pairs_offset)) +
>     mp_size)) {
>    ntfs_log_redirect(__FUNCTION__,"attrib.c",4388,(1 << 8),((void *)0),"Failed to resize attribute");
>    err = 5;
>    goto put_err_out;
>   }
>  }
>
>
>  a->lowest_vcn = (s64)((s64)(stop_vcn));
>  ntfs_inode_mark_dirty(ctx->ntfs_ino);
>  if ((ctx->ntfs_ino->nr_extents == -1 ||
>     (((ctx->ntfs_ino)->state) & (1 << (NI_AttrList)))) &&
>     ctx->attr->type != AT_ATTRIBUTE_LIST) {
>   ctx->al_entry->lowest_vcn = (s64)((s64)(stop_vcn));
>   ntfs_attrlist_mark_dirty(ctx->ntfs_ino);
>  }
>
>
>
>
>
>  if (!ntfs_mapping_pairs_build(na->ni->vol, (u8*)a + (u16)((u16)(a->mapping_pairs_offset)), mp_size, na->rl,
>
>    stop_vcn, &stop_vcn))
>   finished_build = TRUE;
>  if (!finished_build && (*__errno_location ()) != 28) {
>   err = (*__errno_location ());
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",4414,(1 << 8),((void *)0),"Failed to build mapping pairs");
>   goto put_err_out;
>  }
>  a->highest_vcn = (s64)((s64)(stop_vcn - 1));
> }
>
> if ((*__errno_location ()) != 2) {
>  err = (*__errno_location ());
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",4422,(1 << 8),((void *)0),"%s: Attribute lookup failed", __FUNCTION__);
>  goto put_err_out;
> }
>
>
> if (finished_build) {
>  ntfs_attr_reinit_search_ctx(ctx);
>  do {} while (0);
>  while (!ntfs_attr_lookup(na->type, na->name, na->name_len,
>    CASE_SENSITIVE, 0, ((void *)0), 0, ctx)) {
>   if ((s64)((s64)(ctx->attr->highest_vcn)) !=
>       -2)
>    continue;
>
>   if (ntfs_attr_record_rm(ctx)) {
>    err = (*__errno_location ());
>    ntfs_log_redirect(__FUNCTION__,"attrib.c",4438,(1 << 8),((void *)0),"Could not remove unused attr");
>    goto put_err_out;
>   }
>   ntfs_attr_reinit_search_ctx(ctx);
>  }
>  if ((*__errno_location ()) != 2) {
>   err = (*__errno_location ());
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",4445,(1 << 8),((void *)0),"%s: Attr lookup failed", __FUNCTION__);
>   goto put_err_out;
>  }
>  do {} while (0);
>  ntfs_attr_put_search_ctx(ctx);
>  goto ok;
> }
> ntfs_attr_put_search_ctx(ctx);
> ctx = ((void *)0);
>
>
> while (1) {
>
>  mp_size = ntfs_get_size_for_mapping_pairs(na->ni->vol,
>      na->rl, stop_vcn);
>  if (mp_size <= 0) {
>   err = (*__errno_location ());
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",4462,(1 << 8),((void *)0),"%s: get mp size failed", __FUNCTION__);
>   goto put_err_out;
>  }
>
>  ni = ntfs_mft_record_alloc(na->ni->vol, base_ni);
>  if (!ni) {
>   err = (*__errno_location ());
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",4469,(1 << 8),((void *)0),"Could not allocate new MFT record");
>   goto put_err_out;
>  }
>  m = ni->mrec;
>
>
>
>
>  cur_max_mp_size = (u32)((u32)(m->bytes_allocated)) -
>    (u32)((u32)(m->bytes_in_use)) -
>    (__builtin_offsetof (ATTR_RECORD, compressed_size) +
>    ((NAttrCompressed(na) || NAttrSparse(na)) ?
>    sizeof(a->compressed_size) : 0)) -
>    ((sizeof(ntfschar) * na->name_len + 7) & ~7);
>  if (mp_size > cur_max_mp_size)
>   mp_size = cur_max_mp_size;
>
>  err = ntfs_non_resident_attr_record_add(ni, na->type,
>    na->name, na->name_len, stop_vcn, mp_size, 0);
>  if (err == -1) {
>   err = (*__errno_location ());
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",4490,(1 << 8),((void *)0),"Could not add attribute extent");
>   if (ntfs_mft_record_free(na->ni->vol, ni))
>    ntfs_log_redirect(__FUNCTION__,"attrib.c",4492,(1 << 8),((void *)0),"Could not free MFT record");
>   goto put_err_out;
>  }
>  a = (ATTR_RECORD*)((u8*)m + err);
>
>  err = ntfs_mapping_pairs_build(na->ni->vol, (u8*)a +
>   (u16)((u16)(a->mapping_pairs_offset)), mp_size, na->rl,
>   stop_vcn, &stop_vcn);
>  if (err < 0 && (*__errno_location ()) != 28) {
>   err = (*__errno_location ());
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",4502,(1 << 8),((void *)0),"Failed to build MP");
>   if (ntfs_mft_record_free(na->ni->vol, ni))
>    ntfs_log_redirect(__FUNCTION__,"attrib.c",4504,(1 << 8),((void *)0),"Couldn't free MFT record");
>   goto put_err_out;
>  }
>  a->highest_vcn = (s64)((s64)(stop_vcn - 1));
>  ntfs_inode_mark_dirty(ni);
>
>  if (!err)
>   break;
> }
>ok:
> ret = 0;
>out:
> return ret;
>put_err_out:
> if (ctx)
>  ntfs_attr_put_search_ctx(ctx);
> (*__errno_location ()) = err;
> goto out;
>}
># 4537 "attrib.c"
>static int ntfs_non_resident_attr_shrink(ntfs_attr *na, const s64 newsize)
>{
> ntfs_volume *vol;
> ntfs_attr_search_ctx *ctx;
> VCN first_free_vcn;
> s64 nr_freed_clusters;
> int err;
>
> do {} while (0);
>
>
> vol = na->ni->vol;
>
>
>
>
>
> if (ntfs_attr_size_bounds_check(vol, na->type, newsize) < 0) {
>  if ((*__errno_location ()) == 34) {
>   do {} while (0);
>
>  } else if ((*__errno_location ()) == 2)
>   (*__errno_location ()) = 5;
>  return -1;
> }
>
>
> first_free_vcn = (newsize + vol->cluster_size - 1) >>
>   vol->cluster_size_bits;
>
>
>
>
> if ((na->allocated_size >> vol->cluster_size_bits) != first_free_vcn) {
>  if (ntfs_attr_map_whole_runlist(na)) {
>   do {} while (0);
>
>   return -1;
>  }
>
>  nr_freed_clusters = ntfs_cluster_free(vol, na, first_free_vcn,
>    -1);
>  if (nr_freed_clusters < 0) {
>   do {} while (0);
>
>   return -1;
>  }
>
>
>  if (ntfs_rl_truncate(&na->rl, first_free_vcn)) {
>
>
>
>
>   free(na->rl);
>   na->rl = ((void *)0);
>   do {} while (0);
>   return -1;
>  }
>
>
>  na->allocated_size = first_free_vcn << vol->cluster_size_bits;
>
>  if (ntfs_attr_update_mapping_pairs(na, 0 )) {
>   do {} while (0);
>
>
>   return -1;
>  }
> }
>
>
> ctx = ntfs_attr_get_search_ctx(na->ni, ((void *)0));
> if (!ctx)
>  return -1;
>
> if (ntfs_attr_lookup(na->type, na->name, na->name_len, CASE_SENSITIVE,
>   0, ((void *)0), 0, ctx)) {
>  err = (*__errno_location ());
>  if (err == 2)
>   err = 5;
>  do {} while (0);
>
>  goto put_err_out;
> }
>
>
> na->data_size = newsize;
> ctx->attr->data_size = (s64)((s64)(newsize));
> if (newsize < na->initialized_size) {
>  na->initialized_size = newsize;
>  ctx->attr->initialized_size = (s64)((s64)(newsize));
> }
>
> if (na->type == AT_DATA && na->name == AT_UNNAMED) {
>  na->ni->data_size = na->data_size;
>  ((na->ni)->state) |= 1 << (NI_FileNameDirty);
> }
>
>
> if (!newsize) {
>  if (ntfs_attr_make_resident(na, ctx)) {
>
>   if ((*__errno_location ()) != 1)
>    ntfs_log_redirect(__FUNCTION__,"attrib.c",4642,(1 << 7),((void *)0),"Failed to make attribute " "resident. Leaving as is...\n");
>
>  }
> }
>
>
> ntfs_inode_mark_dirty(ctx->ntfs_ino);
>
> ntfs_attr_put_search_ctx(ctx);
> return 0;
>put_err_out:
> ntfs_attr_put_search_ctx(ctx);
> (*__errno_location ()) = err;
> return -1;
>}
># 4671 "attrib.c"
>static int ntfs_non_resident_attr_expand(ntfs_attr *na, const s64 newsize)
>{
> LCN lcn_seek_from;
> VCN first_free_vcn;
> ntfs_volume *vol;
> ntfs_attr_search_ctx *ctx;
> runlist *rl, *rln;
> s64 org_alloc_size;
> int err;
>
> do {} while (0);
>
>
>
> vol = na->ni->vol;
>
>
>
>
>
> if (ntfs_attr_size_bounds_check(vol, na->type, newsize) < 0) {
>  if ((*__errno_location ()) == 2)
>   (*__errno_location ()) = 5;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",4694,(1 << 8),((void *)0),"%s: bounds check failed", __FUNCTION__);
>  return -1;
> }
>
>
> org_alloc_size = na->allocated_size;
>
> first_free_vcn = (newsize + vol->cluster_size - 1) >>
>   vol->cluster_size_bits;
>
>
>
>
> if ((na->allocated_size >> vol->cluster_size_bits) < first_free_vcn) {
>  if (ntfs_attr_map_whole_runlist(na)) {
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",4709,(1 << 8),((void *)0),"ntfs_attr_map_whole_runlist failed");
>   return -1;
>  }
>
>
>
>
>
>  if (na->type == AT_DATA && vol->major_ver >= 3) {
>   rl = ntfs_malloc(0x1000);
>   if (!rl)
>    return -1;
>
>   rl[0].vcn = (na->allocated_size >>
>     vol->cluster_size_bits);
>   rl[0].lcn = LCN_HOLE;
>   rl[0].length = first_free_vcn -
>    (na->allocated_size >> vol->cluster_size_bits);
>   rl[1].vcn = first_free_vcn;
>   rl[1].lcn = LCN_ENOENT;
>   rl[1].length = 0;
>  } else {
>
>
>
>
>
>
>
>   lcn_seek_from = -1;
>   if (na->rl->length) {
>
>    for (rl = na->rl; (rl + 1)->length; rl++)
>     ;
>
>
>
>
>    while (rl->lcn < 0 && rl != na->rl)
>     rl--;
>
>
>
>    if (rl->lcn >= 0)
>     lcn_seek_from = rl->lcn + rl->length;
>   }
>
>   rl = ntfs_cluster_alloc(vol, na->allocated_size >>
>     vol->cluster_size_bits, first_free_vcn -
>     (na->allocated_size >>
>     vol->cluster_size_bits), lcn_seek_from,
>     DATA_ZONE);
>   if (!rl) {
>    ntfs_log_redirect(__FUNCTION__,"attrib.c",4766,(1 << 8),((void *)0),"Cluster allocation failed " "(%lld)", (long long)first_free_vcn - ((long long)na->allocated_size >> vol->cluster_size_bits));
>
>
>
>
>    return -1;
>   }
>  }
>
>
>  rln = ntfs_runlists_merge(na->rl, rl);
>  if (!rln) {
>
>   err = (*__errno_location ());
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",4776,(1 << 8),((void *)0),"Run list merge failed");
>   ntfs_cluster_free_from_rl(vol, rl);
>   free(rl);
>   (*__errno_location ()) = err;
>   return -1;
>  }
>  na->rl = rln;
>
>
>  na->allocated_size = first_free_vcn << vol->cluster_size_bits;
>
>  if (ntfs_attr_update_mapping_pairs(na, 0 )) {
>
>   err = (*__errno_location ());
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",4790,(1 << 8),((void *)0),"Mapping pairs update failed");
>   goto rollback;
>  }
> }
>
> ctx = ntfs_attr_get_search_ctx(na->ni, ((void *)0));
> if (!ctx) {
>  err = (*__errno_location ());
>  if (na->allocated_size == org_alloc_size) {
>   (*__errno_location ()) = err;
>   return -1;
>  } else
>   goto rollback;
> }
>
> if (ntfs_attr_lookup(na->type, na->name, na->name_len, CASE_SENSITIVE,
>   0, ((void *)0), 0, ctx)) {
>  err = (*__errno_location ());
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",4808,(1 << 8),((void *)0),"Lookup of first attribute extent failed");
>  if (err == 2)
>   err = 5;
>  if (na->allocated_size != org_alloc_size) {
>   ntfs_attr_put_search_ctx(ctx);
>   goto rollback;
>  } else
>   goto put_err_out;
> }
>
>
> na->data_size = newsize;
> ctx->attr->data_size = (s64)((s64)(newsize));
>
> if (na->type == AT_DATA && na->name == AT_UNNAMED) {
>  na->ni->data_size = na->data_size;
>  ((na->ni)->state) |= 1 << (NI_FileNameDirty);
> }
>
> ntfs_inode_mark_dirty(ctx->ntfs_ino);
>
> ntfs_attr_put_search_ctx(ctx);
> return 0;
>rollback:
>
> if (ntfs_cluster_free(vol, na, org_alloc_size >>
>   vol->cluster_size_bits, -1) < 0) {
>  err = 5;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",4836,(1 << 8),((void *)0),"Leaking clusters");
> }
>
> if (ntfs_rl_truncate(&na->rl, org_alloc_size >>
>   vol->cluster_size_bits)) {
>
>
>
>
>  free(na->rl);
>  na->rl = ((void *)0);
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",4847,(1 << 8),((void *)0),"Couldn't truncate runlist. Rollback failed");
> } else {
>
>  na->allocated_size = org_alloc_size << vol->cluster_size_bits;
>
>  if (ntfs_attr_update_mapping_pairs(na, 0 )) {
>
>   ntfs_log_redirect(__FUNCTION__,"attrib.c",4854,(1 << 8),((void *)0),"Failed to restore old mapping pairs");
>  }
> }
> (*__errno_location ()) = err;
> return -1;
>put_err_out:
> ntfs_attr_put_search_ctx(ctx);
> (*__errno_location ()) = err;
> return -1;
>}
># 4885 "attrib.c"
>int ntfs_attr_truncate(ntfs_attr *na, const s64 newsize)
>{
> int ret;
>
> if (!na || newsize < 0 ||
>   (na->ni->mft_no == FILE_MFT && na->type == AT_DATA)) {
>  do {} while (0);
>  (*__errno_location ()) = 22;
>  return (-1);
> }
>
> do {} while (0);
>
>
> if (na->data_size == newsize) {
>  do {} while (0);
>  return (0);
> }
>
>
>
>
> if (NAttrEncrypted(na)) {
>  (*__errno_location ()) = 13;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",4909,(1 << 8),((void *)0),"Failed to truncate encrypted attribute");
>  return (-1);
> }
>
>
>
> if (NAttrCompressed(na)) {
>  (*__errno_location ()) = 95;
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",4917,(1 << 8),((void *)0),"Failed to truncate compressed attribute");
>  return (-1);
> }
> if ((((na)->state) & (1 << (NA_NonResident)))) {
>  if (newsize > na->data_size)
>   ret = ntfs_non_resident_attr_expand(na, newsize);
>  else
>   ret = ntfs_non_resident_attr_shrink(na, newsize);
> } else
>  ret = ntfs_resident_attr_resize(na, newsize);
>
> do {} while (0);
> return ret;
>}
># 4951 "attrib.c"
>void *ntfs_attr_readall(ntfs_inode *ni, const ATTR_TYPES type,
>   ntfschar *name, u32 name_len, s64 *data_size)
>{
> ntfs_attr *na;
> void *data, *ret = ((void *)0);
> s64 size;
>
> do {} while (0);
>
> na = ntfs_attr_open(ni, type, name, name_len);
> if (!na) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",4962,(1 << 8),((void *)0),"ntfs_attr_open failed");
>  return ((void *)0);
> }
> data = ntfs_malloc(na->data_size);
> if (!data)
>  goto out;
>
> size = ntfs_attr_pread(na, 0, na->data_size, data);
> if (size != na->data_size) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",4971,(1 << 8),((void *)0),"ntfs_attr_pread failed");
>  free(data);
>  goto out;
> }
> ret = data;
> if (data_size)
>  *data_size = size;
>out:
> ntfs_attr_close(na);
> return ret;
>}
>
>
>
>int ntfs_attr_exist(ntfs_inode *ni, const ATTR_TYPES type, ntfschar *name,
>      u32 name_len)
>{
> ntfs_attr_search_ctx *ctx;
> int ret;
>
> do {} while (0);
>
> ctx = ntfs_attr_get_search_ctx(ni, ((void *)0));
> if (!ctx)
>  return 0;
>
> ret = ntfs_attr_lookup(type, name, name_len, CASE_SENSITIVE, 0, ((void *)0), 0,
>          ctx);
>
> ntfs_attr_put_search_ctx(ctx);
>
> return !ret;
>}
>
>int ntfs_attr_remove(ntfs_inode *ni, const ATTR_TYPES type, ntfschar *name,
>       u32 name_len)
>{
> ntfs_attr *na;
> int ret;
>
> do {} while (0);
>
> if (!ni) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",5014,(1 << 7),((void *)0),"%s: NULL inode pointer", __FUNCTION__);
>  (*__errno_location ()) = 22;
>  return -1;
> }
>
> na = ntfs_attr_open(ni, type, name, name_len);
> if (!na) {
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",5022,(1 << 8),((void *)0),"Failed to open attribute 0x%02x of inode " "0x%llx", type, (unsigned long long)ni->mft_no);
>
>  return -1;
> }
>
> ret = ntfs_attr_rm(na);
> if (ret)
>  ntfs_log_redirect(__FUNCTION__,"attrib.c",5029,(1 << 8),((void *)0),"Failed to remove attribute 0x%02x of inode " "0x%llx", type, (unsigned long long)ni->mft_no);
>
> ntfs_attr_close(na);
>
> return ret;
>}
>
>s64 ntfs_attr_get_free_bits(ntfs_attr *na)
>{
> u8 *buf;
> s64 nr_free = 0;
> s64 br, total = 0;
>
> buf = ntfs_malloc(na->ni->vol->cluster_size);
> if (!buf)
>  return -1;
> while (1) {
>  int i, j;
>
>  br = ntfs_attr_pread(na, total, na->ni->vol->cluster_size, buf);
>  if (br <= 0)
>   break;
>  total += br;
>  for (i = 0; i < br; i++)
>   for (j = 0; j < 8; j++)
>    if (!((buf[i] >> j) & 1))
>     nr_free++;
> }
> free(buf);
> if (!total || br < 0)
>  return -1;
> return nr_free;
>}

Actions: View

Attachments on bug 354113: 190690 | 194532 | 194750 | 195524