/**

#define _POSIX_PTHREAD_SEMANTICS

#import "common.h"

#define EXPOSE_NSFileManager_IVARS 1

#define EXPOSE_NSDirectoryEnumerator_IVARS 1

#import "Foundation/NSArray.h"

#import "Foundation/NSAutoreleasePool.h"

#import "Foundation/NSData.h"

#import "Foundation/NSDate.h"

#import "Foundation/NSDictionary.h"

#import "Foundation/NSEnumerator.h"

#import "Foundation/NSError.h"

#import "Foundation/NSException.h"

#import "Foundation/NSFileManager.h"

#import "Foundation/NSLock.h"

#import "Foundation/NSPathUtilities.h"

#import "Foundation/NSProcessInfo.h"

#import "Foundation/NSSet.h"

#import "Foundation/NSURL.h"

#import "Foundation/NSValue.h"

#import "GSPrivate.h"

#import "GNUstepBase/NSString+GNUstepBase.h"

#import "GNUstepBase/NSTask+GNUstepBase.h"

#include <stdio.h>

#if defined(HAVE_DIRENT_H)

# include <dirent.h>

#elif defined(HAVE_SYS_DIR_H)

# include <sys/dir.h>

#elif defined(HAVE_SYS_NDIR_H)

# include <sys/ndir.h>

#elif defined(HAVE_NDIR_H)

# include <ndir.h>

#elif defined(_MSC_VER)

# include <win32/dirent.h>

#endif

#ifdef HAVE_WINDOWS_H

# include <windows.h>

#endif

#if defined(_WIN32)

#include <stdio.h>

#include <tchar.h>

#include <wchar.h>

#include <accctrl.h>

#include <aclapi.h>

#define WIN32ERR ((DWORD)0xFFFFFFFF)

#endif

#if defined(_POSIX_VERSION) || defined(_WIN32)

# if defined(_WIN32)

# include <sys/utime.h>

# else

# include <utime.h>

# endif

#endif

#ifdef HAVE_SYS_CDEFS_H

# include <sys/cdefs.h>

#endif

#ifdef HAVE_SYS_SYSLIMITS_H

# include <sys/syslimits.h>

#endif

#ifdef HAVE_SYS_PARAM_H

# include <sys/param.h> /* for MAXPATHLEN */

#endif

#ifndef PATH_MAX

# ifdef _POSIX_VERSION

# define PATH_MAX _POSIX_PATH_MAX

# else

# ifdef MAXPATHLEN

# define PATH_MAX MAXPATHLEN

# else

# define PATH_MAX 1024

# endif

# endif

#endif

#ifdef HAVE_SYS_VFS_H

# include <sys/vfs.h>

#endif

#ifdef HAVE_SYS_STATVFS_H

# include <sys/statvfs.h>

#endif

#ifdef HAVE_SYS_STATFS_H

# include <sys/statfs.h>

#endif

#if defined(HAVE_SYS_FILE_H)

# include <sys/file.h>

#endif

#ifdef HAVE_SYS_MOUNT_H

#include <sys/mount.h>

#endif

#ifdef HAVE_SYS_STAT_H

#include <sys/stat.h>

#endif

#if defined(HAVE_SYS_FCNTL_H)

# include <sys/fcntl.h>

#elif defined(HAVE_FCNTL_H)

# include <fcntl.h>

#endif

#ifdef HAVE_PWD_H

#include <pwd.h> /* For struct passwd */

#endif

#ifdef HAVE_GRP_H

#include <grp.h> /* For struct group */

#endif

#ifdef HAVE_UTIME_H

# include <utime.h>

#endif

#if defined(O_BINARY)

#define GSBINIO O_BINARY

#else

#define GSBINIO 0

#endif

@interface NSDirectoryEnumerator (Local)

- (id) initWithDirectoryPath: (NSString*)path

recurseIntoSubdirectories: (BOOL)recurse

followSymlinks: (BOOL)follow

justContents: (BOOL)justContents

for: (NSFileManager*)mgr;

- (id) initWithDirectoryPath: (NSString*)path

recurseIntoSubdirectories: (BOOL)recurse

followSymlinks: (BOOL)follow

justContents: (BOOL)justContents

skipHidden: (BOOL)skipHidden

errorHandler: (GSDirEnumErrorHandler) handler

for: (NSFileManager*)mgr;

- (void) _setSkipHidden: (BOOL)flag;

- (void) _setErrorHandler: (GSDirEnumErrorHandler) handler;

#if defined(_WIN32)

#define _CHMOD(A,B) _wchmod(A,B)

#define _CLOSEDIR(A) _wclosedir(A)

#define _OPENDIR(A) _wopendir(A)

#define _READDIR(A) _wreaddir(A)

#define _RENAME(A,B) (MoveFileExW(A,B,MOVEFILE_COPY_ALLOWED|MOVEFILE_REPLACE_EXISTING|MOVEFILE_WRITE_THROUGH)==0)?-1:0

#define _RMDIR(A) _wrmdir(A)

#define _STAT(A,B) _wstat(A,B)

#define _UTIME(A,B) _wutime(A,B)

#define _DIR _WDIR

#define _DIRENT _wdirent

#define _STATB _stat

#define _UTIMB _utimbuf

#define _NUL L'\0'

#else

#define _CHMOD(A,B) chmod(A,B)

#define _CLOSEDIR(A) closedir(A)

#define _OPENDIR(A) opendir(A)

#define _READDIR(A) readdir(A)

#define _RENAME(A,B) rename(A,B)

#define _RMDIR(A) rmdir(A)

#define _STAT(A,B) stat(A,B)

#define _UTIME(A,B) utime(A,B)

#define _DIR DIR

#define _DIRENT dirent

#define _STATB stat

#define _UTIMB utimbuf

#define _NUL '\0'

#endif

#define _CHAR GSNativeChar

#define _CCP const _CHAR*

@interface GSAttrDictionary : NSDictionary

{

struct _STATB statbuf;

_CHAR _path[0];

}

+ (NSDictionary*) attributesAt: (NSString *)path

traverseLink: (BOOL)traverse;

static Class GSAttrDictionaryClass = 0;

@interface GSAttrDictionaryEnumerator : NSEnumerator

{

NSDictionary *dictionary;

NSEnumerator *enumerator;

}

+ (NSEnumerator*) enumeratorFor: (NSDictionary*)d;

@interface NSFileManager (PrivateMethods)

- (BOOL) _copyFile: (NSString*)source

toFile: (NSString*)destination

handler: (id)handler;

- (BOOL) _copyPath: (NSString*)source

toPath: (NSString*)destination

handler: (id)handler;

- (BOOL) _linkPath: (NSString*)source

toPath: (NSString*)destination

handler: handler;

- (void) _sendToHandler: (id) handler

willProcessPath: (NSString*) path;

- (BOOL) _proceedAccordingToHandler: (id) handler

forError: (NSString*) error

inPath: (NSString*) path;

- (BOOL) _proceedAccordingToHandler: (id) handler

forError: (NSString*) error

inPath: (NSString*) path

fromPath: (NSString*) fromPath

toPath: (NSString*) toPath;

- (NSError*) _errorFrom: (NSString*)fromPath to: (NSString*)toPath;

@end /* NSFileManager (PrivateMethods) */

@implementation NSFileManager

static NSFileManager* defaultManager = nil;

static NSStringEncoding defaultEncoding;

+ (NSFileManager*) defaultManager

{

if (defaultManager == nil)

{

NS_DURING

{

[gnustep_global_lock lock];

if (defaultManager == nil)

{

defaultManager = [[self alloc] init];

}

[gnustep_global_lock unlock];

}

NS_HANDLER

{

// unlock then re-raise the exception

[gnustep_global_lock unlock];

[localException raise];

}

NS_ENDHANDLER

}

return defaultManager;

}

+ (void) initialize

{

defaultEncoding = [NSString defaultCStringEncoding];

GSAttrDictionaryClass = [GSAttrDictionary class];

}

- (void) dealloc

{

TEST_RELEASE(_lastError);

[super dealloc];

}

- (id<NSFileManagerDelegate>) delegate

{

return _delegate;

}

- (void) setDelegate: (id<NSFileManagerDelegate>)delegate

{

_delegate = delegate;

}

- (BOOL) changeCurrentDirectoryPath: (NSString*)path

{

static Class bundleClass = 0;

const _CHAR *lpath = [self fileSystemRepresentationWithPath: path];

/*

if (bundleClass == 0)

{

bundleClass = [NSBundle class];

}

#if defined(_WIN32)

return SetCurrentDirectoryW(lpath) == TRUE ? YES : NO;

#else

return (chdir(lpath) == 0) ? YES : NO;

#endif

}

- (BOOL) changeFileAttributes: (NSDictionary*)attributes atPath: (NSString*)path

{

NSDictionary *old;

const _CHAR *lpath = 0;

NSUInteger num;

NSString *str;

NSDate *date;

BOOL allOk = YES;

if (0 == [attributes count])

{

return YES;

}

old = [self fileAttributesAtPath: path traverseLink: YES];

lpath = [defaultManager fileSystemRepresentationWithPath: path];

#ifndef _WIN32

if (object_getClass(attributes) == GSAttrDictionaryClass)

{

num = ((GSAttrDictionary*)attributes)->statbuf.st_uid;

}

else

{

NSNumber *tmpNum = [attributes fileOwnerAccountID];

num = tmpNum ? [tmpNum unsignedLongValue] : NSNotFound;

}

if (num != NSNotFound && num != [[old fileOwnerAccountID] unsignedLongValue])

{

if (chown(lpath, num, -1) != 0)

{

allOk = NO;

str = [NSString stringWithFormat:

@"Unable to change NSFileOwnerAccountID to '%"PRIuPTR"' - %@",

num, [NSError _last]];

ASSIGN(_lastError, str);

}

}

else

{

if ((str = [attributes fileOwnerAccountName]) != nil

&& NO == [str isEqual: [old fileOwnerAccountName]])

{

BOOL ok = NO;

#ifdef HAVE_PWD_H

#if defined(HAVE_GETPWNAM_R)

struct passwd pw;

struct passwd *p;

char buf[BUFSIZ*10];

if (getpwnam_r([str cStringUsingEncoding: defaultEncoding],

&pw, buf, sizeof(buf), &p) == 0)

{

ok = (chown(lpath, pw.pw_uid, -1) == 0);

(void)chown(lpath, -1, pw.pw_gid);

}

#else

#if defined(HAVE_GETPWNAM)

struct passwd *pw;

[gnustep_global_lock lock];

pw = getpwnam([str cStringUsingEncoding: defaultEncoding]);

if (pw != 0)

{

ok = (chown(lpath, pw->pw_uid, -1) == 0);

(void)chown(lpath, -1, pw->pw_gid);

}

[gnustep_global_lock unlock];

#endif

#endif

#endif

if (ok == NO)

{

allOk = NO;

str = [NSString stringWithFormat:

@"Unable to change NSFileOwnerAccountName to '%@' - %@",

str, [NSError _last]];

ASSIGN(_lastError, str);

}

}

}

if (object_getClass(attributes) == GSAttrDictionaryClass)

{

num = ((GSAttrDictionary*)attributes)->statbuf.st_gid;

}

else

{

NSNumber *tmpNum = [attributes fileGroupOwnerAccountID];

num = tmpNum ? [tmpNum unsignedLongValue] : NSNotFound;

}

if (num != NSNotFound

&& num != [[old fileGroupOwnerAccountID] unsignedLongValue])

{

if (chown(lpath, -1, num) != 0)

{

allOk = NO;

str = [NSString stringWithFormat:

@"Unable to change NSFileGroupOwnerAccountID to '%"PRIuPTR"' - %@",

num, [NSError _last]];

ASSIGN(_lastError, str);

}

}

else if ((str = [attributes fileGroupOwnerAccountName]) != nil

&& NO == [str isEqual: [old fileGroupOwnerAccountName]])

{

BOOL ok = NO;

#ifdef HAVE_GRP_H

#ifdef HAVE_GETGRNAM_R

struct group gp;

struct group *p;

char buf[BUFSIZ*10];

if (getgrnam_r([str cStringUsingEncoding: defaultEncoding], &gp,

buf, sizeof(buf), &p) == 0)

{

if (chown(lpath, -1, gp.gr_gid) == 0)

ok = YES;

}

#else

#ifdef HAVE_GETGRNAM

struct group *gp;

[gnustep_global_lock lock];

gp = getgrnam([str cStringUsingEncoding: defaultEncoding]);

if (gp)

{

if (chown(lpath, -1, gp->gr_gid) == 0)

ok = YES;

}

[gnustep_global_lock unlock];

#endif

#endif

#endif

if (ok == NO)

{

allOk = NO;

str = [NSString stringWithFormat:

@"Unable to change NSFileGroupOwnerAccountName to '%@' - %@",

str, [NSError _last]];

ASSIGN(_lastError, str);

}

}

#endif /* _WIN32 */

num = [attributes filePosixPermissions];

if (num != NSNotFound && num != [old filePosixPermissions])

{

if (_CHMOD(lpath, num) != 0)

{

allOk = NO;

str = [NSString stringWithFormat:

@"Unable to change NSFilePosixPermissions to '%o' - %@",

(unsigned)num, [NSError _last]];

ASSIGN(_lastError, str);

}

}

date = [attributes fileCreationDate];

if (date != nil && NO == [date isEqual: [old fileCreationDate]])

{

BOOL ok = NO;

struct _STATB sb;

const _CHAR *lpath;

lpath = [self fileSystemRepresentationWithPath: path];

if (_STAT(lpath, &sb) != 0)

{

ok = NO;

}

#if defined(_WIN32)

else if (sb.st_mode & _S_IFDIR)

{

ok = YES; // Directories don't have creation times.

}

#endif

else

{

#if defined(_WIN32)

FILETIME ctime;

HANDLE fh;

ULONGLONG nanosecs = ((ULONGLONG)([date timeIntervalSince1970]*10000000)+116444736000000000ULL);

fh = CreateFileW(lpath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL );

if (fh == INVALID_HANDLE_VALUE)

{

ok = NO;

}

else

{

ctime.dwLowDateTime = (DWORD) (nanosecs & 0xFFFFFFFF );

ctime.dwHighDateTime = (DWORD) (nanosecs >> 32 );

ok = SetFileTime(fh, &ctime, NULL, NULL);

CloseHandle(fh);

}

#else

NSTimeInterval ti = [date timeIntervalSince1970];

#if defined (HAVE_UTIMENSAT)

struct timespec ub[2];

ub[0].tv_sec = 0;

ub[0].tv_nsec = UTIME_OMIT; // we don't touch access time

ub[1].tv_sec = (time_t)trunc(ti);

ub[1].tv_nsec = (long)trunc((ti - trunc(ti)) * 1.0e9);

ok = (utimensat(AT_FDCWD, lpath, ub, 0) == 0);

#elif defined(_POSIX_VERSION)

struct _UTIMB ub;

ub.actime = sb.st_atime;

ub.modtime = ti;

ok = (_UTIME(lpath, &ub) == 0);

#else

time_t ub[2];

ub[0] = sb.st_atime;

ub[1] = ti;

ok = (_UTIME(lpath, ub) == 0);

#endif

#endif

}

if (ok == NO)

{

allOk = NO;

str = [NSString stringWithFormat:

@"Unable to change NSFileCreationDate to '%@' - %@",

date, [NSError _last]];

ASSIGN(_lastError, str);

}

}

date = [attributes fileModificationDate];

if (date != nil && NO == [date isEqual: [old fileModificationDate]])

{

BOOL ok = NO;

struct _STATB sb;

if (_STAT(lpath, &sb) != 0)

{

ok = NO;

}

#if defined(_WIN32)

else if (sb.st_mode & _S_IFDIR)

{

ok = YES; // Directories don't have modification times.

}

#endif

else

{

NSTimeInterval ti = [date timeIntervalSince1970];

#if defined (HAVE_UTIMENSAT)

struct timespec ub[2];

ub[0].tv_sec = 0;

ub[0].tv_nsec = UTIME_OMIT; // we don't touch access time

ub[1].tv_sec = (time_t)trunc(ti);

ub[1].tv_nsec = (long)trunc((ti - trunc(ti)) * 1.0e9);

ok = (utimensat(AT_FDCWD, lpath, ub, 0) == 0);

#elif defined(_WIN32) || defined(_POSIX_VERSION)

struct _UTIMB ub;

ub.actime = sb.st_atime;

ub.modtime = ti;

ok = (_UTIME(lpath, &ub) == 0);

#else

time_t ub[2];

ub[0] = sb.st_atime;

ub[1] = ti;

ok = (_UTIME(lpath, ub) == 0);

#endif

}

if (ok == NO)

{

allOk = NO;

str = [NSString stringWithFormat:

@"Unable to change NSFileModificationDate to '%@' - %@",

date, [NSError _last]];

ASSIGN(_lastError, str);

}

}

return allOk;

}

- (NSArray*) componentsToDisplayForPath: (NSString*)path

{

return [path pathComponents];

}

- (NSData*) contentsAtPath: (NSString*)path

{

return [NSData dataWithContentsOfFile: path];

}

- (BOOL) contentsEqualAtPath: (NSString*)path1 andPath: (NSString*)path2

{

NSDictionary *d1;

NSDictionary *d2;

NSString *t;

if ([path1 isEqual: path2])

return YES;

d1 = [self fileAttributesAtPath: path1 traverseLink: NO];

d2 = [self fileAttributesAtPath: path2 traverseLink: NO];

t = [d1 fileType];

if ([t isEqual: [d2 fileType]] == NO)

{

return NO;

}

if ([t isEqual: NSFileTypeRegular])

{

if ([d1 fileSize] == [d2 fileSize])

{

NSData *c1 = [NSData dataWithContentsOfFile: path1];

NSData *c2 = [NSData dataWithContentsOfFile: path2];

if ([c1 isEqual: c2])

{

return YES;

}

}

return NO;

}

else if ([t isEqual: NSFileTypeDirectory])

{

NSArray *a1 = [self directoryContentsAtPath: path1];

NSArray *a2 = [self directoryContentsAtPath: path2];

unsigned index, count = [a1 count];

BOOL ok = YES;

if ([a1 isEqual: a2] == NO)

{

return NO;

}

for (index = 0; ok == YES && index < count; index++)

{

NSString *n = [a1 objectAtIndex: index];

NSString *p1;

NSString *p2;

ENTER_POOL

p1 = [path1 stringByAppendingPathComponent: n];

p2 = [path2 stringByAppendingPathComponent: n];

d1 = [self fileAttributesAtPath: p1 traverseLink: NO];

d2 = [self fileAttributesAtPath: p2 traverseLink: NO];

t = [d1 fileType];

if ([t isEqual: [d2 fileType]] == NO)

{

ok = NO;

}

else if ([t isEqual: NSFileTypeDirectory]

|| [t isEqual: NSFileTypeRegular])

{

ok = [self contentsEqualAtPath: p1 andPath: p2];

}

LEAVE_POOL

}

return ok;

}

else

{

return YES;

}

}

- (NSArray*) contentsOfDirectoryAtURL: (NSURL*)url

includingPropertiesForKeys: (NSArray*)keys

options: (NSDirectoryEnumerationOptions)mask

error: (NSError **)error

{

NSArray *result;

NSDirectoryEnumerator *direnum;

NSString *path;

DESTROY(_lastError);

if (![[url scheme] isEqualToString: @"file"])

{

return nil;

}

path = [url path];

direnum = [[NSDirectoryEnumerator alloc]

initWithDirectoryPath: path

recurseIntoSubdirectories: NO

followSymlinks: NO

justContents: NO

for: self];

/* we make an array of NSURLs */

result = nil;

if (nil != direnum)

{

IMP nxtImp;

NSMutableArray *urlArray;

NSString *tempPath;

nxtImp = [direnum methodForSelector: @selector(nextObject)];

urlArray = [NSMutableArray arrayWithCapacity: 128];

while ((tempPath = (*nxtImp)(direnum, @selector(nextObject))) != nil)

{

NSURL *tempURL;

NSString *lastComponent;

tempURL = [NSURL fileURLWithPath: tempPath];

lastComponent = [tempPath lastPathComponent];

/* we purge files beginning with . */

if (!((mask & NSDirectoryEnumerationSkipsHiddenFiles)

&& [lastComponent hasPrefix: @"."]))

{

[urlArray addObject: tempURL];

}

}

RELEASE(direnum);

if ([urlArray count] > 0)

{

result = [NSArray arrayWithArray: urlArray];

}

}

if (error != NULL)

{

if (nil == result)

{

*error = [self _errorFrom: path to: nil];

}

}

return result;

}

- (NSURL *)URLForDirectory: (NSSearchPathDirectory)directory

inDomain: (NSSearchPathDomainMask)domain

appropriateForURL: (NSURL *)url

create: (BOOL)shouldCreate

error: (NSError **)error

{

NSURL *result = nil;

NSArray *urlArray = NSSearchPathForDirectoriesInDomains(directory, domain, YES);

// Find out the URL exists...

if ([urlArray count] > 0)

{

result = [NSURL URLWithString: [urlArray objectAtIndex: 0]];

}

if (directory == NSItemReplacementDirectory)

{

result = [NSURL URLWithString: NSTemporaryDirectory()];

}

if (![self fileExistsAtPath: [result absoluteString]])

{

// If we should created it, create it...

if (shouldCreate)

{

[self createDirectoryAtPath: [result absoluteString]

withIntermediateDirectories: YES

attributes: nil

error: error];

}

}

return result;

}

- (NSDirectoryEnumerator *)enumeratorAtURL: (NSURL *)url

includingPropertiesForKeys: (NSArray *)keys

options: (NSDirectoryEnumerationOptions)mask

errorHandler: (GSDirEnumErrorHandler)handler

{

NSDirectoryEnumerator *direnum;

NSString *path;

DESTROY(_lastError);

if (![[url scheme] isEqualToString: @"file"])

{

return nil;

}

path = [url path];

direnum = [[NSDirectoryEnumerator alloc]

initWithDirectoryPath: path

recurseIntoSubdirectories: !(mask & NSDirectoryEnumerationSkipsSubdirectoryDescendants)

followSymlinks: NO

justContents: NO

skipHidden: (mask & NSDirectoryEnumerationSkipsHiddenFiles)

errorHandler: handler

for: self];

return direnum;

}

- (NSArray*) contentsOfDirectoryAtPath: (NSString*)path error: (NSError**)error

{

NSArray *result;

DESTROY(_lastError);

result = [self directoryContentsAtPath: path];

if (error != NULL)

{

if (nil == result)

{

*error = [self _errorFrom: path to: nil];

}

}

return result;

}

- (BOOL) createDirectoryAtPath: (NSString *)path

withIntermediateDirectories: (BOOL)flag

attributes: (NSDictionary *)attributes

error: (NSError **)error

{

BOOL result = NO;

DESTROY(_lastError);

if (YES == flag)

{

NSEnumerator *paths = [[path pathComponents] objectEnumerator];

NSString *path = nil;

NSString *dir = [NSString string];

result = YES;

while (YES == result && (path = (NSString *)[paths nextObject]) != nil)

{

dir = [dir stringByAppendingPathComponent: path];

// create directory only if it doesn't exist

if (NO == [self fileExistsAtPath: dir])

{

result = [self createDirectoryAtPath: dir

attributes: attributes];

}

}

}

else

{

BOOL isDir;

if ([self fileExistsAtPath: [path stringByDeletingLastPathComponent]

isDirectory: &isDir] && isDir)

{

result = [self createDirectoryAtPath: path

attributes: attributes];

}

else

{

result = NO;

ASSIGN(_lastError, @"Could not create directory - intermediate path did not exist or was not a directory");

}

}

if (error != NULL)

{

if (NO == result)

{

*error = [self _errorFrom: path to: nil];